vulkaninfo/generated/vulkaninfo.hpp

   1
   2 /*
   3  * Copyright (c) 2019 The Khronos Group Inc.
   4  * Copyright (c) 2019 Valve Corporation
   5  * Copyright (c) 2019 LunarG, Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  * Author: Charles Giessen <charles@lunarg.com>
  20  *
  21  */
  22
  23 /*
  24  * This file is generated from the Khronos Vulkan XML API Registry.
  25  */
  26
  27 #include "vulkaninfo.h"
  28 #include "outputprinter.h"
  29
  30 void DumpVkConformanceVersion(Printer &p, std::string name, VkConformanceVersion &c, int width = 0) {
  31     p.PrintKeyString("conformanceVersion", std::to_string(c.major)+ "." + std::to_string(c.minor) + "." + std::to_string(c.subminor) + "."
  32              + std::to_string(c.patch), width);
  33 }
  34
  35 template <typename T>
  36 std::string to_hex_str(T i) {
  37     std::stringstream stream;
  38     stream << "0x" << std::setfill('0') << std::setw(sizeof(T)) << std::hex << i;
  39     return stream.str();
  40 }
  41
  42 template <typename T>
  43 std::string to_hex_str(Printer &p, T i) {
  44     if (p.Type() == OutputType::json)
  45         return std::to_string(i);
  46     else if (p.Type() == OutputType::vkconfig_output)
  47         return std::string("\"") + to_hex_str(i) + std::string("\"");
  48     else
  49         return to_hex_str(i);
  50 }
  51 static const char *VkResultString(VkResult value) {
  52     switch (value) {
  53         case (0): return "SUCCESS";
  54         case (1): return "NOT_READY";
  55         case (2): return "TIMEOUT";
  56         case (3): return "EVENT_SET";
  57         case (4): return "EVENT_RESET";
  58         case (5): return "INCOMPLETE";
  59         case (-1): return "ERROR_OUT_OF_HOST_MEMORY";
  60         case (-2): return "ERROR_OUT_OF_DEVICE_MEMORY";
  61         case (-3): return "ERROR_INITIALIZATION_FAILED";
  62         case (-4): return "ERROR_DEVICE_LOST";
  63         case (-5): return "ERROR_MEMORY_MAP_FAILED";
  64         case (-6): return "ERROR_LAYER_NOT_PRESENT";
  65         case (-7): return "ERROR_EXTENSION_NOT_PRESENT";
  66         case (-8): return "ERROR_FEATURE_NOT_PRESENT";
  67         case (-9): return "ERROR_INCOMPATIBLE_DRIVER";
  68         case (-10): return "ERROR_TOO_MANY_OBJECTS";
  69         case (-11): return "ERROR_FORMAT_NOT_SUPPORTED";
  70         case (-12): return "ERROR_FRAGMENTED_POOL";
  71         case (-13): return "ERROR_UNKNOWN";
  72         case (-1000069000): return "ERROR_OUT_OF_POOL_MEMORY";
  73         case (-1000072003): return "ERROR_INVALID_EXTERNAL_HANDLE";
  74         case (-1000161000): return "ERROR_FRAGMENTATION";
  75         case (-1000257000): return "ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS";
  76         case (-1000000000): return "ERROR_SURFACE_LOST_KHR";
  77         case (-1000000001): return "ERROR_NATIVE_WINDOW_IN_USE_KHR";
  78         case (1000001003): return "SUBOPTIMAL_KHR";
  79         case (-1000001004): return "ERROR_OUT_OF_DATE_KHR";
  80         case (-1000003001): return "ERROR_INCOMPATIBLE_DISPLAY_KHR";
  81         case (-1000011001): return "ERROR_VALIDATION_FAILED_EXT";
  82         case (-1000012000): return "ERROR_INVALID_SHADER_NV";
  83         case (-1000158000): return "ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
  84         case (-1000174001): return "ERROR_NOT_PERMITTED_EXT";
  85         case (-1000255000): return "ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
  86         default: return "UNKNOWN_VkResult";
  87     }
  88 }
  89 void DumpVkResult(Printer &p, std::string name, VkResult value, int width = 0) {
  90     if (p.Type() == OutputType::json) {
  91         p.PrintKeyValue(name, value, width);
  92     } else {
  93         p.PrintKeyString(name, VkResultString(value), width);
  94     }
  95 }
  96 static const char *VkFormatString(VkFormat value) {
  97     switch (value) {
  98         case (0): return "FORMAT_UNDEFINED";
  99         case (1): return "FORMAT_R4G4_UNORM_PACK8";
 100         case (2): return "FORMAT_R4G4B4A4_UNORM_PACK16";
 101         case (3): return "FORMAT_B4G4R4A4_UNORM_PACK16";
 102         case (4): return "FORMAT_R5G6B5_UNORM_PACK16";
 103         case (5): return "FORMAT_B5G6R5_UNORM_PACK16";
 104         case (6): return "FORMAT_R5G5B5A1_UNORM_PACK16";
 105         case (7): return "FORMAT_B5G5R5A1_UNORM_PACK16";
 106         case (8): return "FORMAT_A1R5G5B5_UNORM_PACK16";
 107         case (9): return "FORMAT_R8_UNORM";
 108         case (10): return "FORMAT_R8_SNORM";
 109         case (11): return "FORMAT_R8_USCALED";
 110         case (12): return "FORMAT_R8_SSCALED";
 111         case (13): return "FORMAT_R8_UINT";
 112         case (14): return "FORMAT_R8_SINT";
 113         case (15): return "FORMAT_R8_SRGB";
 114         case (16): return "FORMAT_R8G8_UNORM";
 115         case (17): return "FORMAT_R8G8_SNORM";
 116         case (18): return "FORMAT_R8G8_USCALED";
 117         case (19): return "FORMAT_R8G8_SSCALED";
 118         case (20): return "FORMAT_R8G8_UINT";
 119         case (21): return "FORMAT_R8G8_SINT";
 120         case (22): return "FORMAT_R8G8_SRGB";
 121         case (23): return "FORMAT_R8G8B8_UNORM";
 122         case (24): return "FORMAT_R8G8B8_SNORM";
 123         case (25): return "FORMAT_R8G8B8_USCALED";
 124         case (26): return "FORMAT_R8G8B8_SSCALED";
 125         case (27): return "FORMAT_R8G8B8_UINT";
 126         case (28): return "FORMAT_R8G8B8_SINT";
 127         case (29): return "FORMAT_R8G8B8_SRGB";
 128         case (30): return "FORMAT_B8G8R8_UNORM";
 129         case (31): return "FORMAT_B8G8R8_SNORM";
 130         case (32): return "FORMAT_B8G8R8_USCALED";
 131         case (33): return "FORMAT_B8G8R8_SSCALED";
 132         case (34): return "FORMAT_B8G8R8_UINT";
 133         case (35): return "FORMAT_B8G8R8_SINT";
 134         case (36): return "FORMAT_B8G8R8_SRGB";
 135         case (37): return "FORMAT_R8G8B8A8_UNORM";
 136         case (38): return "FORMAT_R8G8B8A8_SNORM";
 137         case (39): return "FORMAT_R8G8B8A8_USCALED";
 138         case (40): return "FORMAT_R8G8B8A8_SSCALED";
 139         case (41): return "FORMAT_R8G8B8A8_UINT";
 140         case (42): return "FORMAT_R8G8B8A8_SINT";
 141         case (43): return "FORMAT_R8G8B8A8_SRGB";
 142         case (44): return "FORMAT_B8G8R8A8_UNORM";
 143         case (45): return "FORMAT_B8G8R8A8_SNORM";
 144         case (46): return "FORMAT_B8G8R8A8_USCALED";
 145         case (47): return "FORMAT_B8G8R8A8_SSCALED";
 146         case (48): return "FORMAT_B8G8R8A8_UINT";
 147         case (49): return "FORMAT_B8G8R8A8_SINT";
 148         case (50): return "FORMAT_B8G8R8A8_SRGB";
 149         case (51): return "FORMAT_A8B8G8R8_UNORM_PACK32";
 150         case (52): return "FORMAT_A8B8G8R8_SNORM_PACK32";
 151         case (53): return "FORMAT_A8B8G8R8_USCALED_PACK32";
 152         case (54): return "FORMAT_A8B8G8R8_SSCALED_PACK32";
 153         case (55): return "FORMAT_A8B8G8R8_UINT_PACK32";
 154         case (56): return "FORMAT_A8B8G8R8_SINT_PACK32";
 155         case (57): return "FORMAT_A8B8G8R8_SRGB_PACK32";
 156         case (58): return "FORMAT_A2R10G10B10_UNORM_PACK32";
 157         case (59): return "FORMAT_A2R10G10B10_SNORM_PACK32";
 158         case (60): return "FORMAT_A2R10G10B10_USCALED_PACK32";
 159         case (61): return "FORMAT_A2R10G10B10_SSCALED_PACK32";
 160         case (62): return "FORMAT_A2R10G10B10_UINT_PACK32";
 161         case (63): return "FORMAT_A2R10G10B10_SINT_PACK32";
 162         case (64): return "FORMAT_A2B10G10R10_UNORM_PACK32";
 163         case (65): return "FORMAT_A2B10G10R10_SNORM_PACK32";
 164         case (66): return "FORMAT_A2B10G10R10_USCALED_PACK32";
 165         case (67): return "FORMAT_A2B10G10R10_SSCALED_PACK32";
 166         case (68): return "FORMAT_A2B10G10R10_UINT_PACK32";
 167         case (69): return "FORMAT_A2B10G10R10_SINT_PACK32";
 168         case (70): return "FORMAT_R16_UNORM";
 169         case (71): return "FORMAT_R16_SNORM";
 170         case (72): return "FORMAT_R16_USCALED";
 171         case (73): return "FORMAT_R16_SSCALED";
 172         case (74): return "FORMAT_R16_UINT";
 173         case (75): return "FORMAT_R16_SINT";
 174         case (76): return "FORMAT_R16_SFLOAT";
 175         case (77): return "FORMAT_R16G16_UNORM";
 176         case (78): return "FORMAT_R16G16_SNORM";
 177         case (79): return "FORMAT_R16G16_USCALED";
 178         case (80): return "FORMAT_R16G16_SSCALED";
 179         case (81): return "FORMAT_R16G16_UINT";
 180         case (82): return "FORMAT_R16G16_SINT";
 181         case (83): return "FORMAT_R16G16_SFLOAT";
 182         case (84): return "FORMAT_R16G16B16_UNORM";
 183         case (85): return "FORMAT_R16G16B16_SNORM";
 184         case (86): return "FORMAT_R16G16B16_USCALED";
 185         case (87): return "FORMAT_R16G16B16_SSCALED";
 186         case (88): return "FORMAT_R16G16B16_UINT";
 187         case (89): return "FORMAT_R16G16B16_SINT";
 188         case (90): return "FORMAT_R16G16B16_SFLOAT";
 189         case (91): return "FORMAT_R16G16B16A16_UNORM";
 190         case (92): return "FORMAT_R16G16B16A16_SNORM";
 191         case (93): return "FORMAT_R16G16B16A16_USCALED";
 192         case (94): return "FORMAT_R16G16B16A16_SSCALED";
 193         case (95): return "FORMAT_R16G16B16A16_UINT";
 194         case (96): return "FORMAT_R16G16B16A16_SINT";
 195         case (97): return "FORMAT_R16G16B16A16_SFLOAT";
 196         case (98): return "FORMAT_R32_UINT";
 197         case (99): return "FORMAT_R32_SINT";
 198         case (100): return "FORMAT_R32_SFLOAT";
 199         case (101): return "FORMAT_R32G32_UINT";
 200         case (102): return "FORMAT_R32G32_SINT";
 201         case (103): return "FORMAT_R32G32_SFLOAT";
 202         case (104): return "FORMAT_R32G32B32_UINT";
 203         case (105): return "FORMAT_R32G32B32_SINT";
 204         case (106): return "FORMAT_R32G32B32_SFLOAT";
 205         case (107): return "FORMAT_R32G32B32A32_UINT";
 206         case (108): return "FORMAT_R32G32B32A32_SINT";
 207         case (109): return "FORMAT_R32G32B32A32_SFLOAT";
 208         case (110): return "FORMAT_R64_UINT";
 209         case (111): return "FORMAT_R64_SINT";
 210         case (112): return "FORMAT_R64_SFLOAT";
 211         case (113): return "FORMAT_R64G64_UINT";
 212         case (114): return "FORMAT_R64G64_SINT";
 213         case (115): return "FORMAT_R64G64_SFLOAT";
 214         case (116): return "FORMAT_R64G64B64_UINT";
 215         case (117): return "FORMAT_R64G64B64_SINT";
 216         case (118): return "FORMAT_R64G64B64_SFLOAT";
 217         case (119): return "FORMAT_R64G64B64A64_UINT";
 218         case (120): return "FORMAT_R64G64B64A64_SINT";
 219         case (121): return "FORMAT_R64G64B64A64_SFLOAT";
 220         case (122): return "FORMAT_B10G11R11_UFLOAT_PACK32";
 221         case (123): return "FORMAT_E5B9G9R9_UFLOAT_PACK32";
 222         case (124): return "FORMAT_D16_UNORM";
 223         case (125): return "FORMAT_X8_D24_UNORM_PACK32";
 224         case (126): return "FORMAT_D32_SFLOAT";
 225         case (127): return "FORMAT_S8_UINT";
 226         case (128): return "FORMAT_D16_UNORM_S8_UINT";
 227         case (129): return "FORMAT_D24_UNORM_S8_UINT";
 228         case (130): return "FORMAT_D32_SFLOAT_S8_UINT";
 229         case (131): return "FORMAT_BC1_RGB_UNORM_BLOCK";
 230         case (132): return "FORMAT_BC1_RGB_SRGB_BLOCK";
 231         case (133): return "FORMAT_BC1_RGBA_UNORM_BLOCK";
 232         case (134): return "FORMAT_BC1_RGBA_SRGB_BLOCK";
 233         case (135): return "FORMAT_BC2_UNORM_BLOCK";
 234         case (136): return "FORMAT_BC2_SRGB_BLOCK";
 235         case (137): return "FORMAT_BC3_UNORM_BLOCK";
 236         case (138): return "FORMAT_BC3_SRGB_BLOCK";
 237         case (139): return "FORMAT_BC4_UNORM_BLOCK";
 238         case (140): return "FORMAT_BC4_SNORM_BLOCK";
 239         case (141): return "FORMAT_BC5_UNORM_BLOCK";
 240         case (142): return "FORMAT_BC5_SNORM_BLOCK";
 241         case (143): return "FORMAT_BC6H_UFLOAT_BLOCK";
 242         case (144): return "FORMAT_BC6H_SFLOAT_BLOCK";
 243         case (145): return "FORMAT_BC7_UNORM_BLOCK";
 244         case (146): return "FORMAT_BC7_SRGB_BLOCK";
 245         case (147): return "FORMAT_ETC2_R8G8B8_UNORM_BLOCK";
 246         case (148): return "FORMAT_ETC2_R8G8B8_SRGB_BLOCK";
 247         case (149): return "FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK";
 248         case (150): return "FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK";
 249         case (151): return "FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK";
 250         case (152): return "FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK";
 251         case (153): return "FORMAT_EAC_R11_UNORM_BLOCK";
 252         case (154): return "FORMAT_EAC_R11_SNORM_BLOCK";
 253         case (155): return "FORMAT_EAC_R11G11_UNORM_BLOCK";
 254         case (156): return "FORMAT_EAC_R11G11_SNORM_BLOCK";
 255         case (157): return "FORMAT_ASTC_4x4_UNORM_BLOCK";
 256         case (158): return "FORMAT_ASTC_4x4_SRGB_BLOCK";
 257         case (159): return "FORMAT_ASTC_5x4_UNORM_BLOCK";
 258         case (160): return "FORMAT_ASTC_5x4_SRGB_BLOCK";
 259         case (161): return "FORMAT_ASTC_5x5_UNORM_BLOCK";
 260         case (162): return "FORMAT_ASTC_5x5_SRGB_BLOCK";
 261         case (163): return "FORMAT_ASTC_6x5_UNORM_BLOCK";
 262         case (164): return "FORMAT_ASTC_6x5_SRGB_BLOCK";
 263         case (165): return "FORMAT_ASTC_6x6_UNORM_BLOCK";
 264         case (166): return "FORMAT_ASTC_6x6_SRGB_BLOCK";
 265         case (167): return "FORMAT_ASTC_8x5_UNORM_BLOCK";
 266         case (168): return "FORMAT_ASTC_8x5_SRGB_BLOCK";
 267         case (169): return "FORMAT_ASTC_8x6_UNORM_BLOCK";
 268         case (170): return "FORMAT_ASTC_8x6_SRGB_BLOCK";
 269         case (171): return "FORMAT_ASTC_8x8_UNORM_BLOCK";
 270         case (172): return "FORMAT_ASTC_8x8_SRGB_BLOCK";
 271         case (173): return "FORMAT_ASTC_10x5_UNORM_BLOCK";
 272         case (174): return "FORMAT_ASTC_10x5_SRGB_BLOCK";
 273         case (175): return "FORMAT_ASTC_10x6_UNORM_BLOCK";
 274         case (176): return "FORMAT_ASTC_10x6_SRGB_BLOCK";
 275         case (177): return "FORMAT_ASTC_10x8_UNORM_BLOCK";
 276         case (178): return "FORMAT_ASTC_10x8_SRGB_BLOCK";
 277         case (179): return "FORMAT_ASTC_10x10_UNORM_BLOCK";
 278         case (180): return "FORMAT_ASTC_10x10_SRGB_BLOCK";
 279         case (181): return "FORMAT_ASTC_12x10_UNORM_BLOCK";
 280         case (182): return "FORMAT_ASTC_12x10_SRGB_BLOCK";
 281         case (183): return "FORMAT_ASTC_12x12_UNORM_BLOCK";
 282         case (184): return "FORMAT_ASTC_12x12_SRGB_BLOCK";
 283         case (1000156000): return "FORMAT_G8B8G8R8_422_UNORM";
 284         case (1000156001): return "FORMAT_B8G8R8G8_422_UNORM";
 285         case (1000156002): return "FORMAT_G8_B8_R8_3PLANE_420_UNORM";
 286         case (1000156003): return "FORMAT_G8_B8R8_2PLANE_420_UNORM";
 287         case (1000156004): return "FORMAT_G8_B8_R8_3PLANE_422_UNORM";
 288         case (1000156005): return "FORMAT_G8_B8R8_2PLANE_422_UNORM";
 289         case (1000156006): return "FORMAT_G8_B8_R8_3PLANE_444_UNORM";
 290         case (1000156007): return "FORMAT_R10X6_UNORM_PACK16";
 291         case (1000156008): return "FORMAT_R10X6G10X6_UNORM_2PACK16";
 292         case (1000156009): return "FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16";
 293         case (1000156010): return "FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16";
 294         case (1000156011): return "FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16";
 295         case (1000156012): return "FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16";
 296         case (1000156013): return "FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16";
 297         case (1000156014): return "FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16";
 298         case (1000156015): return "FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16";
 299         case (1000156016): return "FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16";
 300         case (1000156017): return "FORMAT_R12X4_UNORM_PACK16";
 301         case (1000156018): return "FORMAT_R12X4G12X4_UNORM_2PACK16";
 302         case (1000156019): return "FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16";
 303         case (1000156020): return "FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16";
 304         case (1000156021): return "FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16";
 305         case (1000156022): return "FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16";
 306         case (1000156023): return "FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16";
 307         case (1000156024): return "FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16";
 308         case (1000156025): return "FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16";
 309         case (1000156026): return "FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16";
 310         case (1000156027): return "FORMAT_G16B16G16R16_422_UNORM";
 311         case (1000156028): return "FORMAT_B16G16R16G16_422_UNORM";
 312         case (1000156029): return "FORMAT_G16_B16_R16_3PLANE_420_UNORM";
 313         case (1000156030): return "FORMAT_G16_B16R16_2PLANE_420_UNORM";
 314         case (1000156031): return "FORMAT_G16_B16_R16_3PLANE_422_UNORM";
 315         case (1000156032): return "FORMAT_G16_B16R16_2PLANE_422_UNORM";
 316         case (1000156033): return "FORMAT_G16_B16_R16_3PLANE_444_UNORM";
 317         case (1000054000): return "FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG";
 318         case (1000054001): return "FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG";
 319         case (1000054002): return "FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG";
 320         case (1000054003): return "FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG";
 321         case (1000054004): return "FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG";
 322         case (1000054005): return "FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG";
 323         case (1000054006): return "FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG";
 324         case (1000054007): return "FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
 325         case (1000066000): return "FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT";
 326         case (1000066001): return "FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT";
 327         case (1000066002): return "FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT";
 328         case (1000066003): return "FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT";
 329         case (1000066004): return "FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT";
 330         case (1000066005): return "FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT";
 331         case (1000066006): return "FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT";
 332         case (1000066007): return "FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT";
 333         case (1000066008): return "FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT";
 334         case (1000066009): return "FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT";
 335         case (1000066010): return "FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT";
 336         case (1000066011): return "FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT";
 337         case (1000066012): return "FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT";
 338         case (1000066013): return "FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT";
 339         default: return "UNKNOWN_VkFormat";
 340     }
 341 }
 342 void DumpVkFormat(Printer &p, std::string name, VkFormat value, int width = 0) {
 343     if (p.Type() == OutputType::json) {
 344         p.PrintKeyValue(name, value, width);
 345     } else {
 346         p.PrintKeyString(name, VkFormatString(value), width);
 347     }
 348 }
 349 static const char *VkImageTilingString(VkImageTiling value) {
 350     switch (value) {
 351         case (0): return "IMAGE_TILING_OPTIMAL";
 352         case (1): return "IMAGE_TILING_LINEAR";
 353         case (1000158000): return "IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT";
 354         default: return "UNKNOWN_VkImageTiling";
 355     }
 356 }
 357 void DumpVkImageTiling(Printer &p, std::string name, VkImageTiling value, int width = 0) {
 358     if (p.Type() == OutputType::json) {
 359         p.PrintKeyValue(name, value, width);
 360     } else {
 361         p.PrintKeyString(name, VkImageTilingString(value), width);
 362     }
 363 }
 364 static const char *VkPhysicalDeviceTypeString(VkPhysicalDeviceType value) {
 365     switch (value) {
 366         case (0): return "PHYSICAL_DEVICE_TYPE_OTHER";
 367         case (1): return "PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU";
 368         case (2): return "PHYSICAL_DEVICE_TYPE_DISCRETE_GPU";
 369         case (3): return "PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU";
 370         case (4): return "PHYSICAL_DEVICE_TYPE_CPU";
 371         default: return "UNKNOWN_VkPhysicalDeviceType";
 372     }
 373 }
 374 void DumpVkPhysicalDeviceType(Printer &p, std::string name, VkPhysicalDeviceType value, int width = 0) {
 375     if (p.Type() == OutputType::json) {
 376         p.PrintKeyValue(name, value, width);
 377     } else {
 378         p.PrintKeyString(name, VkPhysicalDeviceTypeString(value), width);
 379     }
 380 }
 381 static const char *VkPointClippingBehaviorString(VkPointClippingBehavior value) {
 382     switch (value) {
 383         case (0): return "POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
 384         case (1): return "POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
 385         default: return "UNKNOWN_VkPointClippingBehavior";
 386     }
 387 }
 388 void DumpVkPointClippingBehavior(Printer &p, std::string name, VkPointClippingBehavior value, int width = 0) {
 389     if (p.Type() == OutputType::json) {
 390         p.PrintKeyValue(name, value, width);
 391     } else {
 392         p.PrintKeyString(name, VkPointClippingBehaviorString(value), width);
 393     }
 394 }
 395 static const char *VkDriverIdString(VkDriverId value) {
 396     switch (value) {
 397         case (1): return "DRIVER_ID_AMD_PROPRIETARY";
 398         case (2): return "DRIVER_ID_AMD_OPEN_SOURCE";
 399         case (3): return "DRIVER_ID_MESA_RADV";
 400         case (4): return "DRIVER_ID_NVIDIA_PROPRIETARY";
 401         case (5): return "DRIVER_ID_INTEL_PROPRIETARY_WINDOWS";
 402         case (6): return "DRIVER_ID_INTEL_OPEN_SOURCE_MESA";
 403         case (7): return "DRIVER_ID_IMAGINATION_PROPRIETARY";
 404         case (8): return "DRIVER_ID_QUALCOMM_PROPRIETARY";
 405         case (9): return "DRIVER_ID_ARM_PROPRIETARY";
 406         case (10): return "DRIVER_ID_GOOGLE_SWIFTSHADER";
 407         case (11): return "DRIVER_ID_GGP_PROPRIETARY";
 408         case (12): return "DRIVER_ID_BROADCOM_PROPRIETARY";
 409         default: return "UNKNOWN_VkDriverId";
 410     }
 411 }
 412 void DumpVkDriverId(Printer &p, std::string name, VkDriverId value, int width = 0) {
 413     if (p.Type() == OutputType::json) {
 414         p.PrintKeyValue(name, value, width);
 415     } else {
 416         p.PrintKeyString(name, VkDriverIdString(value), width);
 417     }
 418 }
 419 static const char *VkShaderFloatControlsIndependenceString(VkShaderFloatControlsIndependence value) {
 420     switch (value) {
 421         case (0): return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY";
 422         case (1): return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL";
 423         case (2): return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE";
 424         default: return "UNKNOWN_VkShaderFloatControlsIndependence";
 425     }
 426 }
 427 void DumpVkShaderFloatControlsIndependence(Printer &p, std::string name, VkShaderFloatControlsIndependence value, int width = 0) {
 428     if (p.Type() == OutputType::json) {
 429         p.PrintKeyValue(name, value, width);
 430     } else {
 431         p.PrintKeyString(name, VkShaderFloatControlsIndependenceString(value), width);
 432     }
 433 }
 434 static const char *VkColorSpaceKHRString(VkColorSpaceKHR value) {
 435     switch (value) {
 436         case (0): return "COLOR_SPACE_SRGB_NONLINEAR_KHR";
 437         case (1000104001): return "COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT";
 438         case (1000104002): return "COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT";
 439         case (1000104003): return "COLOR_SPACE_DISPLAY_P3_LINEAR_EXT";
 440         case (1000104004): return "COLOR_SPACE_DCI_P3_NONLINEAR_EXT";
 441         case (1000104005): return "COLOR_SPACE_BT709_LINEAR_EXT";
 442         case (1000104006): return "COLOR_SPACE_BT709_NONLINEAR_EXT";
 443         case (1000104007): return "COLOR_SPACE_BT2020_LINEAR_EXT";
 444         case (1000104008): return "COLOR_SPACE_HDR10_ST2084_EXT";
 445         case (1000104009): return "COLOR_SPACE_DOLBYVISION_EXT";
 446         case (1000104010): return "COLOR_SPACE_HDR10_HLG_EXT";
 447         case (1000104011): return "COLOR_SPACE_ADOBERGB_LINEAR_EXT";
 448         case (1000104012): return "COLOR_SPACE_ADOBERGB_NONLINEAR_EXT";
 449         case (1000104013): return "COLOR_SPACE_PASS_THROUGH_EXT";
 450         case (1000104014): return "COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT";
 451         case (1000213000): return "COLOR_SPACE_DISPLAY_NATIVE_AMD";
 452         default: return "UNKNOWN_VkColorSpaceKHR";
 453     }
 454 }
 455 void DumpVkColorSpaceKHR(Printer &p, std::string name, VkColorSpaceKHR value, int width = 0) {
 456     if (p.Type() == OutputType::json) {
 457         p.PrintKeyValue(name, value, width);
 458     } else {
 459         p.PrintKeyString(name, VkColorSpaceKHRString(value), width);
 460     }
 461 }
 462 static const char *VkPresentModeKHRString(VkPresentModeKHR value) {
 463     switch (value) {
 464         case (0): return "PRESENT_MODE_IMMEDIATE_KHR";
 465         case (1): return "PRESENT_MODE_MAILBOX_KHR";
 466         case (2): return "PRESENT_MODE_FIFO_KHR";
 467         case (3): return "PRESENT_MODE_FIFO_RELAXED_KHR";
 468         case (1000111000): return "PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR";
 469         case (1000111001): return "PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR";
 470         default: return "UNKNOWN_VkPresentModeKHR";
 471     }
 472 }
 473 void DumpVkPresentModeKHR(Printer &p, std::string name, VkPresentModeKHR value, int width = 0) {
 474     if (p.Type() == OutputType::json) {
 475         p.PrintKeyValue(name, value, width);
 476     } else {
 477         p.PrintKeyString(name, VkPresentModeKHRString(value), width);
 478     }
 479 }
 480 std::vector<const char *>VkFormatFeatureFlagBitsGetStrings(VkFormatFeatureFlagBits value) {
 481     std::vector<const char *> strings;
 482     if (value == 0) strings.push_back("None");
 483     if (0x1 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_BIT");
 484     if (0x2 & value) strings.push_back("FORMAT_FEATURE_STORAGE_IMAGE_BIT");
 485     if (0x4 & value) strings.push_back("FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT");
 486     if (0x8 & value) strings.push_back("FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT");
 487     if (0x10 & value) strings.push_back("FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT");
 488     if (0x20 & value) strings.push_back("FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT");
 489     if (0x40 & value) strings.push_back("FORMAT_FEATURE_VERTEX_BUFFER_BIT");
 490     if (0x80 & value) strings.push_back("FORMAT_FEATURE_COLOR_ATTACHMENT_BIT");
 491     if (0x100 & value) strings.push_back("FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT");
 492     if (0x200 & value) strings.push_back("FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT");
 493     if (0x400 & value) strings.push_back("FORMAT_FEATURE_BLIT_SRC_BIT");
 494     if (0x800 & value) strings.push_back("FORMAT_FEATURE_BLIT_DST_BIT");
 495     if (0x1000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT");
 496     if (0x4000 & value) strings.push_back("FORMAT_FEATURE_TRANSFER_SRC_BIT");
 497     if (0x8000 & value) strings.push_back("FORMAT_FEATURE_TRANSFER_DST_BIT");
 498     if (0x20000 & value) strings.push_back("FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT");
 499     if (0x40000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT");
 500     if (0x80000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT");
 501     if (0x100000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT");
 502     if (0x200000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT");
 503     if (0x400000 & value) strings.push_back("FORMAT_FEATURE_DISJOINT_BIT");
 504     if (0x800000 & value) strings.push_back("FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT");
 505     if (0x10000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT");
 506     if (0x2000 & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG");
 507     if (0x1000000 & value) strings.push_back("FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT");
 508     return strings;
 509 }
 510 void DumpVkFormatFeatureFlags(Printer &p, std::string name, VkFormatFeatureFlags value, int width = 0) {
 511     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 512     auto strings = VkFormatFeatureFlagBitsGetStrings(static_cast<VkFormatFeatureFlagBits>(value));
 513     if (static_cast<VkFormatFeatureFlagBits>(value) == 0) {
 514         ArrayWrapper arr(p, name, 0);
 515         p.SetAsType().PrintString("None");
 516         return;
 517     }
 518     ArrayWrapper arr(p, name, strings.size());
 519     for(auto& str : strings){
 520         p.SetAsType().PrintString(str);
 521     }
 522 }
 523 void DumpVkFormatFeatureFlagBits(Printer &p, std::string name, VkFormatFeatureFlagBits value, int width = 0) {
 524     auto strings = VkFormatFeatureFlagBitsGetStrings(value);
 525     p.PrintKeyString(name, strings.at(0), width);
 526 }
 527
 528 std::vector<const char *>VkImageUsageFlagBitsGetStrings(VkImageUsageFlagBits value) {
 529     std::vector<const char *> strings;
 530     if (value == 0) strings.push_back("None");
 531     if (0x1 & value) strings.push_back("IMAGE_USAGE_TRANSFER_SRC_BIT");
 532     if (0x2 & value) strings.push_back("IMAGE_USAGE_TRANSFER_DST_BIT");
 533     if (0x4 & value) strings.push_back("IMAGE_USAGE_SAMPLED_BIT");
 534     if (0x8 & value) strings.push_back("IMAGE_USAGE_STORAGE_BIT");
 535     if (0x10 & value) strings.push_back("IMAGE_USAGE_COLOR_ATTACHMENT_BIT");
 536     if (0x20 & value) strings.push_back("IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT");
 537     if (0x40 & value) strings.push_back("IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT");
 538     if (0x80 & value) strings.push_back("IMAGE_USAGE_INPUT_ATTACHMENT_BIT");
 539     if (0x100 & value) strings.push_back("IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV");
 540     if (0x200 & value) strings.push_back("IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT");
 541     return strings;
 542 }
 543 void DumpVkImageUsageFlags(Printer &p, std::string name, VkImageUsageFlags value, int width = 0) {
 544     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 545     auto strings = VkImageUsageFlagBitsGetStrings(static_cast<VkImageUsageFlagBits>(value));
 546     if (static_cast<VkImageUsageFlagBits>(value) == 0) {
 547         ArrayWrapper arr(p, name, 0);
 548         p.SetAsType().PrintString("None");
 549         return;
 550     }
 551     ArrayWrapper arr(p, name, strings.size());
 552     for(auto& str : strings){
 553         p.SetAsType().PrintString(str);
 554     }
 555 }
 556 void DumpVkImageUsageFlagBits(Printer &p, std::string name, VkImageUsageFlagBits value, int width = 0) {
 557     auto strings = VkImageUsageFlagBitsGetStrings(value);
 558     p.PrintKeyString(name, strings.at(0), width);
 559 }
 560
 561 std::vector<const char *>VkSampleCountFlagBitsGetStrings(VkSampleCountFlagBits value) {
 562     std::vector<const char *> strings;
 563     if (value == 0) strings.push_back("None");
 564     if (0x1 & value) strings.push_back("SAMPLE_COUNT_1_BIT");
 565     if (0x2 & value) strings.push_back("SAMPLE_COUNT_2_BIT");
 566     if (0x4 & value) strings.push_back("SAMPLE_COUNT_4_BIT");
 567     if (0x8 & value) strings.push_back("SAMPLE_COUNT_8_BIT");
 568     if (0x10 & value) strings.push_back("SAMPLE_COUNT_16_BIT");
 569     if (0x20 & value) strings.push_back("SAMPLE_COUNT_32_BIT");
 570     if (0x40 & value) strings.push_back("SAMPLE_COUNT_64_BIT");
 571     return strings;
 572 }
 573 void DumpVkSampleCountFlags(Printer &p, std::string name, VkSampleCountFlags value, int width = 0) {
 574     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 575     auto strings = VkSampleCountFlagBitsGetStrings(static_cast<VkSampleCountFlagBits>(value));
 576     if (static_cast<VkSampleCountFlagBits>(value) == 0) {
 577         ArrayWrapper arr(p, name, 0);
 578         p.SetAsType().PrintString("None");
 579         return;
 580     }
 581     ArrayWrapper arr(p, name, strings.size());
 582     for(auto& str : strings){
 583         p.SetAsType().PrintString(str);
 584     }
 585 }
 586 void DumpVkSampleCountFlagBits(Printer &p, std::string name, VkSampleCountFlagBits value, int width = 0) {
 587     auto strings = VkSampleCountFlagBitsGetStrings(value);
 588     p.PrintKeyString(name, strings.at(0), width);
 589 }
 590
 591 std::string VkQueueFlagsString(VkQueueFlags value, int width = 0) {
 592     std::string out;
 593     bool is_first = true;
 594     if (1 & value) {
 595         if (is_first) { is_first = false; } else { out += " | "; }
 596         out += "QUEUE_GRAPHICS";
 597     }
 598     if (2 & value) {
 599         if (is_first) { is_first = false; } else { out += " | "; }
 600         out += "QUEUE_COMPUTE";
 601     }
 602     if (4 & value) {
 603         if (is_first) { is_first = false; } else { out += " | "; }
 604         out += "QUEUE_TRANSFER";
 605     }
 606     if (8 & value) {
 607         if (is_first) { is_first = false; } else { out += " | "; }
 608         out += "QUEUE_SPARSE_BINDING";
 609     }
 610     if (16 & value) {
 611         if (is_first) { is_first = false; } else { out += " | "; }
 612         out += "QUEUE_PROTECTED";
 613     }
 614     return out;
 615 }
 616 std::vector<const char *>VkMemoryPropertyFlagBitsGetStrings(VkMemoryPropertyFlagBits value) {
 617     std::vector<const char *> strings;
 618     if (value == 0) strings.push_back("None");
 619     if (0x1 & value) strings.push_back("MEMORY_PROPERTY_DEVICE_LOCAL_BIT");
 620     if (0x2 & value) strings.push_back("MEMORY_PROPERTY_HOST_VISIBLE_BIT");
 621     if (0x4 & value) strings.push_back("MEMORY_PROPERTY_HOST_COHERENT_BIT");
 622     if (0x8 & value) strings.push_back("MEMORY_PROPERTY_HOST_CACHED_BIT");
 623     if (0x10 & value) strings.push_back("MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT");
 624     if (0x20 & value) strings.push_back("MEMORY_PROPERTY_PROTECTED_BIT");
 625     if (0x40 & value) strings.push_back("MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD");
 626     if (0x80 & value) strings.push_back("MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD");
 627     return strings;
 628 }
 629 void DumpVkMemoryPropertyFlags(Printer &p, std::string name, VkMemoryPropertyFlags value, int width = 0) {
 630     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 631     auto strings = VkMemoryPropertyFlagBitsGetStrings(static_cast<VkMemoryPropertyFlagBits>(value));
 632     if (static_cast<VkMemoryPropertyFlagBits>(value) == 0) {
 633         ArrayWrapper arr(p, name, 0);
 634         p.SetAsType().PrintString("None");
 635         return;
 636     }
 637     ArrayWrapper arr(p, name, strings.size());
 638     for(auto& str : strings){
 639         p.SetAsType().PrintString(str);
 640     }
 641 }
 642 void DumpVkMemoryPropertyFlagBits(Printer &p, std::string name, VkMemoryPropertyFlagBits value, int width = 0) {
 643     auto strings = VkMemoryPropertyFlagBitsGetStrings(value);
 644     p.PrintKeyString(name, strings.at(0), width);
 645 }
 646
 647 std::vector<const char *>VkMemoryHeapFlagBitsGetStrings(VkMemoryHeapFlagBits value) {
 648     std::vector<const char *> strings;
 649     if (value == 0) strings.push_back("None");
 650     if (0x1 & value) strings.push_back("MEMORY_HEAP_DEVICE_LOCAL_BIT");
 651     if (0x2 & value) strings.push_back("MEMORY_HEAP_MULTI_INSTANCE_BIT");
 652     return strings;
 653 }
 654 void DumpVkMemoryHeapFlags(Printer &p, std::string name, VkMemoryHeapFlags value, int width = 0) {
 655     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 656     auto strings = VkMemoryHeapFlagBitsGetStrings(static_cast<VkMemoryHeapFlagBits>(value));
 657     if (static_cast<VkMemoryHeapFlagBits>(value) == 0) {
 658         ArrayWrapper arr(p, name, 0);
 659         p.SetAsType().PrintString("None");
 660         return;
 661     }
 662     ArrayWrapper arr(p, name, strings.size());
 663     for(auto& str : strings){
 664         p.SetAsType().PrintString(str);
 665     }
 666 }
 667 void DumpVkMemoryHeapFlagBits(Printer &p, std::string name, VkMemoryHeapFlagBits value, int width = 0) {
 668     auto strings = VkMemoryHeapFlagBitsGetStrings(value);
 669     p.PrintKeyString(name, strings.at(0), width);
 670 }
 671
 672 std::vector<const char *>VkShaderStageFlagBitsGetStrings(VkShaderStageFlagBits value) {
 673     std::vector<const char *> strings;
 674     if (value == 0) strings.push_back("None");
 675     if (0x1 & value) strings.push_back("SHADER_STAGE_VERTEX_BIT");
 676     if (0x2 & value) strings.push_back("SHADER_STAGE_TESSELLATION_CONTROL_BIT");
 677     if (0x4 & value) strings.push_back("SHADER_STAGE_TESSELLATION_EVALUATION_BIT");
 678     if (0x8 & value) strings.push_back("SHADER_STAGE_GEOMETRY_BIT");
 679     if (0x10 & value) strings.push_back("SHADER_STAGE_FRAGMENT_BIT");
 680     if (0x20 & value) strings.push_back("SHADER_STAGE_COMPUTE_BIT");
 681     if (0x0000001F & value) strings.push_back("SHADER_STAGE_ALL_GRAPHICS");
 682     if (0x7FFFFFFF & value) strings.push_back("SHADER_STAGE_ALL");
 683     if (0x100 & value) strings.push_back("SHADER_STAGE_RAYGEN_BIT_NV");
 684     if (0x200 & value) strings.push_back("SHADER_STAGE_ANY_HIT_BIT_NV");
 685     if (0x400 & value) strings.push_back("SHADER_STAGE_CLOSEST_HIT_BIT_NV");
 686     if (0x800 & value) strings.push_back("SHADER_STAGE_MISS_BIT_NV");
 687     if (0x1000 & value) strings.push_back("SHADER_STAGE_INTERSECTION_BIT_NV");
 688     if (0x2000 & value) strings.push_back("SHADER_STAGE_CALLABLE_BIT_NV");
 689     if (0x40 & value) strings.push_back("SHADER_STAGE_TASK_BIT_NV");
 690     if (0x80 & value) strings.push_back("SHADER_STAGE_MESH_BIT_NV");
 691     return strings;
 692 }
 693 void DumpVkShaderStageFlags(Printer &p, std::string name, VkShaderStageFlags value, int width = 0) {
 694     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 695     auto strings = VkShaderStageFlagBitsGetStrings(static_cast<VkShaderStageFlagBits>(value));
 696     if (static_cast<VkShaderStageFlagBits>(value) == 0) {
 697         ArrayWrapper arr(p, name, 0);
 698         p.SetAsType().PrintString("None");
 699         return;
 700     }
 701     ArrayWrapper arr(p, name, strings.size());
 702     for(auto& str : strings){
 703         p.SetAsType().PrintString(str);
 704     }
 705 }
 706 void DumpVkShaderStageFlagBits(Printer &p, std::string name, VkShaderStageFlagBits value, int width = 0) {
 707     auto strings = VkShaderStageFlagBitsGetStrings(value);
 708     p.PrintKeyString(name, strings.at(0), width);
 709 }
 710
 711 std::vector<const char *>VkSubgroupFeatureFlagBitsGetStrings(VkSubgroupFeatureFlagBits value) {
 712     std::vector<const char *> strings;
 713     if (value == 0) strings.push_back("None");
 714     if (0x1 & value) strings.push_back("SUBGROUP_FEATURE_BASIC_BIT");
 715     if (0x2 & value) strings.push_back("SUBGROUP_FEATURE_VOTE_BIT");
 716     if (0x4 & value) strings.push_back("SUBGROUP_FEATURE_ARITHMETIC_BIT");
 717     if (0x8 & value) strings.push_back("SUBGROUP_FEATURE_BALLOT_BIT");
 718     if (0x10 & value) strings.push_back("SUBGROUP_FEATURE_SHUFFLE_BIT");
 719     if (0x20 & value) strings.push_back("SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT");
 720     if (0x40 & value) strings.push_back("SUBGROUP_FEATURE_CLUSTERED_BIT");
 721     if (0x80 & value) strings.push_back("SUBGROUP_FEATURE_QUAD_BIT");
 722     if (0x100 & value) strings.push_back("SUBGROUP_FEATURE_PARTITIONED_BIT_NV");
 723     return strings;
 724 }
 725 void DumpVkSubgroupFeatureFlags(Printer &p, std::string name, VkSubgroupFeatureFlags value, int width = 0) {
 726     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 727     auto strings = VkSubgroupFeatureFlagBitsGetStrings(static_cast<VkSubgroupFeatureFlagBits>(value));
 728     if (static_cast<VkSubgroupFeatureFlagBits>(value) == 0) {
 729         ArrayWrapper arr(p, name, 0);
 730         p.SetAsType().PrintString("None");
 731         return;
 732     }
 733     ArrayWrapper arr(p, name, strings.size());
 734     for(auto& str : strings){
 735         p.SetAsType().PrintString(str);
 736     }
 737 }
 738 void DumpVkSubgroupFeatureFlagBits(Printer &p, std::string name, VkSubgroupFeatureFlagBits value, int width = 0) {
 739     auto strings = VkSubgroupFeatureFlagBitsGetStrings(value);
 740     p.PrintKeyString(name, strings.at(0), width);
 741 }
 742
 743 std::vector<const char *>VkResolveModeFlagBitsGetStrings(VkResolveModeFlagBits value) {
 744     std::vector<const char *> strings;
 745     if (value == 0) strings.push_back("None");
 746     if (0 & value) strings.push_back("RESOLVE_MODE_NONE");
 747     if (0x1 & value) strings.push_back("RESOLVE_MODE_SAMPLE_ZERO_BIT");
 748     if (0x2 & value) strings.push_back("RESOLVE_MODE_AVERAGE_BIT");
 749     if (0x4 & value) strings.push_back("RESOLVE_MODE_MIN_BIT");
 750     if (0x8 & value) strings.push_back("RESOLVE_MODE_MAX_BIT");
 751     return strings;
 752 }
 753 void DumpVkResolveModeFlags(Printer &p, std::string name, VkResolveModeFlags value, int width = 0) {
 754     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 755     auto strings = VkResolveModeFlagBitsGetStrings(static_cast<VkResolveModeFlagBits>(value));
 756     if (static_cast<VkResolveModeFlagBits>(value) == 0) {
 757         ArrayWrapper arr(p, name, 0);
 758         p.SetAsType().PrintString("None");
 759         return;
 760     }
 761     ArrayWrapper arr(p, name, strings.size());
 762     for(auto& str : strings){
 763         p.SetAsType().PrintString(str);
 764     }
 765 }
 766 void DumpVkResolveModeFlagBits(Printer &p, std::string name, VkResolveModeFlagBits value, int width = 0) {
 767     auto strings = VkResolveModeFlagBitsGetStrings(value);
 768     p.PrintKeyString(name, strings.at(0), width);
 769 }
 770
 771 std::vector<const char *>VkSurfaceTransformFlagBitsKHRGetStrings(VkSurfaceTransformFlagBitsKHR value) {
 772     std::vector<const char *> strings;
 773     if (value == 0) strings.push_back("None");
 774     if (0x1 & value) strings.push_back("SURFACE_TRANSFORM_IDENTITY_BIT_KHR");
 775     if (0x2 & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_90_BIT_KHR");
 776     if (0x4 & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_180_BIT_KHR");
 777     if (0x8 & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_270_BIT_KHR");
 778     if (0x10 & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR");
 779     if (0x20 & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR");
 780     if (0x40 & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR");
 781     if (0x80 & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR");
 782     if (0x100 & value) strings.push_back("SURFACE_TRANSFORM_INHERIT_BIT_KHR");
 783     return strings;
 784 }
 785 void DumpVkSurfaceTransformFlagsKHR(Printer &p, std::string name, VkSurfaceTransformFlagsKHR value, int width = 0) {
 786     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 787     auto strings = VkSurfaceTransformFlagBitsKHRGetStrings(static_cast<VkSurfaceTransformFlagBitsKHR>(value));
 788     if (static_cast<VkSurfaceTransformFlagBitsKHR>(value) == 0) {
 789         ArrayWrapper arr(p, name, 0);
 790         p.SetAsType().PrintString("None");
 791         return;
 792     }
 793     ArrayWrapper arr(p, name, strings.size());
 794     for(auto& str : strings){
 795         p.SetAsType().PrintString(str);
 796     }
 797 }
 798 void DumpVkSurfaceTransformFlagBitsKHR(Printer &p, std::string name, VkSurfaceTransformFlagBitsKHR value, int width = 0) {
 799     auto strings = VkSurfaceTransformFlagBitsKHRGetStrings(value);
 800     p.PrintKeyString(name, strings.at(0), width);
 801 }
 802
 803 std::vector<const char *>VkCompositeAlphaFlagBitsKHRGetStrings(VkCompositeAlphaFlagBitsKHR value) {
 804     std::vector<const char *> strings;
 805     if (value == 0) strings.push_back("None");
 806     if (0x1 & value) strings.push_back("COMPOSITE_ALPHA_OPAQUE_BIT_KHR");
 807     if (0x2 & value) strings.push_back("COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR");
 808     if (0x4 & value) strings.push_back("COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR");
 809     if (0x8 & value) strings.push_back("COMPOSITE_ALPHA_INHERIT_BIT_KHR");
 810     return strings;
 811 }
 812 void DumpVkCompositeAlphaFlagsKHR(Printer &p, std::string name, VkCompositeAlphaFlagsKHR value, int width = 0) {
 813     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 814     auto strings = VkCompositeAlphaFlagBitsKHRGetStrings(static_cast<VkCompositeAlphaFlagBitsKHR>(value));
 815     if (static_cast<VkCompositeAlphaFlagBitsKHR>(value) == 0) {
 816         ArrayWrapper arr(p, name, 0);
 817         p.SetAsType().PrintString("None");
 818         return;
 819     }
 820     ArrayWrapper arr(p, name, strings.size());
 821     for(auto& str : strings){
 822         p.SetAsType().PrintString(str);
 823     }
 824 }
 825 void DumpVkCompositeAlphaFlagBitsKHR(Printer &p, std::string name, VkCompositeAlphaFlagBitsKHR value, int width = 0) {
 826     auto strings = VkCompositeAlphaFlagBitsKHRGetStrings(value);
 827     p.PrintKeyString(name, strings.at(0), width);
 828 }
 829
 830 std::vector<const char *>VkDeviceGroupPresentModeFlagBitsKHRGetStrings(VkDeviceGroupPresentModeFlagBitsKHR value) {
 831     std::vector<const char *> strings;
 832     if (value == 0) strings.push_back("None");
 833     if (0x1 & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR");
 834     if (0x2 & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR");
 835     if (0x4 & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR");
 836     if (0x8 & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR");
 837     return strings;
 838 }
 839 void DumpVkDeviceGroupPresentModeFlagsKHR(Printer &p, std::string name, VkDeviceGroupPresentModeFlagsKHR value, int width = 0) {
 840     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 841     auto strings = VkDeviceGroupPresentModeFlagBitsKHRGetStrings(static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(value));
 842     if (static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(value) == 0) {
 843         ArrayWrapper arr(p, name, 0);
 844         p.SetAsType().PrintString("None");
 845         return;
 846     }
 847     ArrayWrapper arr(p, name, strings.size());
 848     for(auto& str : strings){
 849         p.SetAsType().PrintString(str);
 850     }
 851 }
 852 void DumpVkDeviceGroupPresentModeFlagBitsKHR(Printer &p, std::string name, VkDeviceGroupPresentModeFlagBitsKHR value, int width = 0) {
 853     auto strings = VkDeviceGroupPresentModeFlagBitsKHRGetStrings(value);
 854     p.PrintKeyString(name, strings.at(0), width);
 855 }
 856
 857 std::vector<const char *>VkToolPurposeFlagBitsEXTGetStrings(VkToolPurposeFlagBitsEXT value) {
 858     std::vector<const char *> strings;
 859     if (value == 0) strings.push_back("None");
 860     if (0x1 & value) strings.push_back("TOOL_PURPOSE_VALIDATION_BIT_EXT");
 861     if (0x2 & value) strings.push_back("TOOL_PURPOSE_PROFILING_BIT_EXT");
 862     if (0x4 & value) strings.push_back("TOOL_PURPOSE_TRACING_BIT_EXT");
 863     if (0x8 & value) strings.push_back("TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT");
 864     if (0x10 & value) strings.push_back("TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT");
 865     if (0x20 & value) strings.push_back("TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT");
 866     if (0x40 & value) strings.push_back("TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT");
 867     return strings;
 868 }
 869 void DumpVkToolPurposeFlagsEXT(Printer &p, std::string name, VkToolPurposeFlagsEXT value, int width = 0) {
 870     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 871     auto strings = VkToolPurposeFlagBitsEXTGetStrings(static_cast<VkToolPurposeFlagBitsEXT>(value));
 872     if (static_cast<VkToolPurposeFlagBitsEXT>(value) == 0) {
 873         ArrayWrapper arr(p, name, 0);
 874         p.SetAsType().PrintString("None");
 875         return;
 876     }
 877     ArrayWrapper arr(p, name, strings.size());
 878     for(auto& str : strings){
 879         p.SetAsType().PrintString(str);
 880     }
 881 }
 882 void DumpVkToolPurposeFlagBitsEXT(Printer &p, std::string name, VkToolPurposeFlagBitsEXT value, int width = 0) {
 883     auto strings = VkToolPurposeFlagBitsEXTGetStrings(value);
 884     p.PrintKeyString(name, strings.at(0), width);
 885 }
 886
 887 std::vector<const char *>VkSurfaceCounterFlagBitsEXTGetStrings(VkSurfaceCounterFlagBitsEXT value) {
 888     std::vector<const char *> strings;
 889     if (value == 0) strings.push_back("None");
 890     if (0x1 & value) strings.push_back("SURFACE_COUNTER_VBLANK_EXT");
 891     return strings;
 892 }
 893 void DumpVkSurfaceCounterFlagsEXT(Printer &p, std::string name, VkSurfaceCounterFlagsEXT value, int width = 0) {
 894     if (p.Type() == OutputType::json) { p.PrintKeyValue(name, value); return; }
 895     auto strings = VkSurfaceCounterFlagBitsEXTGetStrings(static_cast<VkSurfaceCounterFlagBitsEXT>(value));
 896     if (static_cast<VkSurfaceCounterFlagBitsEXT>(value) == 0) {
 897         ArrayWrapper arr(p, name, 0);
 898         p.SetAsType().PrintString("None");
 899         return;
 900     }
 901     ArrayWrapper arr(p, name, strings.size());
 902     for(auto& str : strings){
 903         p.SetAsType().PrintString(str);
 904     }
 905 }
 906 void DumpVkSurfaceCounterFlagBitsEXT(Printer &p, std::string name, VkSurfaceCounterFlagBitsEXT value, int width = 0) {
 907     auto strings = VkSurfaceCounterFlagBitsEXTGetStrings(value);
 908     p.PrintKeyString(name, strings.at(0), width);
 909 }
 910
 911 void DumpVkPhysicalDeviceFeatures(Printer &p, std::string name, VkPhysicalDeviceFeatures &obj) {
 912     ObjectWrapper object{p, name};
 913     p.PrintKeyBool("robustBufferAccess", static_cast<bool>(obj.robustBufferAccess), 39);
 914     p.PrintKeyBool("fullDrawIndexUint32", static_cast<bool>(obj.fullDrawIndexUint32), 39);
 915     p.PrintKeyBool("imageCubeArray", static_cast<bool>(obj.imageCubeArray), 39);
 916     p.PrintKeyBool("independentBlend", static_cast<bool>(obj.independentBlend), 39);
 917     p.PrintKeyBool("geometryShader", static_cast<bool>(obj.geometryShader), 39);
 918     p.PrintKeyBool("tessellationShader", static_cast<bool>(obj.tessellationShader), 39);
 919     p.PrintKeyBool("sampleRateShading", static_cast<bool>(obj.sampleRateShading), 39);
 920     p.PrintKeyBool("dualSrcBlend", static_cast<bool>(obj.dualSrcBlend), 39);
 921     p.PrintKeyBool("logicOp", static_cast<bool>(obj.logicOp), 39);
 922     p.PrintKeyBool("multiDrawIndirect", static_cast<bool>(obj.multiDrawIndirect), 39);
 923     p.PrintKeyBool("drawIndirectFirstInstance", static_cast<bool>(obj.drawIndirectFirstInstance), 39);
 924     p.PrintKeyBool("depthClamp", static_cast<bool>(obj.depthClamp), 39);
 925     p.PrintKeyBool("depthBiasClamp", static_cast<bool>(obj.depthBiasClamp), 39);
 926     p.PrintKeyBool("fillModeNonSolid", static_cast<bool>(obj.fillModeNonSolid), 39);
 927     p.PrintKeyBool("depthBounds", static_cast<bool>(obj.depthBounds), 39);
 928     p.PrintKeyBool("wideLines", static_cast<bool>(obj.wideLines), 39);
 929     p.PrintKeyBool("largePoints", static_cast<bool>(obj.largePoints), 39);
 930     p.PrintKeyBool("alphaToOne", static_cast<bool>(obj.alphaToOne), 39);
 931     p.PrintKeyBool("multiViewport", static_cast<bool>(obj.multiViewport), 39);
 932     p.PrintKeyBool("samplerAnisotropy", static_cast<bool>(obj.samplerAnisotropy), 39);
 933     p.PrintKeyBool("textureCompressionETC2", static_cast<bool>(obj.textureCompressionETC2), 39);
 934     p.PrintKeyBool("textureCompressionASTC_LDR", static_cast<bool>(obj.textureCompressionASTC_LDR), 39);
 935     p.PrintKeyBool("textureCompressionBC", static_cast<bool>(obj.textureCompressionBC), 39);
 936     p.PrintKeyBool("occlusionQueryPrecise", static_cast<bool>(obj.occlusionQueryPrecise), 39);
 937     p.PrintKeyBool("pipelineStatisticsQuery", static_cast<bool>(obj.pipelineStatisticsQuery), 39);
 938     p.PrintKeyBool("vertexPipelineStoresAndAtomics", static_cast<bool>(obj.vertexPipelineStoresAndAtomics), 39);
 939     p.PrintKeyBool("fragmentStoresAndAtomics", static_cast<bool>(obj.fragmentStoresAndAtomics), 39);
 940     p.PrintKeyBool("shaderTessellationAndGeometryPointSize", static_cast<bool>(obj.shaderTessellationAndGeometryPointSize), 39);
 941     p.PrintKeyBool("shaderImageGatherExtended", static_cast<bool>(obj.shaderImageGatherExtended), 39);
 942     p.PrintKeyBool("shaderStorageImageExtendedFormats", static_cast<bool>(obj.shaderStorageImageExtendedFormats), 39);
 943     p.PrintKeyBool("shaderStorageImageMultisample", static_cast<bool>(obj.shaderStorageImageMultisample), 39);
 944     p.PrintKeyBool("shaderStorageImageReadWithoutFormat", static_cast<bool>(obj.shaderStorageImageReadWithoutFormat), 39);
 945     p.PrintKeyBool("shaderStorageImageWriteWithoutFormat", static_cast<bool>(obj.shaderStorageImageWriteWithoutFormat), 39);
 946     p.PrintKeyBool("shaderUniformBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderUniformBufferArrayDynamicIndexing), 39);
 947     p.PrintKeyBool("shaderSampledImageArrayDynamicIndexing", static_cast<bool>(obj.shaderSampledImageArrayDynamicIndexing), 39);
 948     p.PrintKeyBool("shaderStorageBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageBufferArrayDynamicIndexing), 39);
 949     p.PrintKeyBool("shaderStorageImageArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageImageArrayDynamicIndexing), 39);
 950     p.PrintKeyBool("shaderClipDistance", static_cast<bool>(obj.shaderClipDistance), 39);
 951     p.PrintKeyBool("shaderCullDistance", static_cast<bool>(obj.shaderCullDistance), 39);
 952     p.PrintKeyBool("shaderFloat64", static_cast<bool>(obj.shaderFloat64), 39);
 953     p.PrintKeyBool("shaderInt64", static_cast<bool>(obj.shaderInt64), 39);
 954     p.PrintKeyBool("shaderInt16", static_cast<bool>(obj.shaderInt16), 39);
 955     p.PrintKeyBool("shaderResourceResidency", static_cast<bool>(obj.shaderResourceResidency), 39);
 956     p.PrintKeyBool("shaderResourceMinLod", static_cast<bool>(obj.shaderResourceMinLod), 39);
 957     p.PrintKeyBool("sparseBinding", static_cast<bool>(obj.sparseBinding), 39);
 958     p.PrintKeyBool("sparseResidencyBuffer", static_cast<bool>(obj.sparseResidencyBuffer), 39);
 959     p.PrintKeyBool("sparseResidencyImage2D", static_cast<bool>(obj.sparseResidencyImage2D), 39);
 960     p.PrintKeyBool("sparseResidencyImage3D", static_cast<bool>(obj.sparseResidencyImage3D), 39);
 961     p.PrintKeyBool("sparseResidency2Samples", static_cast<bool>(obj.sparseResidency2Samples), 39);
 962     p.PrintKeyBool("sparseResidency4Samples", static_cast<bool>(obj.sparseResidency4Samples), 39);
 963     p.PrintKeyBool("sparseResidency8Samples", static_cast<bool>(obj.sparseResidency8Samples), 39);
 964     p.PrintKeyBool("sparseResidency16Samples", static_cast<bool>(obj.sparseResidency16Samples), 39);
 965     p.PrintKeyBool("sparseResidencyAliased", static_cast<bool>(obj.sparseResidencyAliased), 39);
 966     p.PrintKeyBool("variableMultisampleRate", static_cast<bool>(obj.variableMultisampleRate), 39);
 967     p.PrintKeyBool("inheritedQueries", static_cast<bool>(obj.inheritedQueries), 39);
 968 }
 969 void DumpVkExtent3D(Printer &p, std::string name, VkExtent3D &obj) {
 970     ObjectWrapper object{p, name};
 971     p.PrintKeyValue("width", obj.width, 6);
 972     p.PrintKeyValue("height", obj.height, 6);
 973     p.PrintKeyValue("depth", obj.depth, 6);
 974 }
 975 void DumpVkPhysicalDeviceLimits(Printer &p, std::string name, VkPhysicalDeviceLimits &obj) {
 976     if (p.Type() == OutputType::json)
 977         p.ObjectStart("limits");
 978     else
 979         p.SetSubHeader().ObjectStart(name);
 980     p.PrintKeyValue("maxImageDimension1D", obj.maxImageDimension1D, 47);
 981     p.PrintKeyValue("maxImageDimension2D", obj.maxImageDimension2D, 47);
 982     p.PrintKeyValue("maxImageDimension3D", obj.maxImageDimension3D, 47);
 983     p.PrintKeyValue("maxImageDimensionCube", obj.maxImageDimensionCube, 47);
 984     p.PrintKeyValue("maxImageArrayLayers", obj.maxImageArrayLayers, 47);
 985     p.PrintKeyValue("maxTexelBufferElements", obj.maxTexelBufferElements, 47);
 986     p.PrintKeyValue("maxUniformBufferRange", obj.maxUniformBufferRange, 47);
 987     p.PrintKeyValue("maxStorageBufferRange", obj.maxStorageBufferRange, 47);
 988     p.PrintKeyValue("maxPushConstantsSize", obj.maxPushConstantsSize, 47);
 989     p.PrintKeyValue("maxMemoryAllocationCount", obj.maxMemoryAllocationCount, 47);
 990     p.PrintKeyValue("maxSamplerAllocationCount", obj.maxSamplerAllocationCount, 47);
 991     p.PrintKeyValue("bufferImageGranularity", to_hex_str(p, obj.bufferImageGranularity), 47);
 992     p.PrintKeyValue("sparseAddressSpaceSize", to_hex_str(p, obj.sparseAddressSpaceSize), 47);
 993     p.PrintKeyValue("maxBoundDescriptorSets", obj.maxBoundDescriptorSets, 47);
 994     p.PrintKeyValue("maxPerStageDescriptorSamplers", obj.maxPerStageDescriptorSamplers, 47);
 995     p.PrintKeyValue("maxPerStageDescriptorUniformBuffers", obj.maxPerStageDescriptorUniformBuffers, 47);
 996     p.PrintKeyValue("maxPerStageDescriptorStorageBuffers", obj.maxPerStageDescriptorStorageBuffers, 47);
 997     p.PrintKeyValue("maxPerStageDescriptorSampledImages", obj.maxPerStageDescriptorSampledImages, 47);
 998     p.PrintKeyValue("maxPerStageDescriptorStorageImages", obj.maxPerStageDescriptorStorageImages, 47);
 999     p.PrintKeyValue("maxPerStageDescriptorInputAttachments", obj.maxPerStageDescriptorInputAttachments, 47);
1000     p.PrintKeyValue("maxPerStageResources", obj.maxPerStageResources, 47);
1001     p.PrintKeyValue("maxDescriptorSetSamplers", obj.maxDescriptorSetSamplers, 47);
1002     p.PrintKeyValue("maxDescriptorSetUniformBuffers", obj.maxDescriptorSetUniformBuffers, 47);
1003     p.PrintKeyValue("maxDescriptorSetUniformBuffersDynamic", obj.maxDescriptorSetUniformBuffersDynamic, 47);
1004     p.PrintKeyValue("maxDescriptorSetStorageBuffers", obj.maxDescriptorSetStorageBuffers, 47);
1005     p.PrintKeyValue("maxDescriptorSetStorageBuffersDynamic", obj.maxDescriptorSetStorageBuffersDynamic, 47);
1006     p.PrintKeyValue("maxDescriptorSetSampledImages", obj.maxDescriptorSetSampledImages, 47);
1007     p.PrintKeyValue("maxDescriptorSetStorageImages", obj.maxDescriptorSetStorageImages, 47);
1008     p.PrintKeyValue("maxDescriptorSetInputAttachments", obj.maxDescriptorSetInputAttachments, 47);
1009     p.PrintKeyValue("maxVertexInputAttributes", obj.maxVertexInputAttributes, 47);
1010     p.PrintKeyValue("maxVertexInputBindings", obj.maxVertexInputBindings, 47);
1011     p.PrintKeyValue("maxVertexInputAttributeOffset", obj.maxVertexInputAttributeOffset, 47);
1012     p.PrintKeyValue("maxVertexInputBindingStride", obj.maxVertexInputBindingStride, 47);
1013     p.PrintKeyValue("maxVertexOutputComponents", obj.maxVertexOutputComponents, 47);
1014     p.PrintKeyValue("maxTessellationGenerationLevel", obj.maxTessellationGenerationLevel, 47);
1015     p.PrintKeyValue("maxTessellationPatchSize", obj.maxTessellationPatchSize, 47);
1016     p.PrintKeyValue("maxTessellationControlPerVertexInputComponents", obj.maxTessellationControlPerVertexInputComponents, 47);
1017     p.PrintKeyValue("maxTessellationControlPerVertexOutputComponents", obj.maxTessellationControlPerVertexOutputComponents, 47);
1018     p.PrintKeyValue("maxTessellationControlPerPatchOutputComponents", obj.maxTessellationControlPerPatchOutputComponents, 47);
1019     p.PrintKeyValue("maxTessellationControlTotalOutputComponents", obj.maxTessellationControlTotalOutputComponents, 47);
1020     p.PrintKeyValue("maxTessellationEvaluationInputComponents", obj.maxTessellationEvaluationInputComponents, 47);
1021     p.PrintKeyValue("maxTessellationEvaluationOutputComponents", obj.maxTessellationEvaluationOutputComponents, 47);
1022     p.PrintKeyValue("maxGeometryShaderInvocations", obj.maxGeometryShaderInvocations, 47);
1023     p.PrintKeyValue("maxGeometryInputComponents", obj.maxGeometryInputComponents, 47);
1024     p.PrintKeyValue("maxGeometryOutputComponents", obj.maxGeometryOutputComponents, 47);
1025     p.PrintKeyValue("maxGeometryOutputVertices", obj.maxGeometryOutputVertices, 47);
1026     p.PrintKeyValue("maxGeometryTotalOutputComponents", obj.maxGeometryTotalOutputComponents, 47);
1027     p.PrintKeyValue("maxFragmentInputComponents", obj.maxFragmentInputComponents, 47);
1028     p.PrintKeyValue("maxFragmentOutputAttachments", obj.maxFragmentOutputAttachments, 47);
1029     p.PrintKeyValue("maxFragmentDualSrcAttachments", obj.maxFragmentDualSrcAttachments, 47);
1030     p.PrintKeyValue("maxFragmentCombinedOutputResources", obj.maxFragmentCombinedOutputResources, 47);
1031     p.PrintKeyValue("maxComputeSharedMemorySize", obj.maxComputeSharedMemorySize, 47);
1032     {   ArrayWrapper arr(p,"maxComputeWorkGroupCount", 3);
1033         p.PrintElement(obj.maxComputeWorkGroupCount[0]);
1034         p.PrintElement(obj.maxComputeWorkGroupCount[1]);
1035         p.PrintElement(obj.maxComputeWorkGroupCount[2]);
1036     }
1037     p.PrintKeyValue("maxComputeWorkGroupInvocations", obj.maxComputeWorkGroupInvocations, 47);
1038     {   ArrayWrapper arr(p,"maxComputeWorkGroupSize", 3);
1039         p.PrintElement(obj.maxComputeWorkGroupSize[0]);
1040         p.PrintElement(obj.maxComputeWorkGroupSize[1]);
1041         p.PrintElement(obj.maxComputeWorkGroupSize[2]);
1042     }
1043     p.PrintKeyValue("subPixelPrecisionBits", obj.subPixelPrecisionBits, 47);
1044     p.PrintKeyValue("subTexelPrecisionBits", obj.subTexelPrecisionBits, 47);
1045     p.PrintKeyValue("mipmapPrecisionBits", obj.mipmapPrecisionBits, 47);
1046     p.PrintKeyValue("maxDrawIndexedIndexValue", obj.maxDrawIndexedIndexValue, 47);
1047     p.PrintKeyValue("maxDrawIndirectCount", obj.maxDrawIndirectCount, 47);
1048     p.PrintKeyValue("maxSamplerLodBias", obj.maxSamplerLodBias, 47);
1049     p.PrintKeyValue("maxSamplerAnisotropy", obj.maxSamplerAnisotropy, 47);
1050     p.PrintKeyValue("maxViewports", obj.maxViewports, 47);
1051     {   ArrayWrapper arr(p,"maxViewportDimensions", 2);
1052         p.PrintElement(obj.maxViewportDimensions[0]);
1053         p.PrintElement(obj.maxViewportDimensions[1]);
1054     }
1055     {   ArrayWrapper arr(p,"viewportBoundsRange", 2);
1056         p.PrintElement(obj.viewportBoundsRange[0]);
1057         p.PrintElement(obj.viewportBoundsRange[1]);
1058     }
1059     p.PrintKeyValue("viewportSubPixelBits", obj.viewportSubPixelBits, 47);
1060     p.PrintKeyValue("minMemoryMapAlignment", obj.minMemoryMapAlignment, 47);
1061     p.PrintKeyValue("minTexelBufferOffsetAlignment", to_hex_str(p, obj.minTexelBufferOffsetAlignment), 47);
1062     p.PrintKeyValue("minUniformBufferOffsetAlignment", to_hex_str(p, obj.minUniformBufferOffsetAlignment), 47);
1063     p.PrintKeyValue("minStorageBufferOffsetAlignment", to_hex_str(p, obj.minStorageBufferOffsetAlignment), 47);
1064     p.PrintKeyValue("minTexelOffset", obj.minTexelOffset, 47);
1065     p.PrintKeyValue("maxTexelOffset", obj.maxTexelOffset, 47);
1066     p.PrintKeyValue("minTexelGatherOffset", obj.minTexelGatherOffset, 47);
1067     p.PrintKeyValue("maxTexelGatherOffset", obj.maxTexelGatherOffset, 47);
1068     p.PrintKeyValue("minInterpolationOffset", obj.minInterpolationOffset, 47);
1069     p.PrintKeyValue("maxInterpolationOffset", obj.maxInterpolationOffset, 47);
1070     p.PrintKeyValue("subPixelInterpolationOffsetBits", obj.subPixelInterpolationOffsetBits, 47);
1071     p.PrintKeyValue("maxFramebufferWidth", obj.maxFramebufferWidth, 47);
1072     p.PrintKeyValue("maxFramebufferHeight", obj.maxFramebufferHeight, 47);
1073     p.PrintKeyValue("maxFramebufferLayers", obj.maxFramebufferLayers, 47);
1074     DumpVkSampleCountFlags(p, "framebufferColorSampleCounts", obj.framebufferColorSampleCounts, 47);
1075     DumpVkSampleCountFlags(p, "framebufferDepthSampleCounts", obj.framebufferDepthSampleCounts, 47);
1076     DumpVkSampleCountFlags(p, "framebufferStencilSampleCounts", obj.framebufferStencilSampleCounts, 47);
1077     DumpVkSampleCountFlags(p, "framebufferNoAttachmentsSampleCounts", obj.framebufferNoAttachmentsSampleCounts, 47);
1078     p.PrintKeyValue("maxColorAttachments", obj.maxColorAttachments, 47);
1079     DumpVkSampleCountFlags(p, "sampledImageColorSampleCounts", obj.sampledImageColorSampleCounts, 47);
1080     DumpVkSampleCountFlags(p, "sampledImageIntegerSampleCounts", obj.sampledImageIntegerSampleCounts, 47);
1081     DumpVkSampleCountFlags(p, "sampledImageDepthSampleCounts", obj.sampledImageDepthSampleCounts, 47);
1082     DumpVkSampleCountFlags(p, "sampledImageStencilSampleCounts", obj.sampledImageStencilSampleCounts, 47);
1083     DumpVkSampleCountFlags(p, "storageImageSampleCounts", obj.storageImageSampleCounts, 47);
1084     p.PrintKeyValue("maxSampleMaskWords", obj.maxSampleMaskWords, 47);
1085     p.PrintKeyBool("timestampComputeAndGraphics", static_cast<bool>(obj.timestampComputeAndGraphics), 47);
1086     p.PrintKeyValue("timestampPeriod", obj.timestampPeriod, 47);
1087     p.PrintKeyValue("maxClipDistances", obj.maxClipDistances, 47);
1088     p.PrintKeyValue("maxCullDistances", obj.maxCullDistances, 47);
1089     p.PrintKeyValue("maxCombinedClipAndCullDistances", obj.maxCombinedClipAndCullDistances, 47);
1090     p.PrintKeyValue("discreteQueuePriorities", obj.discreteQueuePriorities, 47);
1091     {   ArrayWrapper arr(p,"pointSizeRange", 2);
1092         p.PrintElement(obj.pointSizeRange[0]);
1093         p.PrintElement(obj.pointSizeRange[1]);
1094     }
1095     {   ArrayWrapper arr(p,"lineWidthRange", 2);
1096         p.PrintElement(obj.lineWidthRange[0]);
1097         p.PrintElement(obj.lineWidthRange[1]);
1098     }
1099     p.PrintKeyValue("pointSizeGranularity", obj.pointSizeGranularity, 47);
1100     p.PrintKeyValue("lineWidthGranularity", obj.lineWidthGranularity, 47);
1101     p.PrintKeyBool("strictLines", static_cast<bool>(obj.strictLines), 47);
1102     p.PrintKeyBool("standardSampleLocations", static_cast<bool>(obj.standardSampleLocations), 47);
1103     p.PrintKeyValue("optimalBufferCopyOffsetAlignment", to_hex_str(p, obj.optimalBufferCopyOffsetAlignment), 47);
1104     p.PrintKeyValue("optimalBufferCopyRowPitchAlignment", to_hex_str(p, obj.optimalBufferCopyRowPitchAlignment), 47);
1105     p.PrintKeyValue("nonCoherentAtomSize", to_hex_str(p, obj.nonCoherentAtomSize), 47);
1106     p.ObjectEnd();
1107 }
1108 void DumpVkPhysicalDeviceSparseProperties(Printer &p, std::string name, VkPhysicalDeviceSparseProperties &obj) {
1109     if (p.Type() == OutputType::json)
1110         p.ObjectStart("sparseProperties");
1111     else
1112         p.SetSubHeader().ObjectStart(name);
1113     p.PrintKeyBool("residencyStandard2DBlockShape", static_cast<bool>(obj.residencyStandard2DBlockShape), 40);
1114     p.PrintKeyBool("residencyStandard2DMultisampleBlockShape", static_cast<bool>(obj.residencyStandard2DMultisampleBlockShape), 40);
1115     p.PrintKeyBool("residencyStandard3DBlockShape", static_cast<bool>(obj.residencyStandard3DBlockShape), 40);
1116     p.PrintKeyBool("residencyAlignedMipSize", static_cast<bool>(obj.residencyAlignedMipSize), 40);
1117     p.PrintKeyBool("residencyNonResidentStrict", static_cast<bool>(obj.residencyNonResidentStrict), 40);
1118     p.ObjectEnd();
1119 }
1120 void DumpVkLayerProperties(Printer &p, std::string name, VkLayerProperties &obj) {
1121     ObjectWrapper object{p, name};
1122     p.PrintKeyString("layerName", obj.layerName, 21);
1123     p.PrintKeyValue("specVersion", obj.specVersion, 21);
1124     p.PrintKeyValue("implementationVersion", obj.implementationVersion, 21);
1125     p.PrintKeyString("description", obj.description, 21);
1126 }
1127 void DumpVkExtent2D(Printer &p, std::string name, VkExtent2D &obj) {
1128     ObjectWrapper object{p, name};
1129     p.PrintKeyValue("width", obj.width, 6);
1130     p.PrintKeyValue("height", obj.height, 6);
1131 }
1132 void DumpVkPhysicalDeviceSubgroupProperties(Printer &p, std::string name, VkPhysicalDeviceSubgroupProperties &obj) {
1133     ObjectWrapper object{p, name};
1134     p.PrintKeyValue("subgroupSize", obj.subgroupSize, 25);
1135     DumpVkShaderStageFlags(p, "supportedStages", obj.supportedStages, 25);
1136     DumpVkSubgroupFeatureFlags(p, "supportedOperations", obj.supportedOperations, 25);
1137     p.PrintKeyBool("quadOperationsInAllStages", static_cast<bool>(obj.quadOperationsInAllStages), 25);
1138 }
1139 void DumpVkPhysicalDevice16BitStorageFeatures(Printer &p, std::string name, VkPhysicalDevice16BitStorageFeatures &obj) {
1140     ObjectWrapper object{p, name};
1141     p.PrintKeyBool("storageBuffer16BitAccess", static_cast<bool>(obj.storageBuffer16BitAccess), 34);
1142     p.PrintKeyBool("uniformAndStorageBuffer16BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer16BitAccess), 34);
1143     p.PrintKeyBool("storagePushConstant16", static_cast<bool>(obj.storagePushConstant16), 34);
1144     p.PrintKeyBool("storageInputOutput16", static_cast<bool>(obj.storageInputOutput16), 34);
1145 }
1146 void DumpVkPhysicalDevicePointClippingProperties(Printer &p, std::string name, VkPhysicalDevicePointClippingProperties &obj) {
1147     ObjectWrapper object{p, name};
1148     DumpVkPointClippingBehavior(p, "pointClippingBehavior", obj.pointClippingBehavior, 0);
1149 }
1150 void DumpVkPhysicalDeviceMultiviewFeatures(Printer &p, std::string name, VkPhysicalDeviceMultiviewFeatures &obj) {
1151     ObjectWrapper object{p, name};
1152     p.PrintKeyBool("multiview", static_cast<bool>(obj.multiview), 27);
1153     p.PrintKeyBool("multiviewGeometryShader", static_cast<bool>(obj.multiviewGeometryShader), 27);
1154     p.PrintKeyBool("multiviewTessellationShader", static_cast<bool>(obj.multiviewTessellationShader), 27);
1155 }
1156 void DumpVkPhysicalDeviceMultiviewProperties(Printer &p, std::string name, VkPhysicalDeviceMultiviewProperties &obj) {
1157     ObjectWrapper object{p, name};
1158     p.PrintKeyValue("maxMultiviewViewCount", obj.maxMultiviewViewCount, 25);
1159     p.PrintKeyValue("maxMultiviewInstanceIndex", obj.maxMultiviewInstanceIndex, 25);
1160 }
1161 void DumpVkPhysicalDeviceVariablePointersFeatures(Printer &p, std::string name, VkPhysicalDeviceVariablePointersFeatures &obj) {
1162     ObjectWrapper object{p, name};
1163     p.PrintKeyBool("variablePointersStorageBuffer", static_cast<bool>(obj.variablePointersStorageBuffer), 29);
1164     p.PrintKeyBool("variablePointers", static_cast<bool>(obj.variablePointers), 29);
1165 }
1166 void DumpVkPhysicalDeviceProtectedMemoryFeatures(Printer &p, std::string name, VkPhysicalDeviceProtectedMemoryFeatures &obj) {
1167     ObjectWrapper object{p, name};
1168     p.PrintKeyBool("protectedMemory", static_cast<bool>(obj.protectedMemory), 15);
1169 }
1170 void DumpVkPhysicalDeviceProtectedMemoryProperties(Printer &p, std::string name, VkPhysicalDeviceProtectedMemoryProperties &obj) {
1171     ObjectWrapper object{p, name};
1172     p.PrintKeyBool("protectedNoFault", static_cast<bool>(obj.protectedNoFault), 16);
1173 }
1174 void DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(Printer &p, std::string name, VkPhysicalDeviceSamplerYcbcrConversionFeatures &obj) {
1175     ObjectWrapper object{p, name};
1176     p.PrintKeyBool("samplerYcbcrConversion", static_cast<bool>(obj.samplerYcbcrConversion), 22);
1177 }
1178 void DumpVkPhysicalDeviceIDProperties(Printer &p, std::string name, VkPhysicalDeviceIDProperties &obj) {
1179     ObjectWrapper object{p, name};
1180     p.PrintKeyString("deviceUUID", to_string_16(obj.deviceUUID), 15);
1181     p.PrintKeyString("driverUUID", to_string_16(obj.driverUUID), 15);
1182     if (obj.deviceLUIDValid) p.PrintKeyString("deviceLUID", to_string_8(obj.deviceLUID), 15);
1183     p.PrintKeyValue("deviceNodeMask", obj.deviceNodeMask, 15);
1184     p.PrintKeyBool("deviceLUIDValid", static_cast<bool>(obj.deviceLUIDValid), 15);
1185 }
1186 void DumpVkPhysicalDeviceMaintenance3Properties(Printer &p, std::string name, VkPhysicalDeviceMaintenance3Properties &obj) {
1187     ObjectWrapper object{p, name};
1188     p.PrintKeyValue("maxPerSetDescriptors", obj.maxPerSetDescriptors, 23);
1189     p.PrintKeyValue("maxMemoryAllocationSize", to_hex_str(p, obj.maxMemoryAllocationSize), 23);
1190 }
1191 void DumpVkPhysicalDeviceShaderDrawParametersFeatures(Printer &p, std::string name, VkPhysicalDeviceShaderDrawParametersFeatures &obj) {
1192     ObjectWrapper object{p, name};
1193     p.PrintKeyBool("shaderDrawParameters", static_cast<bool>(obj.shaderDrawParameters), 20);
1194 }
1195 void DumpVkPhysicalDeviceVulkan11Features(Printer &p, std::string name, VkPhysicalDeviceVulkan11Features &obj) {
1196     ObjectWrapper object{p, name};
1197     p.PrintKeyBool("storageBuffer16BitAccess", static_cast<bool>(obj.storageBuffer16BitAccess), 34);
1198     p.PrintKeyBool("uniformAndStorageBuffer16BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer16BitAccess), 34);
1199     p.PrintKeyBool("storagePushConstant16", static_cast<bool>(obj.storagePushConstant16), 34);
1200     p.PrintKeyBool("storageInputOutput16", static_cast<bool>(obj.storageInputOutput16), 34);
1201     p.PrintKeyBool("multiview", static_cast<bool>(obj.multiview), 34);
1202     p.PrintKeyBool("multiviewGeometryShader", static_cast<bool>(obj.multiviewGeometryShader), 34);
1203     p.PrintKeyBool("multiviewTessellationShader", static_cast<bool>(obj.multiviewTessellationShader), 34);
1204     p.PrintKeyBool("variablePointersStorageBuffer", static_cast<bool>(obj.variablePointersStorageBuffer), 34);
1205     p.PrintKeyBool("variablePointers", static_cast<bool>(obj.variablePointers), 34);
1206     p.PrintKeyBool("protectedMemory", static_cast<bool>(obj.protectedMemory), 34);
1207     p.PrintKeyBool("samplerYcbcrConversion", static_cast<bool>(obj.samplerYcbcrConversion), 34);
1208     p.PrintKeyBool("shaderDrawParameters", static_cast<bool>(obj.shaderDrawParameters), 34);
1209 }
1210 void DumpVkPhysicalDeviceVulkan11Properties(Printer &p, std::string name, VkPhysicalDeviceVulkan11Properties &obj) {
1211     ObjectWrapper object{p, name};
1212     p.PrintKeyString("deviceUUID", to_string_16(obj.deviceUUID), 33);
1213     p.PrintKeyString("driverUUID", to_string_16(obj.driverUUID), 33);
1214     if (obj.deviceLUIDValid) p.PrintKeyString("deviceLUID", to_string_8(obj.deviceLUID), 33);
1215     p.PrintKeyValue("deviceNodeMask", obj.deviceNodeMask, 33);
1216     p.PrintKeyBool("deviceLUIDValid", static_cast<bool>(obj.deviceLUIDValid), 33);
1217     p.PrintKeyValue("subgroupSize", obj.subgroupSize, 33);
1218     DumpVkShaderStageFlags(p, "subgroupSupportedStages", obj.subgroupSupportedStages, 33);
1219     DumpVkSubgroupFeatureFlags(p, "subgroupSupportedOperations", obj.subgroupSupportedOperations, 33);
1220     p.PrintKeyBool("subgroupQuadOperationsInAllStages", static_cast<bool>(obj.subgroupQuadOperationsInAllStages), 33);
1221     DumpVkPointClippingBehavior(p, "pointClippingBehavior", obj.pointClippingBehavior, 33);
1222     p.PrintKeyValue("maxMultiviewViewCount", obj.maxMultiviewViewCount, 33);
1223     p.PrintKeyValue("maxMultiviewInstanceIndex", obj.maxMultiviewInstanceIndex, 33);
1224     p.PrintKeyBool("protectedNoFault", static_cast<bool>(obj.protectedNoFault), 33);
1225     p.PrintKeyValue("maxPerSetDescriptors", obj.maxPerSetDescriptors, 33);
1226     p.PrintKeyValue("maxMemoryAllocationSize", to_hex_str(p, obj.maxMemoryAllocationSize), 33);
1227 }
1228 void DumpVkPhysicalDeviceVulkan12Features(Printer &p, std::string name, VkPhysicalDeviceVulkan12Features &obj) {
1229     ObjectWrapper object{p, name};
1230     p.PrintKeyBool("samplerMirrorClampToEdge", static_cast<bool>(obj.samplerMirrorClampToEdge), 50);
1231     p.PrintKeyBool("drawIndirectCount", static_cast<bool>(obj.drawIndirectCount), 50);
1232     p.PrintKeyBool("storageBuffer8BitAccess", static_cast<bool>(obj.storageBuffer8BitAccess), 50);
1233     p.PrintKeyBool("uniformAndStorageBuffer8BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer8BitAccess), 50);
1234     p.PrintKeyBool("storagePushConstant8", static_cast<bool>(obj.storagePushConstant8), 50);
1235     p.PrintKeyBool("shaderBufferInt64Atomics", static_cast<bool>(obj.shaderBufferInt64Atomics), 50);
1236     p.PrintKeyBool("shaderSharedInt64Atomics", static_cast<bool>(obj.shaderSharedInt64Atomics), 50);
1237     p.PrintKeyBool("shaderFloat16", static_cast<bool>(obj.shaderFloat16), 50);
1238     p.PrintKeyBool("shaderInt8", static_cast<bool>(obj.shaderInt8), 50);
1239     p.PrintKeyBool("descriptorIndexing", static_cast<bool>(obj.descriptorIndexing), 50);
1240     p.PrintKeyBool("shaderInputAttachmentArrayDynamicIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayDynamicIndexing), 50);
1241     p.PrintKeyBool("shaderUniformTexelBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderUniformTexelBufferArrayDynamicIndexing), 50);
1242     p.PrintKeyBool("shaderStorageTexelBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageTexelBufferArrayDynamicIndexing), 50);
1243     p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexing), 50);
1244     p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexing), 50);
1245     p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexing), 50);
1246     p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexing), 50);
1247     p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexing), 50);
1248     p.PrintKeyBool("shaderUniformTexelBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformTexelBufferArrayNonUniformIndexing), 50);
1249     p.PrintKeyBool("shaderStorageTexelBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageTexelBufferArrayNonUniformIndexing), 50);
1250     p.PrintKeyBool("descriptorBindingUniformBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingUniformBufferUpdateAfterBind), 50);
1251     p.PrintKeyBool("descriptorBindingSampledImageUpdateAfterBind", static_cast<bool>(obj.descriptorBindingSampledImageUpdateAfterBind), 50);
1252     p.PrintKeyBool("descriptorBindingStorageImageUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageImageUpdateAfterBind), 50);
1253     p.PrintKeyBool("descriptorBindingStorageBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageBufferUpdateAfterBind), 50);
1254     p.PrintKeyBool("descriptorBindingUniformTexelBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingUniformTexelBufferUpdateAfterBind), 50);
1255     p.PrintKeyBool("descriptorBindingStorageTexelBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageTexelBufferUpdateAfterBind), 50);
1256     p.PrintKeyBool("descriptorBindingUpdateUnusedWhilePending", static_cast<bool>(obj.descriptorBindingUpdateUnusedWhilePending), 50);
1257     p.PrintKeyBool("descriptorBindingPartiallyBound", static_cast<bool>(obj.descriptorBindingPartiallyBound), 50);
1258     p.PrintKeyBool("descriptorBindingVariableDescriptorCount", static_cast<bool>(obj.descriptorBindingVariableDescriptorCount), 50);
1259     p.PrintKeyBool("runtimeDescriptorArray", static_cast<bool>(obj.runtimeDescriptorArray), 50);
1260     p.PrintKeyBool("samplerFilterMinmax", static_cast<bool>(obj.samplerFilterMinmax), 50);
1261     p.PrintKeyBool("scalarBlockLayout", static_cast<bool>(obj.scalarBlockLayout), 50);
1262     p.PrintKeyBool("imagelessFramebuffer", static_cast<bool>(obj.imagelessFramebuffer), 50);
1263     p.PrintKeyBool("uniformBufferStandardLayout", static_cast<bool>(obj.uniformBufferStandardLayout), 50);
1264     p.PrintKeyBool("shaderSubgroupExtendedTypes", static_cast<bool>(obj.shaderSubgroupExtendedTypes), 50);
1265     p.PrintKeyBool("separateDepthStencilLayouts", static_cast<bool>(obj.separateDepthStencilLayouts), 50);
1266     p.PrintKeyBool("hostQueryReset", static_cast<bool>(obj.hostQueryReset), 50);
1267     p.PrintKeyBool("timelineSemaphore", static_cast<bool>(obj.timelineSemaphore), 50);
1268     p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress), 50);
1269     p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay), 50);
1270     p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice), 50);
1271     p.PrintKeyBool("vulkanMemoryModel", static_cast<bool>(obj.vulkanMemoryModel), 50);
1272     p.PrintKeyBool("vulkanMemoryModelDeviceScope", static_cast<bool>(obj.vulkanMemoryModelDeviceScope), 50);
1273     p.PrintKeyBool("vulkanMemoryModelAvailabilityVisibilityChains", static_cast<bool>(obj.vulkanMemoryModelAvailabilityVisibilityChains), 50);
1274     p.PrintKeyBool("shaderOutputViewportIndex", static_cast<bool>(obj.shaderOutputViewportIndex), 50);
1275     p.PrintKeyBool("shaderOutputLayer", static_cast<bool>(obj.shaderOutputLayer), 50);
1276     p.PrintKeyBool("subgroupBroadcastDynamicId", static_cast<bool>(obj.subgroupBroadcastDynamicId), 50);
1277 }
1278 void DumpVkPhysicalDeviceVulkan12Properties(Printer &p, std::string name, VkPhysicalDeviceVulkan12Properties &obj) {
1279     ObjectWrapper object{p, name};
1280     DumpVkDriverId(p, "driverID", obj.driverID, 52);
1281     p.PrintKeyString("driverName", obj.driverName, 52);
1282     p.PrintKeyString("driverInfo", obj.driverInfo, 52);
1283     DumpVkConformanceVersion(p, "conformanceVersion", obj.conformanceVersion, 52);
1284     DumpVkShaderFloatControlsIndependence(p, "denormBehaviorIndependence", obj.denormBehaviorIndependence, 52);
1285     DumpVkShaderFloatControlsIndependence(p, "roundingModeIndependence", obj.roundingModeIndependence, 52);
1286     p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat16", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat16), 52);
1287     p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat32", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat32), 52);
1288     p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat64", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat64), 52);
1289     p.PrintKeyBool("shaderDenormPreserveFloat16", static_cast<bool>(obj.shaderDenormPreserveFloat16), 52);
1290     p.PrintKeyBool("shaderDenormPreserveFloat32", static_cast<bool>(obj.shaderDenormPreserveFloat32), 52);
1291     p.PrintKeyBool("shaderDenormPreserveFloat64", static_cast<bool>(obj.shaderDenormPreserveFloat64), 52);
1292     p.PrintKeyBool("shaderDenormFlushToZeroFloat16", static_cast<bool>(obj.shaderDenormFlushToZeroFloat16), 52);
1293     p.PrintKeyBool("shaderDenormFlushToZeroFloat32", static_cast<bool>(obj.shaderDenormFlushToZeroFloat32), 52);
1294     p.PrintKeyBool("shaderDenormFlushToZeroFloat64", static_cast<bool>(obj.shaderDenormFlushToZeroFloat64), 52);
1295     p.PrintKeyBool("shaderRoundingModeRTEFloat16", static_cast<bool>(obj.shaderRoundingModeRTEFloat16), 52);
1296     p.PrintKeyBool("shaderRoundingModeRTEFloat32", static_cast<bool>(obj.shaderRoundingModeRTEFloat32), 52);
1297     p.PrintKeyBool("shaderRoundingModeRTEFloat64", static_cast<bool>(obj.shaderRoundingModeRTEFloat64), 52);
1298     p.PrintKeyBool("shaderRoundingModeRTZFloat16", static_cast<bool>(obj.shaderRoundingModeRTZFloat16), 52);
1299     p.PrintKeyBool("shaderRoundingModeRTZFloat32", static_cast<bool>(obj.shaderRoundingModeRTZFloat32), 52);
1300     p.PrintKeyBool("shaderRoundingModeRTZFloat64", static_cast<bool>(obj.shaderRoundingModeRTZFloat64), 52);
1301     p.PrintKeyValue("maxUpdateAfterBindDescriptorsInAllPools", obj.maxUpdateAfterBindDescriptorsInAllPools, 52);
1302     p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexingNative), 52);
1303     p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexingNative), 52);
1304     p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexingNative), 52);
1305     p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexingNative), 52);
1306     p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexingNative), 52);
1307     p.PrintKeyBool("robustBufferAccessUpdateAfterBind", static_cast<bool>(obj.robustBufferAccessUpdateAfterBind), 52);
1308     p.PrintKeyBool("quadDivergentImplicitLod", static_cast<bool>(obj.quadDivergentImplicitLod), 52);
1309     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSamplers", obj.maxPerStageDescriptorUpdateAfterBindSamplers, 52);
1310     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindUniformBuffers", obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers, 52);
1311     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageBuffers", obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers, 52);
1312     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSampledImages", obj.maxPerStageDescriptorUpdateAfterBindSampledImages, 52);
1313     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageImages", obj.maxPerStageDescriptorUpdateAfterBindStorageImages, 52);
1314     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInputAttachments", obj.maxPerStageDescriptorUpdateAfterBindInputAttachments, 52);
1315     p.PrintKeyValue("maxPerStageUpdateAfterBindResources", obj.maxPerStageUpdateAfterBindResources, 52);
1316     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSamplers", obj.maxDescriptorSetUpdateAfterBindSamplers, 52);
1317     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffers", obj.maxDescriptorSetUpdateAfterBindUniformBuffers, 52);
1318     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, 52);
1319     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffers", obj.maxDescriptorSetUpdateAfterBindStorageBuffers, 52);
1320     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, 52);
1321     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSampledImages", obj.maxDescriptorSetUpdateAfterBindSampledImages, 52);
1322     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageImages", obj.maxDescriptorSetUpdateAfterBindStorageImages, 52);
1323     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInputAttachments", obj.maxDescriptorSetUpdateAfterBindInputAttachments, 52);
1324     DumpVkResolveModeFlags(p, "supportedDepthResolveModes", obj.supportedDepthResolveModes, 52);
1325     DumpVkResolveModeFlags(p, "supportedStencilResolveModes", obj.supportedStencilResolveModes, 52);
1326     p.PrintKeyBool("independentResolveNone", static_cast<bool>(obj.independentResolveNone), 52);
1327     p.PrintKeyBool("independentResolve", static_cast<bool>(obj.independentResolve), 52);
1328     p.PrintKeyBool("filterMinmaxSingleComponentFormats", static_cast<bool>(obj.filterMinmaxSingleComponentFormats), 52);
1329     p.PrintKeyBool("filterMinmaxImageComponentMapping", static_cast<bool>(obj.filterMinmaxImageComponentMapping), 52);
1330     p.PrintKeyValue("maxTimelineSemaphoreValueDifference", obj.maxTimelineSemaphoreValueDifference, 52);
1331     DumpVkSampleCountFlags(p, "framebufferIntegerColorSampleCounts", obj.framebufferIntegerColorSampleCounts, 52);
1332 }
1333 void DumpVkPhysicalDevice8BitStorageFeatures(Printer &p, std::string name, VkPhysicalDevice8BitStorageFeatures &obj) {
1334     ObjectWrapper object{p, name};
1335     p.PrintKeyBool("storageBuffer8BitAccess", static_cast<bool>(obj.storageBuffer8BitAccess), 33);
1336     p.PrintKeyBool("uniformAndStorageBuffer8BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer8BitAccess), 33);
1337     p.PrintKeyBool("storagePushConstant8", static_cast<bool>(obj.storagePushConstant8), 33);
1338 }
1339 void DumpVkPhysicalDeviceDriverProperties(Printer &p, std::string name, VkPhysicalDeviceDriverProperties &obj) {
1340     ObjectWrapper object{p, name};
1341     DumpVkDriverId(p, "driverID", obj.driverID, 18);
1342     p.PrintKeyString("driverName", obj.driverName, 18);
1343     p.PrintKeyString("driverInfo", obj.driverInfo, 18);
1344     DumpVkConformanceVersion(p, "conformanceVersion", obj.conformanceVersion, 18);
1345 }
1346 void DumpVkPhysicalDeviceShaderAtomicInt64Features(Printer &p, std::string name, VkPhysicalDeviceShaderAtomicInt64Features &obj) {
1347     ObjectWrapper object{p, name};
1348     p.PrintKeyBool("shaderBufferInt64Atomics", static_cast<bool>(obj.shaderBufferInt64Atomics), 24);
1349     p.PrintKeyBool("shaderSharedInt64Atomics", static_cast<bool>(obj.shaderSharedInt64Atomics), 24);
1350 }
1351 void DumpVkPhysicalDeviceShaderFloat16Int8Features(Printer &p, std::string name, VkPhysicalDeviceShaderFloat16Int8Features &obj) {
1352     ObjectWrapper object{p, name};
1353     p.PrintKeyBool("shaderFloat16", static_cast<bool>(obj.shaderFloat16), 13);
1354     p.PrintKeyBool("shaderInt8", static_cast<bool>(obj.shaderInt8), 13);
1355 }
1356 void DumpVkPhysicalDeviceFloatControlsProperties(Printer &p, std::string name, VkPhysicalDeviceFloatControlsProperties &obj) {
1357     ObjectWrapper object{p, name};
1358     DumpVkShaderFloatControlsIndependence(p, "denormBehaviorIndependence", obj.denormBehaviorIndependence, 37);
1359     DumpVkShaderFloatControlsIndependence(p, "roundingModeIndependence", obj.roundingModeIndependence, 37);
1360     p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat16", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat16), 37);
1361     p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat32", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat32), 37);
1362     p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat64", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat64), 37);
1363     p.PrintKeyBool("shaderDenormPreserveFloat16", static_cast<bool>(obj.shaderDenormPreserveFloat16), 37);
1364     p.PrintKeyBool("shaderDenormPreserveFloat32", static_cast<bool>(obj.shaderDenormPreserveFloat32), 37);
1365     p.PrintKeyBool("shaderDenormPreserveFloat64", static_cast<bool>(obj.shaderDenormPreserveFloat64), 37);
1366     p.PrintKeyBool("shaderDenormFlushToZeroFloat16", static_cast<bool>(obj.shaderDenormFlushToZeroFloat16), 37);
1367     p.PrintKeyBool("shaderDenormFlushToZeroFloat32", static_cast<bool>(obj.shaderDenormFlushToZeroFloat32), 37);
1368     p.PrintKeyBool("shaderDenormFlushToZeroFloat64", static_cast<bool>(obj.shaderDenormFlushToZeroFloat64), 37);
1369     p.PrintKeyBool("shaderRoundingModeRTEFloat16", static_cast<bool>(obj.shaderRoundingModeRTEFloat16), 37);
1370     p.PrintKeyBool("shaderRoundingModeRTEFloat32", static_cast<bool>(obj.shaderRoundingModeRTEFloat32), 37);
1371     p.PrintKeyBool("shaderRoundingModeRTEFloat64", static_cast<bool>(obj.shaderRoundingModeRTEFloat64), 37);
1372     p.PrintKeyBool("shaderRoundingModeRTZFloat16", static_cast<bool>(obj.shaderRoundingModeRTZFloat16), 37);
1373     p.PrintKeyBool("shaderRoundingModeRTZFloat32", static_cast<bool>(obj.shaderRoundingModeRTZFloat32), 37);
1374     p.PrintKeyBool("shaderRoundingModeRTZFloat64", static_cast<bool>(obj.shaderRoundingModeRTZFloat64), 37);
1375 }
1376 void DumpVkPhysicalDeviceDescriptorIndexingFeatures(Printer &p, std::string name, VkPhysicalDeviceDescriptorIndexingFeatures &obj) {
1377     ObjectWrapper object{p, name};
1378     p.PrintKeyBool("shaderInputAttachmentArrayDynamicIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayDynamicIndexing), 50);
1379     p.PrintKeyBool("shaderUniformTexelBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderUniformTexelBufferArrayDynamicIndexing), 50);
1380     p.PrintKeyBool("shaderStorageTexelBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageTexelBufferArrayDynamicIndexing), 50);
1381     p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexing), 50);
1382     p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexing), 50);
1383     p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexing), 50);
1384     p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexing), 50);
1385     p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexing), 50);
1386     p.PrintKeyBool("shaderUniformTexelBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformTexelBufferArrayNonUniformIndexing), 50);
1387     p.PrintKeyBool("shaderStorageTexelBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageTexelBufferArrayNonUniformIndexing), 50);
1388     p.PrintKeyBool("descriptorBindingUniformBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingUniformBufferUpdateAfterBind), 50);
1389     p.PrintKeyBool("descriptorBindingSampledImageUpdateAfterBind", static_cast<bool>(obj.descriptorBindingSampledImageUpdateAfterBind), 50);
1390     p.PrintKeyBool("descriptorBindingStorageImageUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageImageUpdateAfterBind), 50);
1391     p.PrintKeyBool("descriptorBindingStorageBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageBufferUpdateAfterBind), 50);
1392     p.PrintKeyBool("descriptorBindingUniformTexelBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingUniformTexelBufferUpdateAfterBind), 50);
1393     p.PrintKeyBool("descriptorBindingStorageTexelBufferUpdateAfterBind", static_cast<bool>(obj.descriptorBindingStorageTexelBufferUpdateAfterBind), 50);
1394     p.PrintKeyBool("descriptorBindingUpdateUnusedWhilePending", static_cast<bool>(obj.descriptorBindingUpdateUnusedWhilePending), 50);
1395     p.PrintKeyBool("descriptorBindingPartiallyBound", static_cast<bool>(obj.descriptorBindingPartiallyBound), 50);
1396     p.PrintKeyBool("descriptorBindingVariableDescriptorCount", static_cast<bool>(obj.descriptorBindingVariableDescriptorCount), 50);
1397     p.PrintKeyBool("runtimeDescriptorArray", static_cast<bool>(obj.runtimeDescriptorArray), 50);
1398 }
1399 void DumpVkPhysicalDeviceDescriptorIndexingProperties(Printer &p, std::string name, VkPhysicalDeviceDescriptorIndexingProperties &obj) {
1400     ObjectWrapper object{p, name};
1401     p.PrintKeyValue("maxUpdateAfterBindDescriptorsInAllPools", obj.maxUpdateAfterBindDescriptorsInAllPools, 52);
1402     p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexingNative), 52);
1403     p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexingNative), 52);
1404     p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexingNative), 52);
1405     p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexingNative), 52);
1406     p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexingNative", static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexingNative), 52);
1407     p.PrintKeyBool("robustBufferAccessUpdateAfterBind", static_cast<bool>(obj.robustBufferAccessUpdateAfterBind), 52);
1408     p.PrintKeyBool("quadDivergentImplicitLod", static_cast<bool>(obj.quadDivergentImplicitLod), 52);
1409     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSamplers", obj.maxPerStageDescriptorUpdateAfterBindSamplers, 52);
1410     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindUniformBuffers", obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers, 52);
1411     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageBuffers", obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers, 52);
1412     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSampledImages", obj.maxPerStageDescriptorUpdateAfterBindSampledImages, 52);
1413     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageImages", obj.maxPerStageDescriptorUpdateAfterBindStorageImages, 52);
1414     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInputAttachments", obj.maxPerStageDescriptorUpdateAfterBindInputAttachments, 52);
1415     p.PrintKeyValue("maxPerStageUpdateAfterBindResources", obj.maxPerStageUpdateAfterBindResources, 52);
1416     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSamplers", obj.maxDescriptorSetUpdateAfterBindSamplers, 52);
1417     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffers", obj.maxDescriptorSetUpdateAfterBindUniformBuffers, 52);
1418     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, 52);
1419     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffers", obj.maxDescriptorSetUpdateAfterBindStorageBuffers, 52);
1420     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, 52);
1421     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSampledImages", obj.maxDescriptorSetUpdateAfterBindSampledImages, 52);
1422     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageImages", obj.maxDescriptorSetUpdateAfterBindStorageImages, 52);
1423     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInputAttachments", obj.maxDescriptorSetUpdateAfterBindInputAttachments, 52);
1424 }
1425 void DumpVkPhysicalDeviceDepthStencilResolveProperties(Printer &p, std::string name, VkPhysicalDeviceDepthStencilResolveProperties &obj) {
1426     ObjectWrapper object{p, name};
1427     DumpVkResolveModeFlags(p, "supportedDepthResolveModes", obj.supportedDepthResolveModes, 22);
1428     DumpVkResolveModeFlags(p, "supportedStencilResolveModes", obj.supportedStencilResolveModes, 22);
1429     p.PrintKeyBool("independentResolveNone", static_cast<bool>(obj.independentResolveNone), 22);
1430     p.PrintKeyBool("independentResolve", static_cast<bool>(obj.independentResolve), 22);
1431 }
1432 void DumpVkPhysicalDeviceScalarBlockLayoutFeatures(Printer &p, std::string name, VkPhysicalDeviceScalarBlockLayoutFeatures &obj) {
1433     ObjectWrapper object{p, name};
1434     p.PrintKeyBool("scalarBlockLayout", static_cast<bool>(obj.scalarBlockLayout), 17);
1435 }
1436 void DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(Printer &p, std::string name, VkPhysicalDeviceSamplerFilterMinmaxProperties &obj) {
1437     ObjectWrapper object{p, name};
1438     p.PrintKeyBool("filterMinmaxSingleComponentFormats", static_cast<bool>(obj.filterMinmaxSingleComponentFormats), 34);
1439     p.PrintKeyBool("filterMinmaxImageComponentMapping", static_cast<bool>(obj.filterMinmaxImageComponentMapping), 34);
1440 }
1441 void DumpVkPhysicalDeviceVulkanMemoryModelFeatures(Printer &p, std::string name, VkPhysicalDeviceVulkanMemoryModelFeatures &obj) {
1442     ObjectWrapper object{p, name};
1443     p.PrintKeyBool("vulkanMemoryModel", static_cast<bool>(obj.vulkanMemoryModel), 45);
1444     p.PrintKeyBool("vulkanMemoryModelDeviceScope", static_cast<bool>(obj.vulkanMemoryModelDeviceScope), 45);
1445     p.PrintKeyBool("vulkanMemoryModelAvailabilityVisibilityChains", static_cast<bool>(obj.vulkanMemoryModelAvailabilityVisibilityChains), 45);
1446 }
1447 void DumpVkPhysicalDeviceImagelessFramebufferFeatures(Printer &p, std::string name, VkPhysicalDeviceImagelessFramebufferFeatures &obj) {
1448     ObjectWrapper object{p, name};
1449     p.PrintKeyBool("imagelessFramebuffer", static_cast<bool>(obj.imagelessFramebuffer), 20);
1450 }
1451 void DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(Printer &p, std::string name, VkPhysicalDeviceUniformBufferStandardLayoutFeatures &obj) {
1452     ObjectWrapper object{p, name};
1453     p.PrintKeyBool("uniformBufferStandardLayout", static_cast<bool>(obj.uniformBufferStandardLayout), 27);
1454 }
1455 void DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(Printer &p, std::string name, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &obj) {
1456     ObjectWrapper object{p, name};
1457     p.PrintKeyBool("shaderSubgroupExtendedTypes", static_cast<bool>(obj.shaderSubgroupExtendedTypes), 27);
1458 }
1459 void DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(Printer &p, std::string name, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &obj) {
1460     ObjectWrapper object{p, name};
1461     p.PrintKeyBool("separateDepthStencilLayouts", static_cast<bool>(obj.separateDepthStencilLayouts), 27);
1462 }
1463 void DumpVkPhysicalDeviceHostQueryResetFeatures(Printer &p, std::string name, VkPhysicalDeviceHostQueryResetFeatures &obj) {
1464     ObjectWrapper object{p, name};
1465     p.PrintKeyBool("hostQueryReset", static_cast<bool>(obj.hostQueryReset), 14);
1466 }
1467 void DumpVkPhysicalDeviceTimelineSemaphoreFeatures(Printer &p, std::string name, VkPhysicalDeviceTimelineSemaphoreFeatures &obj) {
1468     ObjectWrapper object{p, name};
1469     p.PrintKeyBool("timelineSemaphore", static_cast<bool>(obj.timelineSemaphore), 17);
1470 }
1471 void DumpVkPhysicalDeviceTimelineSemaphoreProperties(Printer &p, std::string name, VkPhysicalDeviceTimelineSemaphoreProperties &obj) {
1472     ObjectWrapper object{p, name};
1473     p.PrintKeyValue("maxTimelineSemaphoreValueDifference", obj.maxTimelineSemaphoreValueDifference, 35);
1474 }
1475 void DumpVkPhysicalDeviceBufferDeviceAddressFeatures(Printer &p, std::string name, VkPhysicalDeviceBufferDeviceAddressFeatures &obj) {
1476     ObjectWrapper object{p, name};
1477     p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress), 32);
1478     p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay), 32);
1479     p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice), 32);
1480 }
1481 void DumpVkSurfaceCapabilitiesKHR(Printer &p, std::string name, VkSurfaceCapabilitiesKHR &obj) {
1482     ObjectWrapper object{p, name};
1483     p.PrintKeyValue("minImageCount", obj.minImageCount, 19);
1484     p.PrintKeyValue("maxImageCount", obj.maxImageCount, 19);
1485     DumpVkExtent2D(p, "currentExtent", obj.currentExtent);
1486     DumpVkExtent2D(p, "minImageExtent", obj.minImageExtent);
1487     DumpVkExtent2D(p, "maxImageExtent", obj.maxImageExtent);
1488     p.PrintKeyValue("maxImageArrayLayers", obj.maxImageArrayLayers, 19);
1489     DumpVkSurfaceTransformFlagsKHR(p, "supportedTransforms", obj.supportedTransforms, 19);
1490     DumpVkSurfaceTransformFlagBitsKHR(p, "currentTransform", obj.currentTransform, 19);
1491     DumpVkCompositeAlphaFlagsKHR(p, "supportedCompositeAlpha", obj.supportedCompositeAlpha, 19);
1492     DumpVkImageUsageFlags(p, "supportedUsageFlags", obj.supportedUsageFlags, 19);
1493 }
1494 void DumpVkSurfaceFormatKHR(Printer &p, std::string name, VkSurfaceFormatKHR &obj) {
1495     ObjectWrapper object{p, name};
1496     DumpVkFormat(p, "format", obj.format, 0);
1497     DumpVkColorSpaceKHR(p, "colorSpace", obj.colorSpace, 0);
1498 }
1499 void DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceDiscardRectanglePropertiesEXT &obj) {
1500     ObjectWrapper object{p, name};
1501     p.PrintKeyValue("maxDiscardRectangles", obj.maxDiscardRectangles, 20);
1502 }
1503 void DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceConservativeRasterizationPropertiesEXT &obj) {
1504     ObjectWrapper object{p, name};
1505     p.PrintKeyValue("primitiveOverestimationSize", obj.primitiveOverestimationSize, 43);
1506     p.PrintKeyValue("maxExtraPrimitiveOverestimationSize", obj.maxExtraPrimitiveOverestimationSize, 43);
1507     p.PrintKeyValue("extraPrimitiveOverestimationSizeGranularity", obj.extraPrimitiveOverestimationSizeGranularity, 43);
1508     p.PrintKeyBool("primitiveUnderestimation", static_cast<bool>(obj.primitiveUnderestimation), 43);
1509     p.PrintKeyBool("conservativePointAndLineRasterization", static_cast<bool>(obj.conservativePointAndLineRasterization), 43);
1510     p.PrintKeyBool("degenerateTrianglesRasterized", static_cast<bool>(obj.degenerateTrianglesRasterized), 43);
1511     p.PrintKeyBool("degenerateLinesRasterized", static_cast<bool>(obj.degenerateLinesRasterized), 43);
1512     p.PrintKeyBool("fullyCoveredFragmentShaderInputVariable", static_cast<bool>(obj.fullyCoveredFragmentShaderInputVariable), 43);
1513     p.PrintKeyBool("conservativeRasterizationPostDepthCoverage", static_cast<bool>(obj.conservativeRasterizationPostDepthCoverage), 43);
1514 }
1515 void DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceDepthClipEnableFeaturesEXT &obj) {
1516     ObjectWrapper object{p, name};
1517     p.PrintKeyBool("depthClipEnable", static_cast<bool>(obj.depthClipEnable), 15);
1518 }
1519 void DumpVkSharedPresentSurfaceCapabilitiesKHR(Printer &p, std::string name, VkSharedPresentSurfaceCapabilitiesKHR &obj) {
1520     ObjectWrapper object{p, name};
1521     DumpVkImageUsageFlags(p, "sharedPresentSupportedUsageFlags", obj.sharedPresentSupportedUsageFlags, 0);
1522 }
1523 void DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(Printer &p, std::string name, VkPhysicalDevicePerformanceQueryFeaturesKHR &obj) {
1524     ObjectWrapper object{p, name};
1525     p.PrintKeyBool("performanceCounterQueryPools", static_cast<bool>(obj.performanceCounterQueryPools), 36);
1526     p.PrintKeyBool("performanceCounterMultipleQueryPools", static_cast<bool>(obj.performanceCounterMultipleQueryPools), 36);
1527 }
1528 void DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(Printer &p, std::string name, VkPhysicalDevicePerformanceQueryPropertiesKHR &obj) {
1529     ObjectWrapper object{p, name};
1530     p.PrintKeyBool("allowCommandBufferQueryCopies", static_cast<bool>(obj.allowCommandBufferQueryCopies), 29);
1531 }
1532 void DumpVkPhysicalDeviceInlineUniformBlockFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceInlineUniformBlockFeaturesEXT &obj) {
1533     ObjectWrapper object{p, name};
1534     p.PrintKeyBool("inlineUniformBlock", static_cast<bool>(obj.inlineUniformBlock), 50);
1535     p.PrintKeyBool("descriptorBindingInlineUniformBlockUpdateAfterBind", static_cast<bool>(obj.descriptorBindingInlineUniformBlockUpdateAfterBind), 50);
1536 }
1537 void DumpVkPhysicalDeviceInlineUniformBlockPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceInlineUniformBlockPropertiesEXT &obj) {
1538     ObjectWrapper object{p, name};
1539     p.PrintKeyValue("maxInlineUniformBlockSize", obj.maxInlineUniformBlockSize, 55);
1540     p.PrintKeyValue("maxPerStageDescriptorInlineUniformBlocks", obj.maxPerStageDescriptorInlineUniformBlocks, 55);
1541     p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", obj.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, 55);
1542     p.PrintKeyValue("maxDescriptorSetInlineUniformBlocks", obj.maxDescriptorSetInlineUniformBlocks, 55);
1543     p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInlineUniformBlocks", obj.maxDescriptorSetUpdateAfterBindInlineUniformBlocks, 55);
1544 }
1545 void DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceSampleLocationsPropertiesEXT &obj) {
1546     ObjectWrapper object{p, name};
1547     DumpVkSampleCountFlags(p, "sampleLocationSampleCounts", obj.sampleLocationSampleCounts, 32);
1548     DumpVkExtent2D(p, "maxSampleLocationGridSize", obj.maxSampleLocationGridSize);
1549     {   ArrayWrapper arr(p,"sampleLocationCoordinateRange", 2);
1550         p.PrintElement(obj.sampleLocationCoordinateRange[0]);
1551         p.PrintElement(obj.sampleLocationCoordinateRange[1]);
1552     }
1553     p.PrintKeyValue("sampleLocationSubPixelBits", obj.sampleLocationSubPixelBits, 32);
1554     p.PrintKeyBool("variableSampleLocations", static_cast<bool>(obj.variableSampleLocations), 32);
1555 }
1556 void DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &obj) {
1557     ObjectWrapper object{p, name};
1558     p.PrintKeyBool("advancedBlendCoherentOperations", static_cast<bool>(obj.advancedBlendCoherentOperations), 31);
1559 }
1560 void DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &obj) {
1561     ObjectWrapper object{p, name};
1562     p.PrintKeyValue("advancedBlendMaxColorAttachments", obj.advancedBlendMaxColorAttachments, 37);
1563     p.PrintKeyBool("advancedBlendIndependentBlend", static_cast<bool>(obj.advancedBlendIndependentBlend), 37);
1564     p.PrintKeyBool("advancedBlendNonPremultipliedSrcColor", static_cast<bool>(obj.advancedBlendNonPremultipliedSrcColor), 37);
1565     p.PrintKeyBool("advancedBlendNonPremultipliedDstColor", static_cast<bool>(obj.advancedBlendNonPremultipliedDstColor), 37);
1566     p.PrintKeyBool("advancedBlendCorrelatedOverlap", static_cast<bool>(obj.advancedBlendCorrelatedOverlap), 37);
1567     p.PrintKeyBool("advancedBlendAllOperations", static_cast<bool>(obj.advancedBlendAllOperations), 37);
1568 }
1569 void DumpVkDrmFormatModifierPropertiesEXT(Printer &p, std::string name, VkDrmFormatModifierPropertiesEXT &obj) {
1570     ObjectWrapper object{p, name};
1571     p.PrintKeyValue("drmFormatModifier", obj.drmFormatModifier, 27);
1572     p.PrintKeyValue("drmFormatModifierPlaneCount", obj.drmFormatModifierPlaneCount, 27);
1573     DumpVkFormatFeatureFlags(p, "drmFormatModifierTilingFeatures", obj.drmFormatModifierTilingFeatures, 27);
1574 }
1575 void DumpVkDrmFormatModifierPropertiesListEXT(Printer &p, std::string name, VkDrmFormatModifierPropertiesListEXT &obj) {
1576     ObjectWrapper object{p, name};
1577     p.PrintKeyValue("drmFormatModifierCount", obj.drmFormatModifierCount, 52);
1578     ArrayWrapper arr(p,"pDrmFormatModifierProperties", obj.drmFormatModifierCount);
1579     for (uint32_t i = 0; i < obj.drmFormatModifierCount; i++) {
1580         if (obj.pDrmFormatModifierProperties != nullptr) {
1581             p.SetElementIndex(i);
1582             DumpVkDrmFormatModifierPropertiesEXT(p, "pDrmFormatModifierProperties", obj.pDrmFormatModifierProperties[i]);
1583         }
1584     }
1585 }
1586 void DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceExternalMemoryHostPropertiesEXT &obj) {
1587     ObjectWrapper object{p, name};
1588     p.PrintKeyValue("minImportedHostPointerAlignment", to_hex_str(p, obj.minImportedHostPointerAlignment), 31);
1589 }
1590 void DumpVkPhysicalDeviceShaderClockFeaturesKHR(Printer &p, std::string name, VkPhysicalDeviceShaderClockFeaturesKHR &obj) {
1591     ObjectWrapper object{p, name};
1592     p.PrintKeyBool("shaderSubgroupClock", static_cast<bool>(obj.shaderSubgroupClock), 19);
1593     p.PrintKeyBool("shaderDeviceClock", static_cast<bool>(obj.shaderDeviceClock), 19);
1594 }
1595 void DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &obj) {
1596     ObjectWrapper object{p, name};
1597     p.PrintKeyValue("maxVertexAttribDivisor", obj.maxVertexAttribDivisor, 22);
1598 }
1599 void DumpVkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &obj) {
1600     ObjectWrapper object{p, name};
1601     p.PrintKeyBool("vertexAttributeInstanceRateDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateDivisor), 38);
1602     p.PrintKeyBool("vertexAttributeInstanceRateZeroDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateZeroDivisor), 38);
1603 }
1604 void DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(Printer &p, std::string name, VkPhysicalDevicePCIBusInfoPropertiesEXT &obj) {
1605     ObjectWrapper object{p, name};
1606     p.PrintKeyValue("pciDomain", obj.pciDomain, 11);
1607     p.PrintKeyValue("pciBus", obj.pciBus, 11);
1608     p.PrintKeyValue("pciDevice", obj.pciDevice, 11);
1609     p.PrintKeyValue("pciFunction", obj.pciFunction, 11);
1610 }
1611 void DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceFragmentDensityMapFeaturesEXT &obj) {
1612     ObjectWrapper object{p, name};
1613     p.PrintKeyBool("fragmentDensityMap", static_cast<bool>(obj.fragmentDensityMap), 37);
1614     p.PrintKeyBool("fragmentDensityMapDynamic", static_cast<bool>(obj.fragmentDensityMapDynamic), 37);
1615     p.PrintKeyBool("fragmentDensityMapNonSubsampledImages", static_cast<bool>(obj.fragmentDensityMapNonSubsampledImages), 37);
1616 }
1617 void DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceFragmentDensityMapPropertiesEXT &obj) {
1618     ObjectWrapper object{p, name};
1619     DumpVkExtent2D(p, "minFragmentDensityTexelSize", obj.minFragmentDensityTexelSize);
1620     DumpVkExtent2D(p, "maxFragmentDensityTexelSize", obj.maxFragmentDensityTexelSize);
1621     p.PrintKeyBool("fragmentDensityInvocations", static_cast<bool>(obj.fragmentDensityInvocations), 26);
1622 }
1623 void DumpVkPhysicalDeviceSubgroupSizeControlFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT &obj) {
1624     ObjectWrapper object{p, name};
1625     p.PrintKeyBool("subgroupSizeControl", static_cast<bool>(obj.subgroupSizeControl), 20);
1626     p.PrintKeyBool("computeFullSubgroups", static_cast<bool>(obj.computeFullSubgroups), 20);
1627 }
1628 void DumpVkPhysicalDeviceSubgroupSizeControlPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT &obj) {
1629     ObjectWrapper object{p, name};
1630     p.PrintKeyValue("minSubgroupSize", obj.minSubgroupSize, 28);
1631     p.PrintKeyValue("maxSubgroupSize", obj.maxSubgroupSize, 28);
1632     p.PrintKeyValue("maxComputeWorkgroupSubgroups", obj.maxComputeWorkgroupSubgroups, 28);
1633     DumpVkShaderStageFlags(p, "requiredSubgroupSizeStages", obj.requiredSubgroupSizeStages, 28);
1634 }
1635 void DumpVkPhysicalDeviceMemoryBudgetPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceMemoryBudgetPropertiesEXT &obj) {
1636     ObjectWrapper object{p, name};
1637     {   ArrayWrapper arr(p,"heapBudget", 16);
1638         p.PrintElement(obj.heapBudget[0]);
1639         p.PrintElement(obj.heapBudget[1]);
1640         p.PrintElement(obj.heapBudget[2]);
1641         p.PrintElement(obj.heapBudget[3]);
1642         p.PrintElement(obj.heapBudget[4]);
1643         p.PrintElement(obj.heapBudget[5]);
1644         p.PrintElement(obj.heapBudget[6]);
1645         p.PrintElement(obj.heapBudget[7]);
1646         p.PrintElement(obj.heapBudget[8]);
1647         p.PrintElement(obj.heapBudget[9]);
1648         p.PrintElement(obj.heapBudget[10]);
1649         p.PrintElement(obj.heapBudget[11]);
1650         p.PrintElement(obj.heapBudget[12]);
1651         p.PrintElement(obj.heapBudget[13]);
1652         p.PrintElement(obj.heapBudget[14]);
1653         p.PrintElement(obj.heapBudget[15]);
1654     }
1655     {   ArrayWrapper arr(p,"heapUsage", 16);
1656         p.PrintElement(obj.heapUsage[0]);
1657         p.PrintElement(obj.heapUsage[1]);
1658         p.PrintElement(obj.heapUsage[2]);
1659         p.PrintElement(obj.heapUsage[3]);
1660         p.PrintElement(obj.heapUsage[4]);
1661         p.PrintElement(obj.heapUsage[5]);
1662         p.PrintElement(obj.heapUsage[6]);
1663         p.PrintElement(obj.heapUsage[7]);
1664         p.PrintElement(obj.heapUsage[8]);
1665         p.PrintElement(obj.heapUsage[9]);
1666         p.PrintElement(obj.heapUsage[10]);
1667         p.PrintElement(obj.heapUsage[11]);
1668         p.PrintElement(obj.heapUsage[12]);
1669         p.PrintElement(obj.heapUsage[13]);
1670         p.PrintElement(obj.heapUsage[14]);
1671         p.PrintElement(obj.heapUsage[15]);
1672     }
1673 }
1674 void DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceMemoryPriorityFeaturesEXT &obj) {
1675     ObjectWrapper object{p, name};
1676     p.PrintKeyBool("memoryPriority", static_cast<bool>(obj.memoryPriority), 14);
1677 }
1678 void DumpVkSurfaceProtectedCapabilitiesKHR(Printer &p, std::string name, VkSurfaceProtectedCapabilitiesKHR &obj) {
1679     ObjectWrapper object{p, name};
1680     p.PrintKeyBool("supportsProtected", static_cast<bool>(obj.supportsProtected), 17);
1681 }
1682 void DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &obj) {
1683     ObjectWrapper object{p, name};
1684     p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress), 32);
1685     p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay), 32);
1686     p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice), 32);
1687 }
1688 void DumpVkPhysicalDeviceToolPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceToolPropertiesEXT &obj) {
1689     ObjectWrapper object{p, name};
1690     p.PrintKeyString("name", obj.name, 16);
1691     p.PrintKeyString("version", obj.version, 16);
1692     DumpVkToolPurposeFlagsEXT(p, "purposes", obj.purposes, 16);
1693     p.PrintKeyString("description", obj.description, 16);
1694     p.PrintKeyString("layer", obj.layer, 16);
1695 }
1696 void DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &obj) {
1697     ObjectWrapper object{p, name};
1698     p.PrintKeyBool("fragmentShaderSampleInterlock", static_cast<bool>(obj.fragmentShaderSampleInterlock), 34);
1699     p.PrintKeyBool("fragmentShaderPixelInterlock", static_cast<bool>(obj.fragmentShaderPixelInterlock), 34);
1700     p.PrintKeyBool("fragmentShaderShadingRateInterlock", static_cast<bool>(obj.fragmentShaderShadingRateInterlock), 34);
1701 }
1702 void DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &obj) {
1703     ObjectWrapper object{p, name};
1704     p.PrintKeyBool("ycbcrImageArrays", static_cast<bool>(obj.ycbcrImageArrays), 16);
1705 }
1706 #ifdef VK_USE_PLATFORM_WIN32_KHR
1707 void DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(Printer &p, std::string name, VkSurfaceCapabilitiesFullScreenExclusiveEXT &obj) {
1708     ObjectWrapper object{p, name};
1709     p.PrintKeyBool("fullScreenExclusiveSupported", static_cast<bool>(obj.fullScreenExclusiveSupported), 28);
1710 }
1711 #endif  // VK_USE_PLATFORM_WIN32_KHR
1712 void DumpVkPhysicalDeviceLineRasterizationFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceLineRasterizationFeaturesEXT &obj) {
1713     ObjectWrapper object{p, name};
1714     p.PrintKeyBool("rectangularLines", static_cast<bool>(obj.rectangularLines), 24);
1715     p.PrintKeyBool("bresenhamLines", static_cast<bool>(obj.bresenhamLines), 24);
1716     p.PrintKeyBool("smoothLines", static_cast<bool>(obj.smoothLines), 24);
1717     p.PrintKeyBool("stippledRectangularLines", static_cast<bool>(obj.stippledRectangularLines), 24);
1718     p.PrintKeyBool("stippledBresenhamLines", static_cast<bool>(obj.stippledBresenhamLines), 24);
1719     p.PrintKeyBool("stippledSmoothLines", static_cast<bool>(obj.stippledSmoothLines), 24);
1720 }
1721 void DumpVkPhysicalDeviceLineRasterizationPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceLineRasterizationPropertiesEXT &obj) {
1722     ObjectWrapper object{p, name};
1723     p.PrintKeyValue("lineSubPixelPrecisionBits", obj.lineSubPixelPrecisionBits, 25);
1724 }
1725 void DumpVkPhysicalDeviceIndexTypeUint8FeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceIndexTypeUint8FeaturesEXT &obj) {
1726     ObjectWrapper object{p, name};
1727     p.PrintKeyBool("indexTypeUint8", static_cast<bool>(obj.indexTypeUint8), 14);
1728 }
1729 void DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(Printer &p, std::string name, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &obj) {
1730     ObjectWrapper object{p, name};
1731     p.PrintKeyBool("pipelineExecutableInfo", static_cast<bool>(obj.pipelineExecutableInfo), 22);
1732 }
1733 void DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT &obj) {
1734     ObjectWrapper object{p, name};
1735     p.PrintKeyBool("shaderDemoteToHelperInvocation", static_cast<bool>(obj.shaderDemoteToHelperInvocation), 30);
1736 }
1737 void DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &obj) {
1738     ObjectWrapper object{p, name};
1739     p.PrintKeyBool("texelBufferAlignment", static_cast<bool>(obj.texelBufferAlignment), 20);
1740 }
1741 void DumpVkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT &obj) {
1742     ObjectWrapper object{p, name};
1743     p.PrintKeyValue("storageTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.storageTexelBufferOffsetAlignmentBytes), 44);
1744     p.PrintKeyBool("storageTexelBufferOffsetSingleTexelAlignment", static_cast<bool>(obj.storageTexelBufferOffsetSingleTexelAlignment), 44);
1745     p.PrintKeyValue("uniformTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.uniformTexelBufferOffsetAlignmentBytes), 44);
1746     p.PrintKeyBool("uniformTexelBufferOffsetSingleTexelAlignment", static_cast<bool>(obj.uniformTexelBufferOffsetSingleTexelAlignment), 44);
1747 }
1748 void DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceTransformFeedbackFeaturesEXT &obj) {
1749     ObjectWrapper object{p, name};
1750     p.PrintKeyBool("transformFeedback", static_cast<bool>(obj.transformFeedback), 17);
1751     p.PrintKeyBool("geometryStreams", static_cast<bool>(obj.geometryStreams), 17);
1752 }
1753 void DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(Printer &p, std::string name, VkPhysicalDeviceTransformFeedbackPropertiesEXT &obj) {
1754     ObjectWrapper object{p, name};
1755     p.PrintKeyValue("maxTransformFeedbackStreams", obj.maxTransformFeedbackStreams, 42);
1756     p.PrintKeyValue("maxTransformFeedbackBuffers", obj.maxTransformFeedbackBuffers, 42);
1757     p.PrintKeyValue("maxTransformFeedbackBufferSize", to_hex_str(p, obj.maxTransformFeedbackBufferSize), 42);
1758     p.PrintKeyValue("maxTransformFeedbackStreamDataSize", obj.maxTransformFeedbackStreamDataSize, 42);
1759     p.PrintKeyValue("maxTransformFeedbackBufferDataSize", obj.maxTransformFeedbackBufferDataSize, 42);
1760     p.PrintKeyValue("maxTransformFeedbackBufferDataStride", obj.maxTransformFeedbackBufferDataStride, 42);
1761     p.PrintKeyBool("transformFeedbackQueries", static_cast<bool>(obj.transformFeedbackQueries), 42);
1762     p.PrintKeyBool("transformFeedbackStreamsLinesTriangles", static_cast<bool>(obj.transformFeedbackStreamsLinesTriangles), 42);
1763     p.PrintKeyBool("transformFeedbackRasterizationStreamSelect", static_cast<bool>(obj.transformFeedbackRasterizationStreamSelect), 42);
1764     p.PrintKeyBool("transformFeedbackDraw", static_cast<bool>(obj.transformFeedbackDraw), 42);
1765 }
1766 void DumpVkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT &obj) {
1767     ObjectWrapper object{p, name};
1768     p.PrintKeyBool("textureCompressionASTC_HDR", static_cast<bool>(obj.textureCompressionASTC_HDR), 26);
1769 }
1770 void DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceASTCDecodeFeaturesEXT &obj) {
1771     ObjectWrapper object{p, name};
1772     p.PrintKeyBool("decodeModeSharedExponent", static_cast<bool>(obj.decodeModeSharedExponent), 24);
1773 }
1774 void DumpVkPhysicalDevicePushDescriptorPropertiesKHR(Printer &p, std::string name, VkPhysicalDevicePushDescriptorPropertiesKHR &obj) {
1775     ObjectWrapper object{p, name};
1776     p.PrintKeyValue("maxPushDescriptors", obj.maxPushDescriptors, 18);
1777 }
1778 void DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(Printer &p, std::string name, VkPhysicalDeviceConditionalRenderingFeaturesEXT &obj) {
1779     ObjectWrapper object{p, name};
1780     p.PrintKeyBool("conditionalRendering", static_cast<bool>(obj.conditionalRendering), 29);
1781     p.PrintKeyBool("inheritedConditionalRendering", static_cast<bool>(obj.inheritedConditionalRendering), 29);
1782 }
1783 pNextChainInfos get_chain_infos() {
1784     pNextChainInfos infos;
1785     infos.phys_device_props2 = {
1786         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, sizeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT)},
1787         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, sizeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT)},
1788         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, sizeof(VkPhysicalDeviceDepthStencilResolveProperties)},
1789         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, sizeof(VkPhysicalDeviceDescriptorIndexingProperties)},
1790         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, sizeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT)},
1791         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, sizeof(VkPhysicalDeviceDriverProperties)},
1792         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, sizeof(VkPhysicalDeviceExternalMemoryHostPropertiesEXT)},
1793         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, sizeof(VkPhysicalDeviceFloatControlsProperties)},
1794         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT)},
1795         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, sizeof(VkPhysicalDeviceIDProperties)},
1796         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT, sizeof(VkPhysicalDeviceInlineUniformBlockPropertiesEXT)},
1797         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT, sizeof(VkPhysicalDeviceLineRasterizationPropertiesEXT)},
1798         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, sizeof(VkPhysicalDeviceMaintenance3Properties)},
1799         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, sizeof(VkPhysicalDeviceMultiviewProperties)},
1800         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, sizeof(VkPhysicalDevicePCIBusInfoPropertiesEXT)},
1801         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR, sizeof(VkPhysicalDevicePerformanceQueryPropertiesKHR)},
1802         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, sizeof(VkPhysicalDevicePointClippingProperties)},
1803         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, sizeof(VkPhysicalDeviceProtectedMemoryProperties)},
1804         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR)},
1805         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, sizeof(VkPhysicalDeviceSampleLocationsPropertiesEXT)},
1806         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, sizeof(VkPhysicalDeviceSamplerFilterMinmaxProperties)},
1807         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, sizeof(VkPhysicalDeviceSubgroupProperties)},
1808         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, sizeof(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)},
1809         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, sizeof(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)},
1810         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, sizeof(VkPhysicalDeviceTimelineSemaphoreProperties)},
1811         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT, sizeof(VkPhysicalDeviceTransformFeedbackPropertiesEXT)},
1812         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT)},
1813         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, sizeof(VkPhysicalDeviceVulkan11Properties)},
1814         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, sizeof(VkPhysicalDeviceVulkan12Properties)},
1815     };
1816     infos.phys_device_mem_props2 = {
1817         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT)},
1818     };
1819     infos.phys_device_features2 = {
1820         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, sizeof(VkPhysicalDevice16BitStorageFeatures)},
1821         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, sizeof(VkPhysicalDevice8BitStorageFeatures)},
1822         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT)},
1823         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT)},
1824         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures)},
1825         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, sizeof(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT)},
1826         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT)},
1827         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT)},
1828         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, sizeof(VkPhysicalDeviceDescriptorIndexingFeatures)},
1829         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT)},
1830         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, sizeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT)},
1831         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, sizeof(VkPhysicalDeviceHostQueryResetFeatures)},
1832         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, sizeof(VkPhysicalDeviceImagelessFramebufferFeatures)},
1833         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, sizeof(VkPhysicalDeviceIndexTypeUint8FeaturesEXT)},
1834         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, sizeof(VkPhysicalDeviceInlineUniformBlockFeaturesEXT)},
1835         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, sizeof(VkPhysicalDeviceLineRasterizationFeaturesEXT)},
1836         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, sizeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT)},
1837         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, sizeof(VkPhysicalDeviceMultiviewFeatures)},
1838         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, sizeof(VkPhysicalDevicePerformanceQueryFeaturesKHR)},
1839         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR)},
1840         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, sizeof(VkPhysicalDeviceProtectedMemoryFeatures)},
1841         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures)},
1842         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures)},
1843         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures)},
1844         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, sizeof(VkPhysicalDeviceShaderAtomicInt64Features)},
1845         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, sizeof(VkPhysicalDeviceShaderClockFeaturesKHR)},
1846         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)},
1847         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, sizeof(VkPhysicalDeviceShaderDrawParametersFeatures)},
1848         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, sizeof(VkPhysicalDeviceShaderFloat16Int8Features)},
1849         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures)},
1850         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT, sizeof(VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)},
1851         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT)},
1852         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT, sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)},
1853         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures)},
1854         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT)},
1855         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures)},
1856         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, sizeof(VkPhysicalDeviceVariablePointersFeatures)},
1857         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, sizeof(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)},
1858         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, sizeof(VkPhysicalDeviceVulkan11Features)},
1859         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, sizeof(VkPhysicalDeviceVulkan12Features)},
1860         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures)},
1861         {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT)},
1862     };
1863     infos.surface_capabilities2 = {
1864         {VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, sizeof(VkSharedPresentSurfaceCapabilitiesKHR)},
1865 #ifdef VK_USE_PLATFORM_WIN32_KHR
1866         {VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT, sizeof(VkSurfaceCapabilitiesFullScreenExclusiveEXT)},
1867 #endif  // VK_USE_PLATFORM_WIN32_KHR
1868         {VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR, sizeof(VkSurfaceProtectedCapabilitiesKHR)},
1869     };
1870     infos.format_properties2 = {
1871         {VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT, sizeof(VkDrmFormatModifierPropertiesListEXT)},
1872     };
1873     return infos;
1874 }
1875 void chain_iterator_phys_device_props2(Printer &p, AppInstance &inst, AppGpu &gpu, void * place, VulkanVersion version) {
1876     while (place) {
1877         struct VkStructureHeader *structure = (struct VkStructureHeader *)place;
1878         p.SetSubHeader();
1879         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES &&
1880            (version.minor >= 1)) {
1881             VkPhysicalDeviceSubgroupProperties* props = (VkPhysicalDeviceSubgroupProperties*)structure;
1882             DumpVkPhysicalDeviceSubgroupProperties(p, "VkPhysicalDeviceSubgroupProperties", *props);
1883             p.AddNewline();
1884         }
1885         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES &&
1886            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE2_EXTENSION_NAME) ||
1887             version.minor >= 1)) {
1888             VkPhysicalDevicePointClippingProperties* props = (VkPhysicalDevicePointClippingProperties*)structure;
1889             DumpVkPhysicalDevicePointClippingProperties(p, version.minor >= 1 ?"VkPhysicalDevicePointClippingProperties":"VkPhysicalDevicePointClippingPropertiesKHR", *props);
1890             p.AddNewline();
1891         }
1892         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES &&
1893            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME) ||
1894             version.minor >= 1)) {
1895             VkPhysicalDeviceMultiviewProperties* props = (VkPhysicalDeviceMultiviewProperties*)structure;
1896             DumpVkPhysicalDeviceMultiviewProperties(p, version.minor >= 1 ?"VkPhysicalDeviceMultiviewProperties":"VkPhysicalDeviceMultiviewPropertiesKHR", *props);
1897             p.AddNewline();
1898         }
1899         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES &&
1900            (version.minor >= 1)) {
1901             VkPhysicalDeviceProtectedMemoryProperties* props = (VkPhysicalDeviceProtectedMemoryProperties*)structure;
1902             DumpVkPhysicalDeviceProtectedMemoryProperties(p, "VkPhysicalDeviceProtectedMemoryProperties", *props);
1903             p.AddNewline();
1904         }
1905         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES &&
1906            (inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME) ||
1907             version.minor >= 1)) {
1908             VkPhysicalDeviceIDProperties* props = (VkPhysicalDeviceIDProperties*)structure;
1909             DumpVkPhysicalDeviceIDProperties(p, version.minor >= 1 ?"VkPhysicalDeviceIDProperties":"VkPhysicalDeviceIDPropertiesKHR", *props);
1910             p.AddNewline();
1911         }
1912         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES &&
1913            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE3_EXTENSION_NAME) ||
1914             version.minor >= 1)) {
1915             VkPhysicalDeviceMaintenance3Properties* props = (VkPhysicalDeviceMaintenance3Properties*)structure;
1916             DumpVkPhysicalDeviceMaintenance3Properties(p, version.minor >= 1 ?"VkPhysicalDeviceMaintenance3Properties":"VkPhysicalDeviceMaintenance3PropertiesKHR", *props);
1917             p.AddNewline();
1918         }
1919         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES &&
1920            (version.minor >= 2)) {
1921             VkPhysicalDeviceVulkan11Properties* props = (VkPhysicalDeviceVulkan11Properties*)structure;
1922             DumpVkPhysicalDeviceVulkan11Properties(p, "VkPhysicalDeviceVulkan11Properties", *props);
1923             p.AddNewline();
1924         }
1925         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES &&
1926            (version.minor >= 2)) {
1927             VkPhysicalDeviceVulkan12Properties* props = (VkPhysicalDeviceVulkan12Properties*)structure;
1928             DumpVkPhysicalDeviceVulkan12Properties(p, "VkPhysicalDeviceVulkan12Properties", *props);
1929             p.AddNewline();
1930         }
1931         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES &&
1932            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME) ||
1933             version.minor >= 2)) {
1934             VkPhysicalDeviceDriverProperties* props = (VkPhysicalDeviceDriverProperties*)structure;
1935             DumpVkPhysicalDeviceDriverProperties(p, version.minor >= 2 ?"VkPhysicalDeviceDriverProperties":"VkPhysicalDeviceDriverPropertiesKHR", *props);
1936             p.AddNewline();
1937         }
1938         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES &&
1939            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME) ||
1940             version.minor >= 2)) {
1941             VkPhysicalDeviceFloatControlsProperties* props = (VkPhysicalDeviceFloatControlsProperties*)structure;
1942             DumpVkPhysicalDeviceFloatControlsProperties(p, version.minor >= 2 ?"VkPhysicalDeviceFloatControlsProperties":"VkPhysicalDeviceFloatControlsPropertiesKHR", *props);
1943             p.AddNewline();
1944         }
1945         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES &&
1946            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME) ||
1947             version.minor >= 2)) {
1948             VkPhysicalDeviceDescriptorIndexingProperties* props = (VkPhysicalDeviceDescriptorIndexingProperties*)structure;
1949             DumpVkPhysicalDeviceDescriptorIndexingProperties(p, version.minor >= 2 ?"VkPhysicalDeviceDescriptorIndexingProperties":"VkPhysicalDeviceDescriptorIndexingPropertiesEXT", *props);
1950             p.AddNewline();
1951         }
1952         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES &&
1953            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME) ||
1954             version.minor >= 2)) {
1955             VkPhysicalDeviceDepthStencilResolveProperties* props = (VkPhysicalDeviceDepthStencilResolveProperties*)structure;
1956             DumpVkPhysicalDeviceDepthStencilResolveProperties(p, version.minor >= 2 ?"VkPhysicalDeviceDepthStencilResolveProperties":"VkPhysicalDeviceDepthStencilResolvePropertiesKHR", *props);
1957             p.AddNewline();
1958         }
1959         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES &&
1960            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME) ||
1961             version.minor >= 2)) {
1962             VkPhysicalDeviceSamplerFilterMinmaxProperties* props = (VkPhysicalDeviceSamplerFilterMinmaxProperties*)structure;
1963             DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(p, version.minor >= 2 ?"VkPhysicalDeviceSamplerFilterMinmaxProperties":"VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT", *props);
1964             p.AddNewline();
1965         }
1966         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES &&
1967            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME) ||
1968             version.minor >= 2)) {
1969             VkPhysicalDeviceTimelineSemaphoreProperties* props = (VkPhysicalDeviceTimelineSemaphoreProperties*)structure;
1970             DumpVkPhysicalDeviceTimelineSemaphoreProperties(p, version.minor >= 2 ?"VkPhysicalDeviceTimelineSemaphoreProperties":"VkPhysicalDeviceTimelineSemaphorePropertiesKHR", *props);
1971             p.AddNewline();
1972         }
1973         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT &&
1974            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME))) {
1975             VkPhysicalDeviceDiscardRectanglePropertiesEXT* props = (VkPhysicalDeviceDiscardRectanglePropertiesEXT*)structure;
1976             DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(p, "VkPhysicalDeviceDiscardRectanglePropertiesEXT", *props);
1977             p.AddNewline();
1978         }
1979         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT &&
1980            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME))) {
1981             VkPhysicalDeviceConservativeRasterizationPropertiesEXT* props = (VkPhysicalDeviceConservativeRasterizationPropertiesEXT*)structure;
1982             DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(p, "VkPhysicalDeviceConservativeRasterizationPropertiesEXT", *props);
1983             p.AddNewline();
1984         }
1985         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR &&
1986            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME))) {
1987             VkPhysicalDevicePerformanceQueryPropertiesKHR* props = (VkPhysicalDevicePerformanceQueryPropertiesKHR*)structure;
1988             DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(p, "VkPhysicalDevicePerformanceQueryPropertiesKHR", *props);
1989             p.AddNewline();
1990         }
1991         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT &&
1992            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME))) {
1993             VkPhysicalDeviceInlineUniformBlockPropertiesEXT* props = (VkPhysicalDeviceInlineUniformBlockPropertiesEXT*)structure;
1994             DumpVkPhysicalDeviceInlineUniformBlockPropertiesEXT(p, "VkPhysicalDeviceInlineUniformBlockPropertiesEXT", *props);
1995             p.AddNewline();
1996         }
1997         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT &&
1998            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME))) {
1999             VkPhysicalDeviceSampleLocationsPropertiesEXT* props = (VkPhysicalDeviceSampleLocationsPropertiesEXT*)structure;
2000             DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(p, "VkPhysicalDeviceSampleLocationsPropertiesEXT", *props);
2001             p.AddNewline();
2002         }
2003         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT &&
2004            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME))) {
2005             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* props = (VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*)structure;
2006             DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(p, "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT", *props);
2007             p.AddNewline();
2008         }
2009         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT &&
2010            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME))) {
2011             VkPhysicalDeviceExternalMemoryHostPropertiesEXT* props = (VkPhysicalDeviceExternalMemoryHostPropertiesEXT*)structure;
2012             DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(p, "VkPhysicalDeviceExternalMemoryHostPropertiesEXT", *props);
2013             p.AddNewline();
2014         }
2015         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT &&
2016            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME))) {
2017             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* props = (VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*)structure;
2018             DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(p, "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT", *props);
2019             p.AddNewline();
2020         }
2021         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT &&
2022            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PCI_BUS_INFO_EXTENSION_NAME))) {
2023             VkPhysicalDevicePCIBusInfoPropertiesEXT* props = (VkPhysicalDevicePCIBusInfoPropertiesEXT*)structure;
2024             DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(p, "VkPhysicalDevicePCIBusInfoPropertiesEXT", *props);
2025             p.AddNewline();
2026         }
2027         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT &&
2028            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME))) {
2029             VkPhysicalDeviceFragmentDensityMapPropertiesEXT* props = (VkPhysicalDeviceFragmentDensityMapPropertiesEXT*)structure;
2030             DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(p, "VkPhysicalDeviceFragmentDensityMapPropertiesEXT", *props);
2031             p.AddNewline();
2032         }
2033         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT &&
2034            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME))) {
2035             VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* props = (VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*)structure;
2036             DumpVkPhysicalDeviceSubgroupSizeControlPropertiesEXT(p, "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT", *props);
2037             p.AddNewline();
2038         }
2039         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT &&
2040            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME))) {
2041             VkPhysicalDeviceLineRasterizationPropertiesEXT* props = (VkPhysicalDeviceLineRasterizationPropertiesEXT*)structure;
2042             DumpVkPhysicalDeviceLineRasterizationPropertiesEXT(p, "VkPhysicalDeviceLineRasterizationPropertiesEXT", *props);
2043             p.AddNewline();
2044         }
2045         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT &&
2046            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME))) {
2047             VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* props = (VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*)structure;
2048             DumpVkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(p, "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT", *props);
2049             p.AddNewline();
2050         }
2051         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT &&
2052            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME))) {
2053             VkPhysicalDeviceTransformFeedbackPropertiesEXT* props = (VkPhysicalDeviceTransformFeedbackPropertiesEXT*)structure;
2054             DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(p, "VkPhysicalDeviceTransformFeedbackPropertiesEXT", *props);
2055             p.AddNewline();
2056         }
2057         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR &&
2058            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME))) {
2059             VkPhysicalDevicePushDescriptorPropertiesKHR* props = (VkPhysicalDevicePushDescriptorPropertiesKHR*)structure;
2060             DumpVkPhysicalDevicePushDescriptorPropertiesKHR(p, "VkPhysicalDevicePushDescriptorPropertiesKHR", *props);
2061             p.AddNewline();
2062         }
2063         place = structure->pNext;
2064     }
2065 }
2066 void chain_iterator_phys_device_mem_props2(Printer &p, AppGpu &gpu, void * place, VulkanVersion version) {
2067     while (place) {
2068         struct VkStructureHeader *structure = (struct VkStructureHeader *)place;
2069         p.SetSubHeader();
2070         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT &&
2071            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME))) {
2072             VkPhysicalDeviceMemoryBudgetPropertiesEXT* props = (VkPhysicalDeviceMemoryBudgetPropertiesEXT*)structure;
2073             DumpVkPhysicalDeviceMemoryBudgetPropertiesEXT(p, "VkPhysicalDeviceMemoryBudgetPropertiesEXT", *props);
2074             p.AddNewline();
2075         }
2076         place = structure->pNext;
2077     }
2078 }
2079 void chain_iterator_phys_device_features2(Printer &p, AppGpu &gpu, void * place, VulkanVersion version) {
2080     while (place) {
2081         struct VkStructureHeader *structure = (struct VkStructureHeader *)place;
2082         p.SetSubHeader();
2083         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES &&
2084            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_16BIT_STORAGE_EXTENSION_NAME) ||
2085             version.minor >= 1)) {
2086             VkPhysicalDevice16BitStorageFeatures* props = (VkPhysicalDevice16BitStorageFeatures*)structure;
2087             DumpVkPhysicalDevice16BitStorageFeatures(p, version.minor >= 1 ?"VkPhysicalDevice16BitStorageFeatures":"VkPhysicalDevice16BitStorageFeaturesKHR", *props);
2088             p.AddNewline();
2089         }
2090         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES &&
2091            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME) ||
2092             version.minor >= 1)) {
2093             VkPhysicalDeviceMultiviewFeatures* props = (VkPhysicalDeviceMultiviewFeatures*)structure;
2094             DumpVkPhysicalDeviceMultiviewFeatures(p, version.minor >= 1 ?"VkPhysicalDeviceMultiviewFeatures":"VkPhysicalDeviceMultiviewFeaturesKHR", *props);
2095             p.AddNewline();
2096         }
2097         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES &&
2098            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME) ||
2099             version.minor >= 1)) {
2100             VkPhysicalDeviceVariablePointersFeatures* props = (VkPhysicalDeviceVariablePointersFeatures*)structure;
2101             DumpVkPhysicalDeviceVariablePointersFeatures(p, version.minor >= 1 ?"VkPhysicalDeviceVariablePointersFeatures":"VkPhysicalDeviceVariablePointersFeaturesKHR", *props);
2102             p.AddNewline();
2103         }
2104         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES &&
2105            (version.minor >= 1)) {
2106             VkPhysicalDeviceProtectedMemoryFeatures* props = (VkPhysicalDeviceProtectedMemoryFeatures*)structure;
2107             DumpVkPhysicalDeviceProtectedMemoryFeatures(p, "VkPhysicalDeviceProtectedMemoryFeatures", *props);
2108             p.AddNewline();
2109         }
2110         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES &&
2111            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME) ||
2112             version.minor >= 1)) {
2113             VkPhysicalDeviceSamplerYcbcrConversionFeatures* props = (VkPhysicalDeviceSamplerYcbcrConversionFeatures*)structure;
2114             DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(p, version.minor >= 1 ?"VkPhysicalDeviceSamplerYcbcrConversionFeatures":"VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR", *props);
2115             p.AddNewline();
2116         }
2117         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES &&
2118            (version.minor >= 1)) {
2119             VkPhysicalDeviceShaderDrawParametersFeatures* props = (VkPhysicalDeviceShaderDrawParametersFeatures*)structure;
2120             DumpVkPhysicalDeviceShaderDrawParametersFeatures(p, version.minor >= 1 ?"VkPhysicalDeviceShaderDrawParametersFeatures":"VkPhysicalDeviceShaderDrawParameterFeatures", *props);
2121             p.AddNewline();
2122         }
2123         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES &&
2124            (version.minor >= 2)) {
2125             VkPhysicalDeviceVulkan11Features* props = (VkPhysicalDeviceVulkan11Features*)structure;
2126             DumpVkPhysicalDeviceVulkan11Features(p, "VkPhysicalDeviceVulkan11Features", *props);
2127             p.AddNewline();
2128         }
2129         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES &&
2130            (version.minor >= 2)) {
2131             VkPhysicalDeviceVulkan12Features* props = (VkPhysicalDeviceVulkan12Features*)structure;
2132             DumpVkPhysicalDeviceVulkan12Features(p, "VkPhysicalDeviceVulkan12Features", *props);
2133             p.AddNewline();
2134         }
2135         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES &&
2136            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_8BIT_STORAGE_EXTENSION_NAME) ||
2137             version.minor >= 2)) {
2138             VkPhysicalDevice8BitStorageFeatures* props = (VkPhysicalDevice8BitStorageFeatures*)structure;
2139             DumpVkPhysicalDevice8BitStorageFeatures(p, version.minor >= 2 ?"VkPhysicalDevice8BitStorageFeatures":"VkPhysicalDevice8BitStorageFeaturesKHR", *props);
2140             p.AddNewline();
2141         }
2142         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES &&
2143            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME) ||
2144             version.minor >= 2)) {
2145             VkPhysicalDeviceShaderAtomicInt64Features* props = (VkPhysicalDeviceShaderAtomicInt64Features*)structure;
2146             DumpVkPhysicalDeviceShaderAtomicInt64Features(p, version.minor >= 2 ?"VkPhysicalDeviceShaderAtomicInt64Features":"VkPhysicalDeviceShaderAtomicInt64FeaturesKHR", *props);
2147             p.AddNewline();
2148         }
2149         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES &&
2150            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME) ||
2151             version.minor >= 2)) {
2152             VkPhysicalDeviceShaderFloat16Int8Features* props = (VkPhysicalDeviceShaderFloat16Int8Features*)structure;
2153             DumpVkPhysicalDeviceShaderFloat16Int8Features(p, version.minor >= 2 ?"VkPhysicalDeviceShaderFloat16Int8Features":"VkPhysicalDeviceFloat16Int8FeaturesKHR", *props);
2154             p.AddNewline();
2155         }
2156         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES &&
2157            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME) ||
2158             version.minor >= 2)) {
2159             VkPhysicalDeviceDescriptorIndexingFeatures* props = (VkPhysicalDeviceDescriptorIndexingFeatures*)structure;
2160             DumpVkPhysicalDeviceDescriptorIndexingFeatures(p, version.minor >= 2 ?"VkPhysicalDeviceDescriptorIndexingFeatures":"VkPhysicalDeviceDescriptorIndexingFeaturesEXT", *props);
2161             p.AddNewline();
2162         }
2163         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES &&
2164            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME) ||
2165             version.minor >= 2)) {
2166             VkPhysicalDeviceScalarBlockLayoutFeatures* props = (VkPhysicalDeviceScalarBlockLayoutFeatures*)structure;
2167             DumpVkPhysicalDeviceScalarBlockLayoutFeatures(p, version.minor >= 2 ?"VkPhysicalDeviceScalarBlockLayoutFeatures":"VkPhysicalDeviceScalarBlockLayoutFeaturesEXT", *props);
2168             p.AddNewline();
2169         }
2170         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES &&
2171            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME) ||
2172             version.minor >= 2)) {
2173             VkPhysicalDeviceVulkanMemoryModelFeatures* props = (VkPhysicalDeviceVulkanMemoryModelFeatures*)structure;
2174             DumpVkPhysicalDeviceVulkanMemoryModelFeatures(p, version.minor >= 2 ?"VkPhysicalDeviceVulkanMemoryModelFeatures":"VkPhysicalDeviceVulkanMemoryModelFeaturesKHR", *props);
2175             p.AddNewline();
2176         }
2177         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES &&
2178            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME) ||
2179             version.minor >= 2)) {
2180             VkPhysicalDeviceImagelessFramebufferFeatures* props = (VkPhysicalDeviceImagelessFramebufferFeatures*)structure;
2181             DumpVkPhysicalDeviceImagelessFramebufferFeatures(p, version.minor >= 2 ?"VkPhysicalDeviceImagelessFramebufferFeatures":"VkPhysicalDeviceImagelessFramebufferFeaturesKHR", *props);
2182             p.AddNewline();
2183         }
2184         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES &&
2185            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME) ||
2186             version.minor >= 2)) {
2187             VkPhysicalDeviceUniformBufferStandardLayoutFeatures* props = (VkPhysicalDeviceUniformBufferStandardLayoutFeatures*)structure;
2188             DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(p, version.minor >= 2 ?"VkPhysicalDeviceUniformBufferStandardLayoutFeatures":"VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR", *props);
2189             p.AddNewline();
2190         }
2191         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES &&
2192            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME) ||
2193             version.minor >= 2)) {
2194             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* props = (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*)structure;
2195             DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(p, version.minor >= 2 ?"VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures":"VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR", *props);
2196             p.AddNewline();
2197         }
2198         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES &&
2199            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME) ||
2200             version.minor >= 2)) {
2201             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* props = (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*)structure;
2202             DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(p, version.minor >= 2 ?"VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures":"VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR", *props);
2203             p.AddNewline();
2204         }
2205         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES &&
2206            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME) ||
2207             version.minor >= 2)) {
2208             VkPhysicalDeviceHostQueryResetFeatures* props = (VkPhysicalDeviceHostQueryResetFeatures*)structure;
2209             DumpVkPhysicalDeviceHostQueryResetFeatures(p, version.minor >= 2 ?"VkPhysicalDeviceHostQueryResetFeatures":"VkPhysicalDeviceHostQueryResetFeaturesEXT", *props);
2210             p.AddNewline();
2211         }
2212         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES &&
2213            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME) ||
2214             version.minor >= 2)) {
2215             VkPhysicalDeviceTimelineSemaphoreFeatures* props = (VkPhysicalDeviceTimelineSemaphoreFeatures*)structure;
2216             DumpVkPhysicalDeviceTimelineSemaphoreFeatures(p, version.minor >= 2 ?"VkPhysicalDeviceTimelineSemaphoreFeatures":"VkPhysicalDeviceTimelineSemaphoreFeaturesKHR", *props);
2217             p.AddNewline();
2218         }
2219         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES &&
2220            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME) ||
2221             version.minor >= 2)) {
2222             VkPhysicalDeviceBufferDeviceAddressFeatures* props = (VkPhysicalDeviceBufferDeviceAddressFeatures*)structure;
2223             DumpVkPhysicalDeviceBufferDeviceAddressFeatures(p, version.minor >= 2 ?"VkPhysicalDeviceBufferDeviceAddressFeatures":"VkPhysicalDeviceBufferDeviceAddressFeaturesKHR", *props);
2224             p.AddNewline();
2225         }
2226         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT &&
2227            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME))) {
2228             VkPhysicalDeviceDepthClipEnableFeaturesEXT* props = (VkPhysicalDeviceDepthClipEnableFeaturesEXT*)structure;
2229             DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(p, "VkPhysicalDeviceDepthClipEnableFeaturesEXT", *props);
2230             p.AddNewline();
2231         }
2232         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR &&
2233            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME))) {
2234             VkPhysicalDevicePerformanceQueryFeaturesKHR* props = (VkPhysicalDevicePerformanceQueryFeaturesKHR*)structure;
2235             DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(p, "VkPhysicalDevicePerformanceQueryFeaturesKHR", *props);
2236             p.AddNewline();
2237         }
2238         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT &&
2239            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME))) {
2240             VkPhysicalDeviceInlineUniformBlockFeaturesEXT* props = (VkPhysicalDeviceInlineUniformBlockFeaturesEXT*)structure;
2241             DumpVkPhysicalDeviceInlineUniformBlockFeaturesEXT(p, "VkPhysicalDeviceInlineUniformBlockFeaturesEXT", *props);
2242             p.AddNewline();
2243         }
2244         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT &&
2245            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME))) {
2246             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* props = (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*)structure;
2247             DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(p, "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT", *props);
2248             p.AddNewline();
2249         }
2250         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR &&
2251            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_CLOCK_EXTENSION_NAME))) {
2252             VkPhysicalDeviceShaderClockFeaturesKHR* props = (VkPhysicalDeviceShaderClockFeaturesKHR*)structure;
2253             DumpVkPhysicalDeviceShaderClockFeaturesKHR(p, "VkPhysicalDeviceShaderClockFeaturesKHR", *props);
2254             p.AddNewline();
2255         }
2256         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT &&
2257            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME))) {
2258             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* props = (VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*)structure;
2259             DumpVkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(p, "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT", *props);
2260             p.AddNewline();
2261         }
2262         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT &&
2263            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME))) {
2264             VkPhysicalDeviceFragmentDensityMapFeaturesEXT* props = (VkPhysicalDeviceFragmentDensityMapFeaturesEXT*)structure;
2265             DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(p, "VkPhysicalDeviceFragmentDensityMapFeaturesEXT", *props);
2266             p.AddNewline();
2267         }
2268         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT &&
2269            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME))) {
2270             VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* props = (VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*)structure;
2271             DumpVkPhysicalDeviceSubgroupSizeControlFeaturesEXT(p, "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT", *props);
2272             p.AddNewline();
2273         }
2274         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT &&
2275            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME))) {
2276             VkPhysicalDeviceMemoryPriorityFeaturesEXT* props = (VkPhysicalDeviceMemoryPriorityFeaturesEXT*)structure;
2277             DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(p, "VkPhysicalDeviceMemoryPriorityFeaturesEXT", *props);
2278             p.AddNewline();
2279         }
2280         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT &&
2281            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME))) {
2282             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* props = (VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*)structure;
2283             DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(p, "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT", *props);
2284             p.AddNewline();
2285         }
2286         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT &&
2287            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME))) {
2288             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* props = (VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*)structure;
2289             DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(p, "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT", *props);
2290             p.AddNewline();
2291         }
2292         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT &&
2293            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME))) {
2294             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* props = (VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*)structure;
2295             DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(p, "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT", *props);
2296             p.AddNewline();
2297         }
2298         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT &&
2299            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME))) {
2300             VkPhysicalDeviceLineRasterizationFeaturesEXT* props = (VkPhysicalDeviceLineRasterizationFeaturesEXT*)structure;
2301             DumpVkPhysicalDeviceLineRasterizationFeaturesEXT(p, "VkPhysicalDeviceLineRasterizationFeaturesEXT", *props);
2302             p.AddNewline();
2303         }
2304         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT &&
2305            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME))) {
2306             VkPhysicalDeviceIndexTypeUint8FeaturesEXT* props = (VkPhysicalDeviceIndexTypeUint8FeaturesEXT*)structure;
2307             DumpVkPhysicalDeviceIndexTypeUint8FeaturesEXT(p, "VkPhysicalDeviceIndexTypeUint8FeaturesEXT", *props);
2308             p.AddNewline();
2309         }
2310         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR &&
2311            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME))) {
2312             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* props = (VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*)structure;
2313             DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(p, "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR", *props);
2314             p.AddNewline();
2315         }
2316         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT &&
2317            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME))) {
2318             VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* props = (VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*)structure;
2319             DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(p, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT", *props);
2320             p.AddNewline();
2321         }
2322         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT &&
2323            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME))) {
2324             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* props = (VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*)structure;
2325             DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(p, "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT", *props);
2326             p.AddNewline();
2327         }
2328         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT &&
2329            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME))) {
2330             VkPhysicalDeviceTransformFeedbackFeaturesEXT* props = (VkPhysicalDeviceTransformFeedbackFeaturesEXT*)structure;
2331             DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(p, "VkPhysicalDeviceTransformFeedbackFeaturesEXT", *props);
2332             p.AddNewline();
2333         }
2334         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT &&
2335            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME))) {
2336             VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* props = (VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*)structure;
2337             DumpVkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(p, "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT", *props);
2338             p.AddNewline();
2339         }
2340         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT &&
2341            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME))) {
2342             VkPhysicalDeviceASTCDecodeFeaturesEXT* props = (VkPhysicalDeviceASTCDecodeFeaturesEXT*)structure;
2343             DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(p, "VkPhysicalDeviceASTCDecodeFeaturesEXT", *props);
2344             p.AddNewline();
2345         }
2346         if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT &&
2347            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME))) {
2348             VkPhysicalDeviceConditionalRenderingFeaturesEXT* props = (VkPhysicalDeviceConditionalRenderingFeaturesEXT*)structure;
2349             DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(p, "VkPhysicalDeviceConditionalRenderingFeaturesEXT", *props);
2350             p.AddNewline();
2351         }
2352         place = structure->pNext;
2353     }
2354 }
2355 void chain_iterator_surface_capabilities2(Printer &p, AppInstance &inst, AppGpu &gpu, void * place, VulkanVersion version) {
2356     while (place) {
2357         struct VkStructureHeader *structure = (struct VkStructureHeader *)place;
2358         p.SetSubHeader();
2359         if (structure->sType == VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR &&
2360            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME))) {
2361             VkSharedPresentSurfaceCapabilitiesKHR* props = (VkSharedPresentSurfaceCapabilitiesKHR*)structure;
2362             DumpVkSharedPresentSurfaceCapabilitiesKHR(p, "VkSharedPresentSurfaceCapabilitiesKHR", *props);
2363             p.AddNewline();
2364         }
2365         if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR &&
2366            (inst.CheckExtensionEnabled(VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME))) {
2367             VkSurfaceProtectedCapabilitiesKHR* props = (VkSurfaceProtectedCapabilitiesKHR*)structure;
2368             DumpVkSurfaceProtectedCapabilitiesKHR(p, "VkSurfaceProtectedCapabilitiesKHR", *props);
2369             p.AddNewline();
2370         }
2371 #ifdef VK_USE_PLATFORM_WIN32_KHR
2372         if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT &&
2373            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME))) {
2374             VkSurfaceCapabilitiesFullScreenExclusiveEXT* props = (VkSurfaceCapabilitiesFullScreenExclusiveEXT*)structure;
2375             DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(p, "VkSurfaceCapabilitiesFullScreenExclusiveEXT", *props);
2376             p.AddNewline();
2377         }
2378 #endif  // VK_USE_PLATFORM_WIN32_KHR
2379         place = structure->pNext;
2380     }
2381 }
2382 void chain_iterator_format_properties2(Printer &p, AppGpu &gpu, void * place, VulkanVersion version) {
2383     while (place) {
2384         struct VkStructureHeader *structure = (struct VkStructureHeader *)place;
2385         p.SetSubHeader();
2386         if (structure->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT &&
2387            (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME))) {
2388             VkDrmFormatModifierPropertiesListEXT* props = (VkDrmFormatModifierPropertiesListEXT*)structure;
2389             DumpVkDrmFormatModifierPropertiesListEXT(p, "VkDrmFormatModifierPropertiesListEXT", *props);
2390             p.AddNewline();
2391         }
2392         place = structure->pNext;
2393     }
2394 }
2395 bool operator==(const VkExtent2D & a, const VkExtent2D b) {
2396     return a.width == b.width
2397         && a.height == b.height;
2398 }
2399 bool operator==(const VkSurfaceCapabilitiesKHR & a, const VkSurfaceCapabilitiesKHR b) {
2400     return a.minImageCount == b.minImageCount
2401         && a.maxImageCount == b.maxImageCount
2402         && a.currentExtent == b.currentExtent
2403         && a.minImageExtent == b.minImageExtent
2404         && a.maxImageExtent == b.maxImageExtent
2405         && a.maxImageArrayLayers == b.maxImageArrayLayers
2406         && a.supportedTransforms == b.supportedTransforms
2407         && a.currentTransform == b.currentTransform
2408         && a.supportedCompositeAlpha == b.supportedCompositeAlpha
2409         && a.supportedUsageFlags == b.supportedUsageFlags;
2410 }
2411 bool operator==(const VkSurfaceFormatKHR & a, const VkSurfaceFormatKHR b) {
2412     return a.format == b.format
2413         && a.colorSpace == b.colorSpace;
2414 }
2415 bool operator==(const VkSurfaceCapabilities2KHR & a, const VkSurfaceCapabilities2KHR b) {
2416     return a.surfaceCapabilities == b.surfaceCapabilities;
2417 }
2418 bool operator==(const VkSurfaceFormat2KHR & a, const VkSurfaceFormat2KHR b) {
2419     return a.surfaceFormat == b.surfaceFormat;
2420 }
2421 bool operator==(const VkSurfaceCapabilities2EXT & a, const VkSurfaceCapabilities2EXT b) {
2422     return a.minImageCount == b.minImageCount
2423         && a.maxImageCount == b.maxImageCount
2424         && a.currentExtent == b.currentExtent
2425         && a.minImageExtent == b.minImageExtent
2426         && a.maxImageExtent == b.maxImageExtent
2427         && a.maxImageArrayLayers == b.maxImageArrayLayers
2428         && a.supportedTransforms == b.supportedTransforms
2429         && a.currentTransform == b.currentTransform
2430         && a.supportedCompositeAlpha == b.supportedCompositeAlpha
2431         && a.supportedUsageFlags == b.supportedUsageFlags
2432         && a.supportedSurfaceCounters == b.supportedSurfaceCounters;
2433 }
2434 std::ostream &operator<<(std::ostream &o, VkExtent3D &obj) {
2435     return o << "(" << obj.width << ',' << obj.height << ',' << obj.depth << ")";
2436 }
2437