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