external/vulkancts/framework/vulkan/generated/vulkansc/vulkan_json_data.hpp

   1 #ifndef _VULKAN_JSON_DATA_HPP
   2 #define _VULKAN_JSON_DATA_HPP
   3
   4 /*
   5  * Copyright (c) 2021 The Khronos Group 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  *//*!
  20  * \file
  21  * \brief Defines JSON generators for Vulkan structures
  22  */
  23
  24
  25 /********************************************************************************************/
  26 /** This code is generated. To make changes, please modify the scripts or the relevant xml **/
  27 /********************************************************************************************/
  28
  29 #include <iostream>
  30 #include <map>
  31 #include <bitset>
  32 #include <functional>
  33 #include <sstream>
  34 #include <cassert>
  35 #include <cmath>
  36 #ifndef VULKAN_JSON_CTS
  37     #include <vulkan/vulkan.h>
  38 #endif
  39
  40 #ifdef _WIN32
  41         #ifndef WIN32_LEAN_AND_MEAN
  42         #define WIN32_LEAN_AND_MEAN
  43         #endif
  44         #define VC_EXTRALEAN
  45         #define NOMINMAX
  46         #include <windows.h>
  47 #endif
  48
  49 namespace vk_json {
  50
  51 static thread_local int s_num_spaces    = 0;
  52 #if defined(USE_THREAD_LOCAL_WAR)
  53 // Workaround (off by default) for certain platforms that have a thread_local libc bug
  54 std::stringstream & TLSGetStrStream();
  55 #define _string_stream  TLSGetStrStream()
  56 #else
  57 static thread_local std::stringstream _string_stream;
  58 #endif
  59
  60 static void dumpPNextChain(const void* pNext);
  61
  62 // By default, redirect to std::cout. Can stream it to a stringstream if needed.
  63 //#define   _OUT std::cout
  64 #define _OUT _string_stream
  65
  66 // Helper utility to do indentation in the generated json file.
  67 #define PRINT_SPACE for (int k = 0; k < s_num_spaces; k++) _OUT << " ";
  68
  69 #define INDENT(sz) s_num_spaces += (sz);
  70
  71 #define PRINT_VAL(c) PRINT_SPACE \
  72     if (s != "") {\
  73         _OUT << "\"" << s << "\"" << " : " << o << (c ? "," : "") << std::endl; \
  74     } else {\
  75         _OUT << o << (c ? "," : "") << std::endl; \
  76     }
  77
  78 #define PRINT_STR(c) PRINT_SPACE \
  79     if (s != "") {\
  80         _OUT << "\"" << s << "\"" << " : " << "\"" << o << "\"" << (c ? "," : "") << std::endl; \
  81     } else {\
  82         _OUT << "\"" << o << "\"" << (c ? "," : "") << std::endl; \
  83     }
  84
  85 // To make sure the generated data is consistent across platforms,
  86 // we typecast to 32-bit and dump the data.
  87 // The value is not expected to exceed the range.
  88 static void print_size_t(const size_t* o, const std::string& s, bool commaNeeded=true)
  89 {
  90     PRINT_SPACE
  91     _OUT << "\"" << s << "\"" << " : " << static_cast<deUint32>(*o) << (commaNeeded ? "," : "") << std::endl;\
  92 }
  93 static void print_size_t(size_t o, const std::string& s, bool commaNeeded=true)
  94 {
  95     PRINT_SPACE
  96     _OUT << "\"" << s << "\"" << " : " << static_cast<deUint32>(o) << (commaNeeded ? "," : "") << std::endl;\
  97 }
  98
  99 static void print_int32_t(deInt32 o, const std::string& s, bool commaNeeded=true)
 100 {
 101     PRINT_VAL(commaNeeded)
 102 }
 103
 104 static void print_int32_t(const deInt32 * o, const std::string& s, bool commaNeeded=true)
 105 {
 106     PRINT_VAL(commaNeeded)
 107 }
 108
 109 static void print_uint32_t(deUint32 o, const std::string& s, bool commaNeeded=true)
 110 {
 111     PRINT_VAL(commaNeeded)
 112 }
 113
 114 static void print_uint32_t(const deUint32 * o, const std::string& s, bool commaNeeded=true)
 115 {
 116     PRINT_VAL(commaNeeded)
 117 }
 118
 119 static void print_uint8_t(deUint8 o, const std::string& s, bool commaNeeded=true)
 120 {
 121     PRINT_VAL(commaNeeded)
 122 }
 123
 124 static void print_uint8_t(const deUint8 * o, const std::string& s, bool commaNeeded=true)
 125 {
 126     PRINT_VAL(commaNeeded)
 127 }
 128
 129 static void print_uint64_t(deUint64 o, const std::string& s, bool commaNeeded=true)
 130 {
 131     PRINT_VAL(commaNeeded)
 132 }
 133
 134 static void print_uint64_t(const deUint64 * o, const std::string& s, bool commaNeeded=true)
 135 {
 136     PRINT_VAL(commaNeeded)
 137 }
 138
 139 static void print_float(float o, const std::string& s, bool commaNeeded=true)
 140 {
 141         if (std::isnan(o))
 142         {
 143                 PRINT_SPACE
 144                 if (s != "")
 145                         _OUT << "\"" << s << "\"" << " : \"NaN\"" << (commaNeeded ? "," : "") << std::endl;
 146                 else
 147                         _OUT << "\"NaN\"" << (commaNeeded ? "," : "") << std::endl;
 148         }
 149         else
 150         {
 151                 PRINT_VAL(commaNeeded)
 152         }
 153 }
 154
 155 static void print_float(const float * o, const std::string& s, bool commaNeeded=true)
 156 {
 157         if (std::isnan(*o))
 158         {
 159                 PRINT_SPACE
 160                 if (s != "")
 161                         _OUT << "\"" << s << "\"" << " : \"NaN\"" << (commaNeeded ? "," : "") << std::endl;
 162                 else
 163                         _OUT << "\"NaN\"" << (commaNeeded ? "," : "") << std::endl;
 164         }
 165         else
 166         {
 167                 PRINT_VAL(commaNeeded)
 168         }
 169 }
 170
 171 static void print_int(int o, const std::string& s, bool commaNeeded=true)
 172 {
 173     PRINT_VAL(commaNeeded)
 174 }
 175
 176 static void print_int(const int * o, const std::string& s, bool commaNeeded=true)
 177 {
 178     PRINT_VAL(commaNeeded)
 179 }
 180
 181 static void print_double(double o, const std::string& s, bool commaNeeded=true)
 182 {
 183     PRINT_VAL(commaNeeded)
 184 }
 185
 186 static void print_double(const double * o, const std::string& s, bool commaNeeded=true)
 187 {
 188     PRINT_VAL(commaNeeded)
 189 }
 190
 191 static void print_int64_t(deInt64 o, const std::string& s, bool commaNeeded=true)
 192 {
 193     PRINT_VAL(commaNeeded)
 194 }
 195
 196 static void print_int64_t(const deInt64 * o, const std::string& s, bool commaNeeded=true)
 197 {
 198     PRINT_VAL(commaNeeded)
 199 }
 200
 201 static void print_uint16_t(deUint16 o, const std::string& s, bool commaNeeded=true)
 202 {
 203     PRINT_VAL(commaNeeded)
 204 }
 205
 206 static void print_uint16_t(const deUint16 * o, const std::string& s, bool commaNeeded=true)
 207 {
 208     PRINT_VAL(commaNeeded)
 209 }
 210
 211 static void print_char(const char * const* o, const std::string& s, bool commaNeeded=true)
 212 {
 213     PRINT_STR(commaNeeded)
 214 }
 215
 216 static void print_char(char o, const std::string& s, bool commaNeeded=true)
 217 {
 218     PRINT_VAL(commaNeeded)
 219 }
 220
 221 static void print_char(const char * o, const std::string& s, bool commaNeeded=true)
 222 {
 223     PRINT_STR(commaNeeded)
 224 }
 225
 226
 227 // Base 64 formater class from executor/xeTestLogWriter.cpp
 228
 229 class Base64Formatter
 230 {
 231 public:
 232         const deUint8*  data;
 233         int                             numBytes;
 234
 235         Base64Formatter(const deUint8* data_, int numBytes_) : data(data_), numBytes(numBytes_) {}
 236 };
 237
 238 std::ostream& operator<< (std::ostream& str, const Base64Formatter& fmt)
 239 {
 240         static const char s_base64Table[64] =
 241         {
 242                 'A','B','C','D','E','F','G','H','I','J','K','L','M',
 243                 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
 244                 'a','b','c','d','e','f','g','h','i','j','k','l','m',
 245                 'n','o','p','q','r','s','t','u','v','w','x','y','z',
 246                 '0','1','2','3','4','5','6','7','8','9','+','/'
 247         };
 248
 249         const deUint8*  data = fmt.data;
 250         int                             numBytes = fmt.numBytes;
 251         int                             srcNdx = 0;
 252
 253         DE_ASSERT(data && (numBytes > 0));
 254
 255         /* Loop all input chars. */
 256         while (srcNdx < numBytes)
 257         {
 258                 int             numRead = de::min(3, numBytes - srcNdx);
 259                 deUint8 s0 = data[srcNdx];
 260                 deUint8 s1 = (numRead >= 2) ? data[srcNdx + 1] : 0;
 261                 deUint8 s2 = (numRead >= 3) ? data[srcNdx + 2] : 0;
 262                 char    d[4];
 263
 264                 srcNdx += numRead;
 265
 266                 d[0] = s_base64Table[s0 >> 2];
 267                 d[1] = s_base64Table[((s0 & 0x3) << 4) | (s1 >> 4)];
 268                 d[2] = s_base64Table[((s1 & 0xF) << 2) | (s2 >> 6)];
 269                 d[3] = s_base64Table[s2 & 0x3F];
 270
 271                 if (numRead < 3) d[3] = '=';
 272                 if (numRead < 2) d[2] = '=';
 273
 274                 /* Write data. */
 275                 str.write(&d[0], sizeof(d));
 276         }
 277
 278         return str;
 279 }
 280
 281 inline Base64Formatter toBase64(const deUint8* bytes, int numBytes) {return Base64Formatter(bytes, numBytes); }
 282
 283 static void print_void_data(const void * o, int oSize, const std::string& s, bool commaNeeded=true)
 284 {
 285         if (o != NULL && oSize != 0)
 286         {
 287                 PRINT_SPACE _OUT << "\"" << s << "\"" << " : " << "\"" << toBase64((deUint8*)o, oSize) << "\"" << (commaNeeded ? "," : "") << std::endl;
 288         }
 289         else
 290         {
 291                 PRINT_SPACE _OUT << "\"" << s << "\"" << " : " << "\"NULL\"" << (commaNeeded ? "," : "") << std::endl;
 292         }
 293 }
 294
 295 static void print_VkBool32(VkBool32 obj, const std::string& str, bool commaNeeded=true) {
 296      PRINT_SPACE
 297      _OUT << "\"" << str << "\"" << " : " << "\"" << ((obj == 0) ? ("VK_FALSE") : ("VK_TRUE")) << "\"" << (commaNeeded ? "," : "") << std::endl;
 298 }
 299 static void print_VkBool32(const VkBool32 * obj, const std::string& str, bool commaNeeded=true) {
 300      PRINT_SPACE
 301      _OUT << "\"" << str << "\"" << " : " << "\"" << ((obj == 0) ? ("VK_FALSE") : ("VK_TRUE")) << "\"" << (commaNeeded ? "," : "") << std::endl;
 302 }
 303
 304 static void print_VkDeviceAddress(VkDeviceAddress obj, const std::string& str, bool commaNeeded=true) {
 305      PRINT_SPACE
 306      _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
 307 }
 308 static void print_VkDeviceAddress(const VkDeviceAddress * obj, const std::string& str, bool commaNeeded=true) {
 309      PRINT_SPACE
 310      _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
 311 }
 312
 313 static void print_VkDeviceSize(VkDeviceSize obj, const std::string& str, bool commaNeeded=true) {
 314      PRINT_SPACE
 315      _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
 316 }
 317 static void print_VkDeviceSize(const VkDeviceSize * obj, const std::string& str, bool commaNeeded=true) {
 318      PRINT_SPACE
 319      _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
 320 }
 321
 322 static void print_VkFlags(VkFlags obj, const std::string& str, bool commaNeeded=true) {
 323      PRINT_SPACE
 324      _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
 325 }
 326 static void print_VkFlags(const VkFlags * obj, const std::string& str, bool commaNeeded=true) {
 327      PRINT_SPACE
 328      _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
 329 }
 330
 331 static void print_VkSampleMask(VkSampleMask obj, const std::string& str, bool commaNeeded=true) {
 332      PRINT_SPACE
 333      _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
 334 }
 335 static void print_VkSampleMask(const VkSampleMask * obj, const std::string& str, bool commaNeeded=true) {
 336      PRINT_SPACE
 337      _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
 338 }
 339
 340 static void print_VkBuffer(VkBuffer obj, const std::string& str, bool commaNeeded=true) {
 341      PRINT_SPACE
 342      if (commaNeeded)
 343          _OUT << "\"" << str << "\"" << "," << std::endl;
 344      else
 345          _OUT << "\"" << str << "\"" << std::endl;
 346 }
 347 static void print_VkBuffer(const VkBuffer * obj, const std::string& str, bool commaNeeded=true) {
 348      PRINT_SPACE
 349      if (commaNeeded)
 350          _OUT << "\"" << str << "\"" << "," << std::endl;
 351      else
 352          _OUT << "\"" << str << "\"" << std::endl;
 353 }
 354
 355 static void print_VkImage(VkImage obj, const std::string& str, bool commaNeeded=true) {
 356      PRINT_SPACE
 357      if (commaNeeded)
 358          _OUT << "\"" << str << "\"" << "," << std::endl;
 359      else
 360          _OUT << "\"" << str << "\"" << std::endl;
 361 }
 362 static void print_VkImage(const VkImage * obj, const std::string& str, bool commaNeeded=true) {
 363      PRINT_SPACE
 364      if (commaNeeded)
 365          _OUT << "\"" << str << "\"" << "," << std::endl;
 366      else
 367          _OUT << "\"" << str << "\"" << std::endl;
 368 }
 369
 370 static void print_VkInstance(VkInstance obj, const std::string& str, bool commaNeeded=true) {
 371      PRINT_SPACE
 372      if (commaNeeded)
 373          _OUT << "\"" << str << "\"" << "," << std::endl;
 374      else
 375          _OUT << "\"" << str << "\"" << std::endl;
 376 }
 377 static void print_VkInstance(const VkInstance * obj, const std::string& str, bool commaNeeded=true) {
 378      PRINT_SPACE
 379      if (commaNeeded)
 380          _OUT << "\"" << str << "\"" << "," << std::endl;
 381      else
 382          _OUT << "\"" << str << "\"" << std::endl;
 383 }
 384
 385 static void print_VkPhysicalDevice(VkPhysicalDevice obj, const std::string& str, bool commaNeeded=true) {
 386      PRINT_SPACE
 387      if (commaNeeded)
 388          _OUT << "\"" << str << "\"" << "," << std::endl;
 389      else
 390          _OUT << "\"" << str << "\"" << std::endl;
 391 }
 392 static void print_VkPhysicalDevice(const VkPhysicalDevice * obj, const std::string& str, bool commaNeeded=true) {
 393      PRINT_SPACE
 394      if (commaNeeded)
 395          _OUT << "\"" << str << "\"" << "," << std::endl;
 396      else
 397          _OUT << "\"" << str << "\"" << std::endl;
 398 }
 399
 400 static void print_VkDevice(VkDevice obj, const std::string& str, bool commaNeeded=true) {
 401      PRINT_SPACE
 402      if (commaNeeded)
 403          _OUT << "\"" << str << "\"" << "," << std::endl;
 404      else
 405          _OUT << "\"" << str << "\"" << std::endl;
 406 }
 407 static void print_VkDevice(const VkDevice * obj, const std::string& str, bool commaNeeded=true) {
 408      PRINT_SPACE
 409      if (commaNeeded)
 410          _OUT << "\"" << str << "\"" << "," << std::endl;
 411      else
 412          _OUT << "\"" << str << "\"" << std::endl;
 413 }
 414
 415 static void print_VkQueue(VkQueue obj, const std::string& str, bool commaNeeded=true) {
 416      PRINT_SPACE
 417      if (commaNeeded)
 418          _OUT << "\"" << str << "\"" << "," << std::endl;
 419      else
 420          _OUT << "\"" << str << "\"" << std::endl;
 421 }
 422 static void print_VkQueue(const VkQueue * obj, const std::string& str, bool commaNeeded=true) {
 423      PRINT_SPACE
 424      if (commaNeeded)
 425          _OUT << "\"" << str << "\"" << "," << std::endl;
 426      else
 427          _OUT << "\"" << str << "\"" << std::endl;
 428 }
 429
 430 static void print_VkSemaphore(VkSemaphore obj, const std::string& str, bool commaNeeded=true) {
 431      PRINT_SPACE
 432      if (commaNeeded)
 433          _OUT << "\"" << str << "\"" << "," << std::endl;
 434      else
 435          _OUT << "\"" << str << "\"" << std::endl;
 436 }
 437 static void print_VkSemaphore(const VkSemaphore * obj, const std::string& str, bool commaNeeded=true) {
 438      PRINT_SPACE
 439      if (commaNeeded)
 440          _OUT << "\"" << str << "\"" << "," << std::endl;
 441      else
 442          _OUT << "\"" << str << "\"" << std::endl;
 443 }
 444
 445 static void print_VkCommandBuffer(VkCommandBuffer obj, const std::string& str, bool commaNeeded=true) {
 446      PRINT_SPACE
 447      if (commaNeeded)
 448          _OUT << "\"" << str << "\"" << "," << std::endl;
 449      else
 450          _OUT << "\"" << str << "\"" << std::endl;
 451 }
 452 static void print_VkCommandBuffer(const VkCommandBuffer * obj, const std::string& str, bool commaNeeded=true) {
 453      PRINT_SPACE
 454      if (commaNeeded)
 455          _OUT << "\"" << str << "\"" << "," << std::endl;
 456      else
 457          _OUT << "\"" << str << "\"" << std::endl;
 458 }
 459
 460 static void print_VkFence(VkFence obj, const std::string& str, bool commaNeeded=true) {
 461      PRINT_SPACE
 462      if (commaNeeded)
 463          _OUT << "\"" << str << "\"" << "," << std::endl;
 464      else
 465          _OUT << "\"" << str << "\"" << std::endl;
 466 }
 467 static void print_VkFence(const VkFence * obj, const std::string& str, bool commaNeeded=true) {
 468      PRINT_SPACE
 469      if (commaNeeded)
 470          _OUT << "\"" << str << "\"" << "," << std::endl;
 471      else
 472          _OUT << "\"" << str << "\"" << std::endl;
 473 }
 474
 475 static void print_VkDeviceMemory(VkDeviceMemory obj, const std::string& str, bool commaNeeded=true) {
 476      PRINT_SPACE
 477      if (commaNeeded)
 478          _OUT << "\"" << str << "\"" << "," << std::endl;
 479      else
 480          _OUT << "\"" << str << "\"" << std::endl;
 481 }
 482 static void print_VkDeviceMemory(const VkDeviceMemory * obj, const std::string& str, bool commaNeeded=true) {
 483      PRINT_SPACE
 484      if (commaNeeded)
 485          _OUT << "\"" << str << "\"" << "," << std::endl;
 486      else
 487          _OUT << "\"" << str << "\"" << std::endl;
 488 }
 489
 490 static void print_VkEvent(VkEvent obj, const std::string& str, bool commaNeeded=true) {
 491      PRINT_SPACE
 492      if (commaNeeded)
 493          _OUT << "\"" << str << "\"" << "," << std::endl;
 494      else
 495          _OUT << "\"" << str << "\"" << std::endl;
 496 }
 497 static void print_VkEvent(const VkEvent * obj, const std::string& str, bool commaNeeded=true) {
 498      PRINT_SPACE
 499      if (commaNeeded)
 500          _OUT << "\"" << str << "\"" << "," << std::endl;
 501      else
 502          _OUT << "\"" << str << "\"" << std::endl;
 503 }
 504
 505 static void print_VkQueryPool(VkQueryPool obj, const std::string& str, bool commaNeeded=true) {
 506      PRINT_SPACE
 507      if (commaNeeded)
 508          _OUT << "\"" << str << "\"" << "," << std::endl;
 509      else
 510          _OUT << "\"" << str << "\"" << std::endl;
 511 }
 512 static void print_VkQueryPool(const VkQueryPool * obj, const std::string& str, bool commaNeeded=true) {
 513      PRINT_SPACE
 514      if (commaNeeded)
 515          _OUT << "\"" << str << "\"" << "," << std::endl;
 516      else
 517          _OUT << "\"" << str << "\"" << std::endl;
 518 }
 519
 520 static void print_VkBufferView(VkBufferView obj, const std::string& str, bool commaNeeded=true) {
 521      PRINT_SPACE
 522      if (commaNeeded)
 523          _OUT << "\"" << str << "\"" << "," << std::endl;
 524      else
 525          _OUT << "\"" << str << "\"" << std::endl;
 526 }
 527 static void print_VkBufferView(const VkBufferView * obj, const std::string& str, bool commaNeeded=true) {
 528      PRINT_SPACE
 529      if (commaNeeded)
 530          _OUT << "\"" << str << "\"" << "," << std::endl;
 531      else
 532          _OUT << "\"" << str << "\"" << std::endl;
 533 }
 534
 535 static void print_VkImageView(VkImageView obj, const std::string& str, bool commaNeeded=true) {
 536      PRINT_SPACE
 537      if (commaNeeded)
 538          _OUT << "\"" << str << "\"" << "," << std::endl;
 539      else
 540          _OUT << "\"" << str << "\"" << std::endl;
 541 }
 542 static void print_VkImageView(const VkImageView * obj, const std::string& str, bool commaNeeded=true) {
 543      PRINT_SPACE
 544      if (commaNeeded)
 545          _OUT << "\"" << str << "\"" << "," << std::endl;
 546      else
 547          _OUT << "\"" << str << "\"" << std::endl;
 548 }
 549
 550 static void print_VkShaderModule(VkShaderModule obj, const std::string& str, bool commaNeeded=true) {
 551      PRINT_SPACE
 552      if (commaNeeded)
 553          _OUT << "\"" << str << "\"" << "," << std::endl;
 554      else
 555          _OUT << "\"" << str << "\"" << std::endl;
 556 }
 557 static void print_VkShaderModule(const VkShaderModule * obj, const std::string& str, bool commaNeeded=true) {
 558      PRINT_SPACE
 559      if (commaNeeded)
 560          _OUT << "\"" << str << "\"" << "," << std::endl;
 561      else
 562          _OUT << "\"" << str << "\"" << std::endl;
 563 }
 564
 565 static void print_VkPipelineCache(VkPipelineCache obj, const std::string& str, bool commaNeeded=true) {
 566      PRINT_SPACE
 567      if (commaNeeded)
 568          _OUT << "\"" << str << "\"" << "," << std::endl;
 569      else
 570          _OUT << "\"" << str << "\"" << std::endl;
 571 }
 572 static void print_VkPipelineCache(const VkPipelineCache * obj, const std::string& str, bool commaNeeded=true) {
 573      PRINT_SPACE
 574      if (commaNeeded)
 575          _OUT << "\"" << str << "\"" << "," << std::endl;
 576      else
 577          _OUT << "\"" << str << "\"" << std::endl;
 578 }
 579
 580 static void print_VkPipelineLayout(VkPipelineLayout obj, const std::string& str, bool commaNeeded=true) {
 581      PRINT_SPACE
 582      if (commaNeeded)
 583          _OUT << "\"" << str << "\"" << "," << std::endl;
 584      else
 585          _OUT << "\"" << str << "\"" << std::endl;
 586 }
 587 static void print_VkPipelineLayout(const VkPipelineLayout * obj, const std::string& str, bool commaNeeded=true) {
 588      PRINT_SPACE
 589      if (commaNeeded)
 590          _OUT << "\"" << str << "\"" << "," << std::endl;
 591      else
 592          _OUT << "\"" << str << "\"" << std::endl;
 593 }
 594
 595 static void print_VkPipeline(VkPipeline obj, const std::string& str, bool commaNeeded=true) {
 596      PRINT_SPACE
 597      if (commaNeeded)
 598          _OUT << "\"" << str << "\"" << "," << std::endl;
 599      else
 600          _OUT << "\"" << str << "\"" << std::endl;
 601 }
 602 static void print_VkPipeline(const VkPipeline * obj, const std::string& str, bool commaNeeded=true) {
 603      PRINT_SPACE
 604      if (commaNeeded)
 605          _OUT << "\"" << str << "\"" << "," << std::endl;
 606      else
 607          _OUT << "\"" << str << "\"" << std::endl;
 608 }
 609
 610 static void print_VkRenderPass(VkRenderPass obj, const std::string& str, bool commaNeeded=true) {
 611      PRINT_SPACE
 612      if (commaNeeded)
 613          _OUT << "\"" << str << "\"" << "," << std::endl;
 614      else
 615          _OUT << "\"" << str << "\"" << std::endl;
 616 }
 617 static void print_VkRenderPass(const VkRenderPass * obj, const std::string& str, bool commaNeeded=true) {
 618      PRINT_SPACE
 619      if (commaNeeded)
 620          _OUT << "\"" << str << "\"" << "," << std::endl;
 621      else
 622          _OUT << "\"" << str << "\"" << std::endl;
 623 }
 624
 625 static void print_VkDescriptorSetLayout(VkDescriptorSetLayout obj, const std::string& str, bool commaNeeded=true) {
 626      PRINT_SPACE
 627      if (commaNeeded)
 628          _OUT << "\"" << str << "\"" << "," << std::endl;
 629      else
 630          _OUT << "\"" << str << "\"" << std::endl;
 631 }
 632 static void print_VkDescriptorSetLayout(const VkDescriptorSetLayout * obj, const std::string& str, bool commaNeeded=true) {
 633      PRINT_SPACE
 634      if (commaNeeded)
 635          _OUT << "\"" << str << "\"" << "," << std::endl;
 636      else
 637          _OUT << "\"" << str << "\"" << std::endl;
 638 }
 639
 640 static void print_VkSampler(VkSampler obj, const std::string& str, bool commaNeeded=true) {
 641      PRINT_SPACE
 642      if (commaNeeded)
 643          _OUT << "\"" << str << "\"" << "," << std::endl;
 644      else
 645          _OUT << "\"" << str << "\"" << std::endl;
 646 }
 647 static void print_VkSampler(const VkSampler * obj, const std::string& str, bool commaNeeded=true) {
 648      PRINT_SPACE
 649      if (commaNeeded)
 650          _OUT << "\"" << str << "\"" << "," << std::endl;
 651      else
 652          _OUT << "\"" << str << "\"" << std::endl;
 653 }
 654
 655 static void print_VkDescriptorSet(VkDescriptorSet obj, const std::string& str, bool commaNeeded=true) {
 656      PRINT_SPACE
 657      if (commaNeeded)
 658          _OUT << "\"" << str << "\"" << "," << std::endl;
 659      else
 660          _OUT << "\"" << str << "\"" << std::endl;
 661 }
 662 static void print_VkDescriptorSet(const VkDescriptorSet * obj, const std::string& str, bool commaNeeded=true) {
 663      PRINT_SPACE
 664      if (commaNeeded)
 665          _OUT << "\"" << str << "\"" << "," << std::endl;
 666      else
 667          _OUT << "\"" << str << "\"" << std::endl;
 668 }
 669
 670 static void print_VkDescriptorPool(VkDescriptorPool obj, const std::string& str, bool commaNeeded=true) {
 671      PRINT_SPACE
 672      if (commaNeeded)
 673          _OUT << "\"" << str << "\"" << "," << std::endl;
 674      else
 675          _OUT << "\"" << str << "\"" << std::endl;
 676 }
 677 static void print_VkDescriptorPool(const VkDescriptorPool * obj, const std::string& str, bool commaNeeded=true) {
 678      PRINT_SPACE
 679      if (commaNeeded)
 680          _OUT << "\"" << str << "\"" << "," << std::endl;
 681      else
 682          _OUT << "\"" << str << "\"" << std::endl;
 683 }
 684
 685 static void print_VkFramebuffer(VkFramebuffer obj, const std::string& str, bool commaNeeded=true) {
 686      PRINT_SPACE
 687      if (commaNeeded)
 688          _OUT << "\"" << str << "\"" << "," << std::endl;
 689      else
 690          _OUT << "\"" << str << "\"" << std::endl;
 691 }
 692 static void print_VkFramebuffer(const VkFramebuffer * obj, const std::string& str, bool commaNeeded=true) {
 693      PRINT_SPACE
 694      if (commaNeeded)
 695          _OUT << "\"" << str << "\"" << "," << std::endl;
 696      else
 697          _OUT << "\"" << str << "\"" << std::endl;
 698 }
 699
 700 static void print_VkCommandPool(VkCommandPool obj, const std::string& str, bool commaNeeded=true) {
 701      PRINT_SPACE
 702      if (commaNeeded)
 703          _OUT << "\"" << str << "\"" << "," << std::endl;
 704      else
 705          _OUT << "\"" << str << "\"" << std::endl;
 706 }
 707 static void print_VkCommandPool(const VkCommandPool * obj, const std::string& str, bool commaNeeded=true) {
 708      PRINT_SPACE
 709      if (commaNeeded)
 710          _OUT << "\"" << str << "\"" << "," << std::endl;
 711      else
 712          _OUT << "\"" << str << "\"" << std::endl;
 713 }
 714
 715 static std::map<deUint64, std::string> VkResult_map = {
 716     std::make_pair(0, "VK_SUCCESS"),
 717     std::make_pair(1, "VK_NOT_READY"),
 718     std::make_pair(2, "VK_TIMEOUT"),
 719     std::make_pair(3, "VK_EVENT_SET"),
 720     std::make_pair(4, "VK_EVENT_RESET"),
 721     std::make_pair(5, "VK_INCOMPLETE"),
 722     std::make_pair(-1, "VK_ERROR_OUT_OF_HOST_MEMORY"),
 723     std::make_pair(-2, "VK_ERROR_OUT_OF_DEVICE_MEMORY"),
 724     std::make_pair(-3, "VK_ERROR_INITIALIZATION_FAILED"),
 725     std::make_pair(-4, "VK_ERROR_DEVICE_LOST"),
 726     std::make_pair(-5, "VK_ERROR_MEMORY_MAP_FAILED"),
 727     std::make_pair(-6, "VK_ERROR_LAYER_NOT_PRESENT"),
 728     std::make_pair(-7, "VK_ERROR_EXTENSION_NOT_PRESENT"),
 729     std::make_pair(-8, "VK_ERROR_FEATURE_NOT_PRESENT"),
 730     std::make_pair(-9, "VK_ERROR_INCOMPATIBLE_DRIVER"),
 731     std::make_pair(-10, "VK_ERROR_TOO_MANY_OBJECTS"),
 732     std::make_pair(-11, "VK_ERROR_FORMAT_NOT_SUPPORTED"),
 733     std::make_pair(-12, "VK_ERROR_FRAGMENTED_POOL"),
 734     std::make_pair(-13, "VK_ERROR_UNKNOWN"),
 735     std::make_pair(1000069000, "VK_ERROR_OUT_OF_POOL_MEMORY"),
 736     std::make_pair(1000072003, "VK_ERROR_INVALID_EXTERNAL_HANDLE"),
 737     std::make_pair(1000161000, "VK_ERROR_FRAGMENTATION"),
 738     std::make_pair(1000257000, "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"),
 739     std::make_pair(1000011001, "VK_ERROR_VALIDATION_FAILED"),
 740     std::make_pair(1000298000, "VK_ERROR_INVALID_PIPELINE_CACHE_DATA"),
 741     std::make_pair(1000298001, "VK_ERROR_NO_PIPELINE_MATCH"),
 742     std::make_pair(1000000000, "VK_ERROR_SURFACE_LOST_KHR"),
 743     std::make_pair(1000000001, "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"),
 744     std::make_pair(1000001003, "VK_SUBOPTIMAL_KHR"),
 745     std::make_pair(1000001004, "VK_ERROR_OUT_OF_DATE_KHR"),
 746     std::make_pair(1000003001, "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"),
 747     std::make_pair(1000012000, "VK_ERROR_INVALID_SHADER_NV"),
 748     std::make_pair(1000158000, "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"),
 749     std::make_pair(1000174001, "VK_ERROR_NOT_PERMITTED_EXT"),
 750     std::make_pair(1000255000, "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"),
 751     std::make_pair(1000268000, "VK_THREAD_IDLE_KHR"),
 752     std::make_pair(1000268001, "VK_THREAD_DONE_KHR"),
 753     std::make_pair(1000268002, "VK_OPERATION_DEFERRED_KHR"),
 754     std::make_pair(1000268003, "VK_OPERATION_NOT_DEFERRED_KHR"),
 755     std::make_pair(1000297000, "VK_PIPELINE_COMPILE_REQUIRED_EXT"),
 756 };
 757 static void print_VkResult(VkResult obj, const std::string& str, bool commaNeeded=true) {
 758      PRINT_SPACE
 759      if (str != "") _OUT << "\"" << str << "\"" << " : ";
 760      if (commaNeeded)
 761          _OUT << "\"" <<  VkResult_map[obj] << "\"," << std::endl;
 762      else
 763          _OUT << "\"" << VkResult_map[obj] << "\"" << std::endl;
 764 }
 765 static void print_VkResult(const VkResult * obj, const std::string& str, bool commaNeeded=true) {
 766      PRINT_SPACE
 767      if (str != "") _OUT << "\"" << str << "\"" << " : ";
 768      if (commaNeeded)
 769          _OUT << "\"" <<  VkResult_map[*obj] << "\"," << std::endl;
 770      else
 771          _OUT << "\"" << VkResult_map[*obj] << "\"" << std::endl;
 772 }
 773
 774 static std::map<deUint64, std::string> VkStructureType_map = {
 775     std::make_pair(0, "VK_STRUCTURE_TYPE_APPLICATION_INFO"),
 776     std::make_pair(1, "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO"),
 777     std::make_pair(2, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO"),
 778     std::make_pair(3, "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO"),
 779     std::make_pair(4, "VK_STRUCTURE_TYPE_SUBMIT_INFO"),
 780     std::make_pair(5, "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO"),
 781     std::make_pair(6, "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE"),
 782     std::make_pair(8, "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO"),
 783     std::make_pair(9, "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO"),
 784     std::make_pair(10, "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO"),
 785     std::make_pair(11, "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO"),
 786     std::make_pair(12, "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO"),
 787     std::make_pair(13, "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO"),
 788     std::make_pair(14, "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO"),
 789     std::make_pair(15, "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO"),
 790     std::make_pair(17, "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO"),
 791     std::make_pair(18, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO"),
 792     std::make_pair(19, "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO"),
 793     std::make_pair(20, "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO"),
 794     std::make_pair(21, "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO"),
 795     std::make_pair(22, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO"),
 796     std::make_pair(23, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO"),
 797     std::make_pair(24, "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO"),
 798     std::make_pair(25, "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO"),
 799     std::make_pair(26, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO"),
 800     std::make_pair(27, "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO"),
 801     std::make_pair(28, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO"),
 802     std::make_pair(29, "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO"),
 803     std::make_pair(30, "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO"),
 804     std::make_pair(31, "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO"),
 805     std::make_pair(32, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO"),
 806     std::make_pair(33, "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO"),
 807     std::make_pair(34, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO"),
 808     std::make_pair(35, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET"),
 809     std::make_pair(36, "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET"),
 810     std::make_pair(37, "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO"),
 811     std::make_pair(38, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO"),
 812     std::make_pair(39, "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO"),
 813     std::make_pair(40, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO"),
 814     std::make_pair(41, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO"),
 815     std::make_pair(42, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO"),
 816     std::make_pair(43, "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO"),
 817     std::make_pair(44, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER"),
 818     std::make_pair(45, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER"),
 819     std::make_pair(46, "VK_STRUCTURE_TYPE_MEMORY_BARRIER"),
 820     std::make_pair(47, "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO"),
 821     std::make_pair(48, "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO"),
 822     std::make_pair(1000094000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES"),
 823     std::make_pair(1000157000, "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO"),
 824     std::make_pair(1000157001, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO"),
 825     std::make_pair(1000083000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"),
 826     std::make_pair(1000127000, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS"),
 827     std::make_pair(1000127001, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO"),
 828     std::make_pair(1000060000, "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO"),
 829     std::make_pair(1000060003, "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"),
 830     std::make_pair(1000060004, "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO"),
 831     std::make_pair(1000060005, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO"),
 832     std::make_pair(1000060013, "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO"),
 833     std::make_pair(1000060014, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO"),
 834     std::make_pair(1000070000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES"),
 835     std::make_pair(1000070001, "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO"),
 836     std::make_pair(1000146000, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2"),
 837     std::make_pair(1000146001, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2"),
 838     std::make_pair(1000146003, "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2"),
 839     std::make_pair(1000059000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2"),
 840     std::make_pair(1000059001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2"),
 841     std::make_pair(1000059002, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2"),
 842     std::make_pair(1000059003, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2"),
 843     std::make_pair(1000059004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2"),
 844     std::make_pair(1000059005, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2"),
 845     std::make_pair(1000059006, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2"),
 846     std::make_pair(1000117000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES"),
 847     std::make_pair(1000117001, "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO"),
 848     std::make_pair(1000117002, "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO"),
 849     std::make_pair(1000117003, "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO"),
 850     std::make_pair(1000053000, "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO"),
 851     std::make_pair(1000053001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES"),
 852     std::make_pair(1000053002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES"),
 853     std::make_pair(1000120000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"),
 854     std::make_pair(1000145000, "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO"),
 855     std::make_pair(1000145001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES"),
 856     std::make_pair(1000145002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES"),
 857     std::make_pair(1000145003, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2"),
 858     std::make_pair(1000156000, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO"),
 859     std::make_pair(1000156001, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO"),
 860     std::make_pair(1000156002, "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO"),
 861     std::make_pair(1000156003, "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO"),
 862     std::make_pair(1000156004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES"),
 863     std::make_pair(1000156005, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES"),
 864     std::make_pair(1000071000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO"),
 865     std::make_pair(1000071001, "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES"),
 866     std::make_pair(1000071002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO"),
 867     std::make_pair(1000071003, "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES"),
 868     std::make_pair(1000071004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES"),
 869     std::make_pair(1000072000, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO"),
 870     std::make_pair(1000072001, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO"),
 871     std::make_pair(1000072002, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO"),
 872     std::make_pair(1000112000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO"),
 873     std::make_pair(1000112001, "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES"),
 874     std::make_pair(1000113000, "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO"),
 875     std::make_pair(1000077000, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO"),
 876     std::make_pair(1000076000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"),
 877     std::make_pair(1000076001, "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES"),
 878     std::make_pair(1000168000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES"),
 879     std::make_pair(1000168001, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT"),
 880     std::make_pair(1000063000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES"),
 881     std::make_pair(49, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES"),
 882     std::make_pair(50, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES"),
 883     std::make_pair(51, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES"),
 884     std::make_pair(52, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES"),
 885     std::make_pair(1000147000, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO"),
 886     std::make_pair(1000109000, "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2"),
 887     std::make_pair(1000109001, "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2"),
 888     std::make_pair(1000109002, "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2"),
 889     std::make_pair(1000109003, "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2"),
 890     std::make_pair(1000109004, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2"),
 891     std::make_pair(1000109005, "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO"),
 892     std::make_pair(1000109006, "VK_STRUCTURE_TYPE_SUBPASS_END_INFO"),
 893     std::make_pair(1000177000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"),
 894     std::make_pair(1000196000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES"),
 895     std::make_pair(1000180000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"),
 896     std::make_pair(1000082000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"),
 897     std::make_pair(1000197000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES"),
 898     std::make_pair(1000161000, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO"),
 899     std::make_pair(1000161001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES"),
 900     std::make_pair(1000161002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES"),
 901     std::make_pair(1000161003, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO"),
 902     std::make_pair(1000161004, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT"),
 903     std::make_pair(1000199000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES"),
 904     std::make_pair(1000199001, "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE"),
 905     std::make_pair(1000221000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"),
 906     std::make_pair(1000246000, "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO"),
 907     std::make_pair(1000130000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES"),
 908     std::make_pair(1000130001, "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO"),
 909     std::make_pair(1000211000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"),
 910     std::make_pair(1000108000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES"),
 911     std::make_pair(1000108001, "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO"),
 912     std::make_pair(1000108002, "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"),
 913     std::make_pair(1000108003, "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO"),
 914     std::make_pair(1000253000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES"),
 915     std::make_pair(1000175000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES"),
 916     std::make_pair(1000241000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES"),
 917     std::make_pair(1000241001, "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT"),
 918     std::make_pair(1000241002, "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT"),
 919     std::make_pair(1000261000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"),
 920     std::make_pair(1000207000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"),
 921     std::make_pair(1000207001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES"),
 922     std::make_pair(1000207002, "VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO"),
 923     std::make_pair(1000207003, "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO"),
 924     std::make_pair(1000207004, "VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO"),
 925     std::make_pair(1000207005, "VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO"),
 926     std::make_pair(1000257000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES"),
 927     std::make_pair(1000244001, "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO"),
 928     std::make_pair(1000257002, "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO"),
 929     std::make_pair(1000257003, "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"),
 930     std::make_pair(1000257004, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO"),
 931     std::make_pair(1000298000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES"),
 932     std::make_pair(1000298001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES"),
 933     std::make_pair(1000298002, "VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO"),
 934     std::make_pair(1000298003, "VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO"),
 935     std::make_pair(1000298004, "VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION"),
 936     std::make_pair(1000298005, "VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE"),
 937     std::make_pair(1000298007, "VK_STRUCTURE_TYPE_FAULT_DATA"),
 938     std::make_pair(1000298008, "VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO"),
 939     std::make_pair(1000298010, "VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO"),
 940     std::make_pair(1000001000, "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR"),
 941     std::make_pair(1000001001, "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR"),
 942     std::make_pair(1000060007, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"),
 943     std::make_pair(1000060008, "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR"),
 944     std::make_pair(1000060009, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"),
 945     std::make_pair(1000060010, "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR"),
 946     std::make_pair(1000060011, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR"),
 947     std::make_pair(1000060012, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"),
 948     std::make_pair(1000002000, "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR"),
 949     std::make_pair(1000002001, "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR"),
 950     std::make_pair(1000003000, "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR"),
 951     std::make_pair(1000004000, "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR"),
 952     std::make_pair(1000005000, "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR"),
 953     std::make_pair(1000006000, "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR"),
 954     std::make_pair(1000008000, "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR"),
 955     std::make_pair(1000009000, "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR"),
 956     std::make_pair(1000010000, "VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID"),
 957     std::make_pair(1000010001, "VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID"),
 958     std::make_pair(1000010002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID"),
 959     std::make_pair(1000011000, "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT"),
 960     std::make_pair(1000018000, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD"),
 961     std::make_pair(1000022000, "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT"),
 962     std::make_pair(1000022001, "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT"),
 963     std::make_pair(1000022002, "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT"),
 964     std::make_pair(1000023000, "VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR"),
 965     std::make_pair(1000023001, "VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR"),
 966     std::make_pair(1000023002, "VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR"),
 967     std::make_pair(1000023003, "VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR"),
 968     std::make_pair(1000023004, "VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR"),
 969     std::make_pair(1000023005, "VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR"),
 970     std::make_pair(1000023006, "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR"),
 971     std::make_pair(1000023007, "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR"),
 972     std::make_pair(1000023008, "VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR"),
 973     std::make_pair(1000023009, "VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR"),
 974     std::make_pair(1000023010, "VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR"),
 975     std::make_pair(1000023011, "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR"),
 976     std::make_pair(1000023012, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR"),
 977     std::make_pair(1000023013, "VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR"),
 978     std::make_pair(1000023014, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR"),
 979     std::make_pair(1000023015, "VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR"),
 980     std::make_pair(1000024000, "VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR"),
 981     std::make_pair(1000026000, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV"),
 982     std::make_pair(1000026001, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV"),
 983     std::make_pair(1000026002, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV"),
 984     std::make_pair(1000028000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT"),
 985     std::make_pair(1000028001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT"),
 986     std::make_pair(1000028002, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT"),
 987     std::make_pair(1000029000, "VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX"),
 988     std::make_pair(1000029001, "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX"),
 989     std::make_pair(1000029002, "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX"),
 990     std::make_pair(1000030000, "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX"),
 991     std::make_pair(1000030001, "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"),
 992     std::make_pair(1000038000, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT"),
 993     std::make_pair(1000038001, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT"),
 994     std::make_pair(1000038002, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"),
 995     std::make_pair(1000038003, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"),
 996     std::make_pair(1000038004, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT"),
 997     std::make_pair(1000038005, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT"),
 998     std::make_pair(1000038006, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT"),
 999     std::make_pair(1000038007, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT"),
1000     std::make_pair(1000038008, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT"),
1001     std::make_pair(1000038009, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT"),
1002     std::make_pair(1000038010, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT"),
1003     std::make_pair(1000039000, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT"),
1004     std::make_pair(1000039001, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT"),
1005     std::make_pair(1000039002, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"),
1006     std::make_pair(1000039003, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"),
1007     std::make_pair(1000039004, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT"),
1008     std::make_pair(1000039005, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT"),
1009     std::make_pair(1000039006, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_EXT"),
1010     std::make_pair(1000039007, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT"),
1011     std::make_pair(1000039008, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT"),
1012     std::make_pair(1000039009, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT"),
1013     std::make_pair(1000039010, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT"),
1014     std::make_pair(1000039011, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT"),
1015     std::make_pair(1000040000, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR"),
1016     std::make_pair(1000040001, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT"),
1017     std::make_pair(1000040002, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR"),
1018     std::make_pair(1000040003, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT"),
1019     std::make_pair(1000040004, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT"),
1020     std::make_pair(1000040005, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"),
1021     std::make_pair(1000040006, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR"),
1022     std::make_pair(1000040007, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR"),
1023     std::make_pair(1000041000, "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD"),
1024     std::make_pair(1000044000, "VK_STRUCTURE_TYPE_RENDERING_INFO_KHR"),
1025     std::make_pair(1000044001, "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR"),
1026     std::make_pair(1000044002, "VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR"),
1027     std::make_pair(1000044003, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR"),
1028     std::make_pair(1000044004, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR"),
1029     std::make_pair(1000044006, "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"),
1030     std::make_pair(1000044007, "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT"),
1031     std::make_pair(1000044008, "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD"),
1032     std::make_pair(1000044009, "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX"),
1033     std::make_pair(1000049000, "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP"),
1034     std::make_pair(1000050000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV"),
1035     std::make_pair(1000056000, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV"),
1036     std::make_pair(1000056001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV"),
1037     std::make_pair(1000057000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"),
1038     std::make_pair(1000057001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"),
1039     std::make_pair(1000058000, "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV"),
1040     std::make_pair(1000060007, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"),
1041     std::make_pair(1000060008, "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR"),
1042     std::make_pair(1000060009, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"),
1043     std::make_pair(1000060010, "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR"),
1044     std::make_pair(1000060011, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR"),
1045     std::make_pair(1000060012, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"),
1046     std::make_pair(1000061000, "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT"),
1047     std::make_pair(1000062000, "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN"),
1048     std::make_pair(1000066000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT"),
1049     std::make_pair(1000067000, "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT"),
1050     std::make_pair(1000067001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT"),
1051     std::make_pair(1000073000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR"),
1052     std::make_pair(1000073001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR"),
1053     std::make_pair(1000073002, "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR"),
1054     std::make_pair(1000073003, "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR"),
1055     std::make_pair(1000074000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR"),
1056     std::make_pair(1000074001, "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR"),
1057     std::make_pair(1000074002, "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR"),
1058     std::make_pair(1000075000, "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR"),
1059     std::make_pair(1000078000, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"),
1060     std::make_pair(1000078001, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"),
1061     std::make_pair(1000078002, "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR"),
1062     std::make_pair(1000078003, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR"),
1063     std::make_pair(1000079000, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"),
1064     std::make_pair(1000079001, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR"),
1065     std::make_pair(1000080000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"),
1066     std::make_pair(1000081000, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT"),
1067     std::make_pair(1000081001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT"),
1068     std::make_pair(1000081002, "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT"),
1069     std::make_pair(1000084000, "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR"),
1070     std::make_pair(1000087000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV"),
1071     std::make_pair(1000090000, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT"),
1072     std::make_pair(1000091000, "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT"),
1073     std::make_pair(1000091001, "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT"),
1074     std::make_pair(1000091002, "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT"),
1075     std::make_pair(1000091003, "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT"),
1076     std::make_pair(1000092000, "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE"),
1077     std::make_pair(1000097000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"),
1078     std::make_pair(1000098000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV"),
1079     std::make_pair(1000099000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"),
1080     std::make_pair(1000099001, "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT"),
1081     std::make_pair(1000101000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT"),
1082     std::make_pair(1000101001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT"),
1083     std::make_pair(1000102000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT"),
1084     std::make_pair(1000102001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT"),
1085     std::make_pair(1000105000, "VK_STRUCTURE_TYPE_HDR_METADATA_EXT"),
1086     std::make_pair(1000111000, "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR"),
1087     std::make_pair(1000114000, "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"),
1088     std::make_pair(1000114001, "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"),
1089     std::make_pair(1000114002, "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR"),
1090     std::make_pair(1000115000, "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR"),
1091     std::make_pair(1000115001, "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR"),
1092     std::make_pair(1000116000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR"),
1093     std::make_pair(1000116001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR"),
1094     std::make_pair(1000116002, "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR"),
1095     std::make_pair(1000116003, "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR"),
1096     std::make_pair(1000116004, "VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR"),
1097     std::make_pair(1000116005, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR"),
1098     std::make_pair(1000116006, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR"),
1099     std::make_pair(1000116007, "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR"),
1100     std::make_pair(1000119000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"),
1101     std::make_pair(1000119001, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR"),
1102     std::make_pair(1000119002, "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR"),
1103     std::make_pair(1000121000, "VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR"),
1104     std::make_pair(1000121001, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR"),
1105     std::make_pair(1000121002, "VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR"),
1106     std::make_pair(1000121003, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR"),
1107     std::make_pair(1000121004, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR"),
1108     std::make_pair(1000122000, "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK"),
1109     std::make_pair(1000123000, "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK"),
1110     std::make_pair(1000128000, "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT"),
1111     std::make_pair(1000128001, "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT"),
1112     std::make_pair(1000128002, "VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT"),
1113     std::make_pair(1000128003, "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT"),
1114     std::make_pair(1000128004, "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT"),
1115     std::make_pair(1000129000, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID"),
1116     std::make_pair(1000129001, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID"),
1117     std::make_pair(1000129002, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID"),
1118     std::make_pair(1000129003, "VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"),
1119     std::make_pair(1000129004, "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"),
1120     std::make_pair(1000129005, "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID"),
1121     std::make_pair(1000129006, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID"),
1122     std::make_pair(1000138000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT"),
1123     std::make_pair(1000138001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT"),
1124     std::make_pair(1000138002, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT"),
1125     std::make_pair(1000138003, "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT"),
1126     std::make_pair(1000143000, "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT"),
1127     std::make_pair(1000143001, "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT"),
1128     std::make_pair(1000143002, "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT"),
1129     std::make_pair(1000143003, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT"),
1130     std::make_pair(1000143004, "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT"),
1131     std::make_pair(1000148000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT"),
1132     std::make_pair(1000148001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT"),
1133     std::make_pair(1000148002, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT"),
1134     std::make_pair(1000149000, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV"),
1135     std::make_pair(1000150007, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR"),
1136     std::make_pair(1000150000, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR"),
1137     std::make_pair(1000150002, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR"),
1138     std::make_pair(1000150003, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR"),
1139     std::make_pair(1000150004, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR"),
1140     std::make_pair(1000150005, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR"),
1141     std::make_pair(1000150006, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR"),
1142     std::make_pair(1000150009, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR"),
1143     std::make_pair(1000150010, "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR"),
1144     std::make_pair(1000150011, "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR"),
1145     std::make_pair(1000150012, "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR"),
1146     std::make_pair(1000150013, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR"),
1147     std::make_pair(1000150014, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR"),
1148     std::make_pair(1000150017, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR"),
1149     std::make_pair(1000150020, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR"),
1150     std::make_pair(1000347000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR"),
1151     std::make_pair(1000347001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR"),
1152     std::make_pair(1000150015, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR"),
1153     std::make_pair(1000150016, "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR"),
1154     std::make_pair(1000150018, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR"),
1155     std::make_pair(1000348013, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR"),
1156     std::make_pair(1000152000, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV"),
1157     std::make_pair(1000154000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV"),
1158     std::make_pair(1000154001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV"),
1159     std::make_pair(1000158000, "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT"),
1160     std::make_pair(1000158002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT"),
1161     std::make_pair(1000158003, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT"),
1162     std::make_pair(1000158004, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT"),
1163     std::make_pair(1000158005, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT"),
1164     std::make_pair(1000158006, "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT"),
1165     std::make_pair(1000160000, "VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT"),
1166     std::make_pair(1000160001, "VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT"),
1167     std::make_pair(1000163000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR"),
1168     std::make_pair(1000163001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR"),
1169     std::make_pair(1000164000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV"),
1170     std::make_pair(1000164001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV"),
1171     std::make_pair(1000164002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV"),
1172     std::make_pair(1000164005, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV"),
1173     std::make_pair(1000165000, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV"),
1174     std::make_pair(1000165001, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV"),
1175     std::make_pair(1000165003, "VK_STRUCTURE_TYPE_GEOMETRY_NV"),
1176     std::make_pair(1000165004, "VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV"),
1177     std::make_pair(1000165005, "VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV"),
1178     std::make_pair(1000165006, "VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV"),
1179     std::make_pair(1000165007, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV"),
1180     std::make_pair(1000165008, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV"),
1181     std::make_pair(1000165009, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV"),
1182     std::make_pair(1000165011, "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV"),
1183     std::make_pair(1000165012, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV"),
1184     std::make_pair(1000166000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV"),
1185     std::make_pair(1000166001, "VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV"),
1186     std::make_pair(1000170000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT"),
1187     std::make_pair(1000170001, "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT"),
1188     std::make_pair(1000174000, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT"),
1189     std::make_pair(1000178000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT"),
1190     std::make_pair(1000178001, "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT"),
1191     std::make_pair(1000178002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT"),
1192     std::make_pair(1000181000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR"),
1193     std::make_pair(1000183000, "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"),
1194     std::make_pair(1000184000, "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT"),
1195     std::make_pair(1000185000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"),
1196     std::make_pair(1000187000, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT"),
1197     std::make_pair(1000187001, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT"),
1198     std::make_pair(1000187002, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"),
1199     std::make_pair(1000187003, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"),
1200     std::make_pair(1000187004, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT"),
1201     std::make_pair(1000187005, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT"),
1202     std::make_pair(1000187006, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT"),
1203     std::make_pair(1000189000, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD"),
1204     std::make_pair(1000190000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"),
1205     std::make_pair(1000190001, "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT"),
1206     std::make_pair(1000190002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT"),
1207     std::make_pair(1000191000, "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP"),
1208     std::make_pair(1000192000, "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT"),
1209     std::make_pair(1000201000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV"),
1210     std::make_pair(1000202000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV"),
1211     std::make_pair(1000202001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV"),
1212     std::make_pair(1000203000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV"),
1213     std::make_pair(1000204000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV"),
1214     std::make_pair(1000205000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV"),
1215     std::make_pair(1000205002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV"),
1216     std::make_pair(1000206000, "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV"),
1217     std::make_pair(1000206001, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV"),
1218     std::make_pair(1000209000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL"),
1219     std::make_pair(1000210000, "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL"),
1220     std::make_pair(1000210001, "VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL"),
1221     std::make_pair(1000210002, "VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL"),
1222     std::make_pair(1000210003, "VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL"),
1223     std::make_pair(1000210004, "VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL"),
1224     std::make_pair(1000210005, "VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL"),
1225     std::make_pair(1000212000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT"),
1226     std::make_pair(1000213000, "VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD"),
1227     std::make_pair(1000213001, "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD"),
1228     std::make_pair(1000214000, "VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA"),
1229     std::make_pair(1000215000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR"),
1230     std::make_pair(1000217000, "VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT"),
1231     std::make_pair(1000218000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT"),
1232     std::make_pair(1000218001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT"),
1233     std::make_pair(1000218002, "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT"),
1234     std::make_pair(1000225000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT"),
1235     std::make_pair(1000225001, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT"),
1236     std::make_pair(1000225002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT"),
1237     std::make_pair(1000226000, "VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"),
1238     std::make_pair(1000226001, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR"),
1239     std::make_pair(1000226002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR"),
1240     std::make_pair(1000226003, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR"),
1241     std::make_pair(1000226004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR"),
1242     std::make_pair(1000227000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD"),
1243     std::make_pair(1000229000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD"),
1244     std::make_pair(1000234000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT"),
1245     std::make_pair(1000237000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT"),
1246     std::make_pair(1000238000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT"),
1247     std::make_pair(1000238001, "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT"),
1248     std::make_pair(1000239000, "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR"),
1249     std::make_pair(1000240000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV"),
1250     std::make_pair(1000244000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT"),
1251     std::make_pair(1000244002, "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT"),
1252     std::make_pair(1000245000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT"),
1253     std::make_pair(1000247000, "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT"),
1254     std::make_pair(1000248000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR"),
1255     std::make_pair(1000249000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV"),
1256     std::make_pair(1000249001, "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV"),
1257     std::make_pair(1000249002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV"),
1258     std::make_pair(1000250000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV"),
1259     std::make_pair(1000250001, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV"),
1260     std::make_pair(1000250002, "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV"),
1261     std::make_pair(1000251000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT"),
1262     std::make_pair(1000252000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT"),
1263     std::make_pair(1000254000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT"),
1264     std::make_pair(1000254001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT"),
1265     std::make_pair(1000254002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT"),
1266     std::make_pair(1000255000, "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT"),
1267     std::make_pair(1000255002, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT"),
1268     std::make_pair(1000255001, "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT"),
1269     std::make_pair(1000256000, "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT"),
1270     std::make_pair(1000259000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT"),
1271     std::make_pair(1000259001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT"),
1272     std::make_pair(1000259002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT"),
1273     std::make_pair(1000260000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT"),
1274     std::make_pair(1000265000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT"),
1275     std::make_pair(1000267000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT"),
1276     std::make_pair(1000269000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR"),
1277     std::make_pair(1000269001, "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR"),
1278     std::make_pair(1000269002, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR"),
1279     std::make_pair(1000269003, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR"),
1280     std::make_pair(1000269004, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR"),
1281     std::make_pair(1000269005, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR"),
1282     std::make_pair(1000273000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT"),
1283     std::make_pair(1000276000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT"),
1284     std::make_pair(1000277000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV"),
1285     std::make_pair(1000277001, "VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV"),
1286     std::make_pair(1000277002, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV"),
1287     std::make_pair(1000277003, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV"),
1288     std::make_pair(1000277004, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV"),
1289     std::make_pair(1000277005, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV"),
1290     std::make_pair(1000277006, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV"),
1291     std::make_pair(1000277007, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV"),
1292     std::make_pair(1000278000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV"),
1293     std::make_pair(1000278001, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV"),
1294     std::make_pair(1000280000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR"),
1295     std::make_pair(1000280001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR"),
1296     std::make_pair(1000281000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT"),
1297     std::make_pair(1000281001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT"),
1298     std::make_pair(1000282000, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM"),
1299     std::make_pair(1000282001, "VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM"),
1300     std::make_pair(1000284000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT"),
1301     std::make_pair(1000284001, "VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT"),
1302     std::make_pair(1000284002, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT"),
1303     std::make_pair(1000286000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT"),
1304     std::make_pair(1000286001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT"),
1305     std::make_pair(1000287000, "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT"),
1306     std::make_pair(1000287001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT"),
1307     std::make_pair(1000287002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT"),
1308     std::make_pair(1000290000, "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR"),
1309     std::make_pair(1000294000, "VK_STRUCTURE_TYPE_PRESENT_ID_KHR"),
1310     std::make_pair(1000294001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR"),
1311     std::make_pair(1000295000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT"),
1312     std::make_pair(1000295001, "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT"),
1313     std::make_pair(1000295002, "VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT"),
1314     std::make_pair(1000297000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT"),
1315     std::make_pair(1000299000, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR"),
1316     std::make_pair(1000299001, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"),
1317     std::make_pair(1000299002, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR"),
1318     std::make_pair(1000300000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV"),
1319     std::make_pair(1000300001, "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV"),
1320     std::make_pair(1000308000, "VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR"),
1321     std::make_pair(1000309000, "VK_STRUCTURE_TYPE_RESERVED_QCOM"),
1322     std::make_pair(1000314000, "VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR"),
1323     std::make_pair(1000314001, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR"),
1324     std::make_pair(1000314002, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR"),
1325     std::make_pair(1000314003, "VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR"),
1326     std::make_pair(1000314004, "VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR"),
1327     std::make_pair(1000314005, "VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR"),
1328     std::make_pair(1000314006, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR"),
1329     std::make_pair(1000314007, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR"),
1330     std::make_pair(1000314008, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV"),
1331     std::make_pair(1000314009, "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV"),
1332     std::make_pair(1000323000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR"),
1333     std::make_pair(1000325000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR"),
1334     std::make_pair(1000326000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV"),
1335     std::make_pair(1000326001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV"),
1336     std::make_pair(1000326002, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV"),
1337     std::make_pair(1000327000, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV"),
1338     std::make_pair(1000327001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV"),
1339     std::make_pair(1000327002, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV"),
1340     std::make_pair(1000330000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT"),
1341     std::make_pair(1000332000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT"),
1342     std::make_pair(1000332001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT"),
1343     std::make_pair(1000333000, "VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM"),
1344     std::make_pair(1000335000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT"),
1345     std::make_pair(1000336000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR"),
1346     std::make_pair(1000337000, "VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR"),
1347     std::make_pair(1000337001, "VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR"),
1348     std::make_pair(1000337002, "VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR"),
1349     std::make_pair(1000337003, "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR"),
1350     std::make_pair(1000337004, "VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR"),
1351     std::make_pair(1000337005, "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR"),
1352     std::make_pair(1000337006, "VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR"),
1353     std::make_pair(1000337007, "VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR"),
1354     std::make_pair(1000337008, "VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR"),
1355     std::make_pair(1000337009, "VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR"),
1356     std::make_pair(1000337010, "VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR"),
1357     std::make_pair(1000340000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT"),
1358     std::make_pair(1000342000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM"),
1359     std::make_pair(1000344000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT"),
1360     std::make_pair(1000346000, "VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT"),
1361     std::make_pair(1000351000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE"),
1362     std::make_pair(1000351002, "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE"),
1363     std::make_pair(1000352000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT"),
1364     std::make_pair(1000352001, "VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT"),
1365     std::make_pair(1000352002, "VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT"),
1366     std::make_pair(1000353000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"),
1367     std::make_pair(1000355000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT"),
1368     std::make_pair(1000355001, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT"),
1369     std::make_pair(1000356000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT"),
1370     std::make_pair(1000360000, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR"),
1371     std::make_pair(1000364000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA"),
1372     std::make_pair(1000364001, "VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA"),
1373     std::make_pair(1000364002, "VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA"),
1374     std::make_pair(1000365000, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA"),
1375     std::make_pair(1000365001, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA"),
1376     std::make_pair(1000366000, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA"),
1377     std::make_pair(1000366001, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA"),
1378     std::make_pair(1000366002, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA"),
1379     std::make_pair(1000366003, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA"),
1380     std::make_pair(1000366004, "VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA"),
1381     std::make_pair(1000366005, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA"),
1382     std::make_pair(1000366006, "VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA"),
1383     std::make_pair(1000366007, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA"),
1384     std::make_pair(1000366008, "VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA"),
1385     std::make_pair(1000366009, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA"),
1386     std::make_pair(1000369000, "VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI"),
1387     std::make_pair(1000369001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI"),
1388     std::make_pair(1000369002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI"),
1389     std::make_pair(1000370000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI"),
1390     std::make_pair(1000371000, "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV"),
1391     std::make_pair(1000371001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV"),
1392     std::make_pair(1000377000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT"),
1393     std::make_pair(1000378000, "VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX"),
1394     std::make_pair(1000381000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT"),
1395     std::make_pair(1000381001, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT"),
1396     std::make_pair(1000388000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT"),
1397     std::make_pair(1000388001, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT"),
1398     std::make_pair(1000391000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT"),
1399     std::make_pair(1000391001, "VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT"),
1400     std::make_pair(1000392000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT"),
1401     std::make_pair(1000392001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT"),
1402     std::make_pair(1000411000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT"),
1403     std::make_pair(1000411001, "VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT"),
1404     std::make_pair(1000412000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT"),
1405     std::make_pair(1000413000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR"),
1406     std::make_pair(1000413001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR"),
1407     std::make_pair(1000413002, "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR"),
1408     std::make_pair(1000413003, "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR"),
1409     std::make_pair(1000435000, "VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT"),
1410 };
1411 static void print_VkStructureType(VkStructureType obj, const std::string& str, bool commaNeeded=true) {
1412      PRINT_SPACE
1413      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1414      if (commaNeeded)
1415          _OUT << "\"" <<  VkStructureType_map[obj] << "\"," << std::endl;
1416      else
1417          _OUT << "\"" << VkStructureType_map[obj] << "\"" << std::endl;
1418 }
1419 static void print_VkStructureType(const VkStructureType * obj, const std::string& str, bool commaNeeded=true) {
1420      PRINT_SPACE
1421      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1422      if (commaNeeded)
1423          _OUT << "\"" <<  VkStructureType_map[*obj] << "\"," << std::endl;
1424      else
1425          _OUT << "\"" << VkStructureType_map[*obj] << "\"" << std::endl;
1426 }
1427
1428 static std::map<deUint64, std::string> VkAccessFlagBits_map = {
1429     std::make_pair(1ULL << 0, "VK_ACCESS_INDIRECT_COMMAND_READ_BIT"),
1430     std::make_pair(1ULL << 1, "VK_ACCESS_INDEX_READ_BIT"),
1431     std::make_pair(1ULL << 2, "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT"),
1432     std::make_pair(1ULL << 3, "VK_ACCESS_UNIFORM_READ_BIT"),
1433     std::make_pair(1ULL << 4, "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT"),
1434     std::make_pair(1ULL << 5, "VK_ACCESS_SHADER_READ_BIT"),
1435     std::make_pair(1ULL << 6, "VK_ACCESS_SHADER_WRITE_BIT"),
1436     std::make_pair(1ULL << 7, "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT"),
1437     std::make_pair(1ULL << 8, "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT"),
1438     std::make_pair(1ULL << 9, "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT"),
1439     std::make_pair(1ULL << 10, "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT"),
1440     std::make_pair(1ULL << 11, "VK_ACCESS_TRANSFER_READ_BIT"),
1441     std::make_pair(1ULL << 12, "VK_ACCESS_TRANSFER_WRITE_BIT"),
1442     std::make_pair(1ULL << 13, "VK_ACCESS_HOST_READ_BIT"),
1443     std::make_pair(1ULL << 14, "VK_ACCESS_HOST_WRITE_BIT"),
1444     std::make_pair(1ULL << 15, "VK_ACCESS_MEMORY_READ_BIT"),
1445     std::make_pair(1ULL << 16, "VK_ACCESS_MEMORY_WRITE_BIT"),
1446     std::make_pair(1ULL << 25, "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"),
1447     std::make_pair(1ULL << 26, "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"),
1448     std::make_pair(1ULL << 27, "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"),
1449     std::make_pair(1ULL << 20, "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT"),
1450     std::make_pair(1ULL << 19, "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"),
1451     std::make_pair(1ULL << 21, "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR"),
1452     std::make_pair(1ULL << 22, "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"),
1453     std::make_pair(1ULL << 24, "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"),
1454     std::make_pair(1ULL << 23, "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"),
1455     std::make_pair(1ULL << 17, "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV"),
1456     std::make_pair(1ULL << 18, "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV"),
1457     std::make_pair(0, "VK_ACCESS_NONE_KHR"),
1458 };
1459 static void print_VkAccessFlagBits(VkAccessFlagBits obj, const std::string& str, bool commaNeeded=true) {
1460      PRINT_SPACE
1461      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1462      if (commaNeeded)
1463          _OUT << "\"" <<  VkAccessFlagBits_map[obj] << "\"," << std::endl;
1464      else
1465          _OUT << "\"" << VkAccessFlagBits_map[obj] << "\"" << std::endl;
1466 }
1467 static void print_VkAccessFlagBits(const VkAccessFlagBits * obj, const std::string& str, bool commaNeeded=true) {
1468      PRINT_SPACE
1469      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1470      if (commaNeeded)
1471          _OUT << "\"" <<  VkAccessFlagBits_map[*obj] << "\"," << std::endl;
1472      else
1473          _OUT << "\"" << VkAccessFlagBits_map[*obj] << "\"" << std::endl;
1474 }
1475
1476 static std::map<deUint64, std::string> VkImageLayout_map = {
1477     std::make_pair(0, "VK_IMAGE_LAYOUT_UNDEFINED"),
1478     std::make_pair(1, "VK_IMAGE_LAYOUT_GENERAL"),
1479     std::make_pair(2, "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL"),
1480     std::make_pair(3, "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL"),
1481     std::make_pair(4, "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL"),
1482     std::make_pair(5, "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL"),
1483     std::make_pair(6, "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL"),
1484     std::make_pair(7, "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL"),
1485     std::make_pair(8, "VK_IMAGE_LAYOUT_PREINITIALIZED"),
1486     std::make_pair(1000117000, "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"),
1487     std::make_pair(1000117001, "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"),
1488     std::make_pair(1000241000, "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL"),
1489     std::make_pair(1000241001, "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL"),
1490     std::make_pair(1000241002, "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL"),
1491     std::make_pair(1000241003, "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL"),
1492     std::make_pair(1000001002, "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR"),
1493     std::make_pair(1000024000, "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR"),
1494     std::make_pair(1000024001, "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR"),
1495     std::make_pair(1000024002, "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR"),
1496     std::make_pair(1000111000, "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR"),
1497     std::make_pair(1000218000, "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"),
1498     std::make_pair(1000164003, "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR"),
1499     std::make_pair(1000299000, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR"),
1500     std::make_pair(1000299001, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR"),
1501     std::make_pair(1000299002, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR"),
1502     std::make_pair(1000314000, "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR"),
1503     std::make_pair(1000314001, "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR"),
1504 };
1505 static void print_VkImageLayout(VkImageLayout obj, const std::string& str, bool commaNeeded=true) {
1506      PRINT_SPACE
1507      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1508      if (commaNeeded)
1509          _OUT << "\"" <<  VkImageLayout_map[obj] << "\"," << std::endl;
1510      else
1511          _OUT << "\"" << VkImageLayout_map[obj] << "\"" << std::endl;
1512 }
1513 static void print_VkImageLayout(const VkImageLayout * obj, const std::string& str, bool commaNeeded=true) {
1514      PRINT_SPACE
1515      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1516      if (commaNeeded)
1517          _OUT << "\"" <<  VkImageLayout_map[*obj] << "\"," << std::endl;
1518      else
1519          _OUT << "\"" << VkImageLayout_map[*obj] << "\"" << std::endl;
1520 }
1521
1522 static std::map<deUint64, std::string> VkImageAspectFlagBits_map = {
1523     std::make_pair(1ULL << 0, "VK_IMAGE_ASPECT_COLOR_BIT"),
1524     std::make_pair(1ULL << 1, "VK_IMAGE_ASPECT_DEPTH_BIT"),
1525     std::make_pair(1ULL << 2, "VK_IMAGE_ASPECT_STENCIL_BIT"),
1526     std::make_pair(1ULL << 3, "VK_IMAGE_ASPECT_METADATA_BIT"),
1527     std::make_pair(1ULL << 4, "VK_IMAGE_ASPECT_PLANE_0_BIT"),
1528     std::make_pair(1ULL << 5, "VK_IMAGE_ASPECT_PLANE_1_BIT"),
1529     std::make_pair(1ULL << 6, "VK_IMAGE_ASPECT_PLANE_2_BIT"),
1530     std::make_pair(1ULL << 7, "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT"),
1531     std::make_pair(1ULL << 8, "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT"),
1532     std::make_pair(1ULL << 9, "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT"),
1533     std::make_pair(1ULL << 10, "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT"),
1534     std::make_pair(0, "VK_IMAGE_ASPECT_NONE_KHR"),
1535 };
1536 static void print_VkImageAspectFlagBits(VkImageAspectFlagBits obj, const std::string& str, bool commaNeeded=true) {
1537      PRINT_SPACE
1538      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1539      if (commaNeeded)
1540          _OUT << "\"" <<  VkImageAspectFlagBits_map[obj] << "\"," << std::endl;
1541      else
1542          _OUT << "\"" << VkImageAspectFlagBits_map[obj] << "\"" << std::endl;
1543 }
1544 static void print_VkImageAspectFlagBits(const VkImageAspectFlagBits * obj, const std::string& str, bool commaNeeded=true) {
1545      PRINT_SPACE
1546      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1547      if (commaNeeded)
1548          _OUT << "\"" <<  VkImageAspectFlagBits_map[*obj] << "\"," << std::endl;
1549      else
1550          _OUT << "\"" << VkImageAspectFlagBits_map[*obj] << "\"" << std::endl;
1551 }
1552
1553 static std::map<deUint64, std::string> VkObjectType_map = {
1554     std::make_pair(0, "VK_OBJECT_TYPE_UNKNOWN"),
1555     std::make_pair(1, "VK_OBJECT_TYPE_INSTANCE"),
1556     std::make_pair(2, "VK_OBJECT_TYPE_PHYSICAL_DEVICE"),
1557     std::make_pair(3, "VK_OBJECT_TYPE_DEVICE"),
1558     std::make_pair(4, "VK_OBJECT_TYPE_QUEUE"),
1559     std::make_pair(5, "VK_OBJECT_TYPE_SEMAPHORE"),
1560     std::make_pair(6, "VK_OBJECT_TYPE_COMMAND_BUFFER"),
1561     std::make_pair(7, "VK_OBJECT_TYPE_FENCE"),
1562     std::make_pair(8, "VK_OBJECT_TYPE_DEVICE_MEMORY"),
1563     std::make_pair(9, "VK_OBJECT_TYPE_BUFFER"),
1564     std::make_pair(10, "VK_OBJECT_TYPE_IMAGE"),
1565     std::make_pair(11, "VK_OBJECT_TYPE_EVENT"),
1566     std::make_pair(12, "VK_OBJECT_TYPE_QUERY_POOL"),
1567     std::make_pair(13, "VK_OBJECT_TYPE_BUFFER_VIEW"),
1568     std::make_pair(14, "VK_OBJECT_TYPE_IMAGE_VIEW"),
1569     std::make_pair(16, "VK_OBJECT_TYPE_PIPELINE_CACHE"),
1570     std::make_pair(17, "VK_OBJECT_TYPE_PIPELINE_LAYOUT"),
1571     std::make_pair(18, "VK_OBJECT_TYPE_RENDER_PASS"),
1572     std::make_pair(19, "VK_OBJECT_TYPE_PIPELINE"),
1573     std::make_pair(20, "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT"),
1574     std::make_pair(21, "VK_OBJECT_TYPE_SAMPLER"),
1575     std::make_pair(22, "VK_OBJECT_TYPE_DESCRIPTOR_POOL"),
1576     std::make_pair(23, "VK_OBJECT_TYPE_DESCRIPTOR_SET"),
1577     std::make_pair(24, "VK_OBJECT_TYPE_FRAMEBUFFER"),
1578     std::make_pair(25, "VK_OBJECT_TYPE_COMMAND_POOL"),
1579     std::make_pair(1000156000, "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION"),
1580     std::make_pair(1000000000, "VK_OBJECT_TYPE_SURFACE_KHR"),
1581     std::make_pair(1000001000, "VK_OBJECT_TYPE_SWAPCHAIN_KHR"),
1582     std::make_pair(1000002000, "VK_OBJECT_TYPE_DISPLAY_KHR"),
1583     std::make_pair(1000002001, "VK_OBJECT_TYPE_DISPLAY_MODE_KHR"),
1584     std::make_pair(1000011000, "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT"),
1585     std::make_pair(1000023000, "VK_OBJECT_TYPE_VIDEO_SESSION_KHR"),
1586     std::make_pair(1000023001, "VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR"),
1587     std::make_pair(1000029000, "VK_OBJECT_TYPE_CU_MODULE_NVX"),
1588     std::make_pair(1000029001, "VK_OBJECT_TYPE_CU_FUNCTION_NVX"),
1589     std::make_pair(1000128000, "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT"),
1590     std::make_pair(1000150000, "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR"),
1591     std::make_pair(1000160000, "VK_OBJECT_TYPE_VALIDATION_CACHE_EXT"),
1592     std::make_pair(1000165000, "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV"),
1593     std::make_pair(1000210000, "VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL"),
1594     std::make_pair(1000268000, "VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR"),
1595     std::make_pair(1000277000, "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV"),
1596     std::make_pair(1000295000, "VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT"),
1597     std::make_pair(1000366000, "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA"),
1598 };
1599 static void print_VkObjectType(VkObjectType obj, const std::string& str, bool commaNeeded=true) {
1600      PRINT_SPACE
1601      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1602      if (commaNeeded)
1603          _OUT << "\"" <<  VkObjectType_map[obj] << "\"," << std::endl;
1604      else
1605          _OUT << "\"" << VkObjectType_map[obj] << "\"" << std::endl;
1606 }
1607 static void print_VkObjectType(const VkObjectType * obj, const std::string& str, bool commaNeeded=true) {
1608      PRINT_SPACE
1609      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1610      if (commaNeeded)
1611          _OUT << "\"" <<  VkObjectType_map[*obj] << "\"," << std::endl;
1612      else
1613          _OUT << "\"" << VkObjectType_map[*obj] << "\"" << std::endl;
1614 }
1615
1616 static std::map<deUint64, std::string> VkPipelineCacheHeaderVersion_map = {
1617     std::make_pair(1, "VK_PIPELINE_CACHE_HEADER_VERSION_ONE"),
1618     std::make_pair(1000298001, "VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE"),
1619 };
1620 static void print_VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion obj, const std::string& str, bool commaNeeded=true) {
1621      PRINT_SPACE
1622      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1623      if (commaNeeded)
1624          _OUT << "\"" <<  VkPipelineCacheHeaderVersion_map[obj] << "\"," << std::endl;
1625      else
1626          _OUT << "\"" << VkPipelineCacheHeaderVersion_map[obj] << "\"" << std::endl;
1627 }
1628 static void print_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion * obj, const std::string& str, bool commaNeeded=true) {
1629      PRINT_SPACE
1630      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1631      if (commaNeeded)
1632          _OUT << "\"" <<  VkPipelineCacheHeaderVersion_map[*obj] << "\"," << std::endl;
1633      else
1634          _OUT << "\"" << VkPipelineCacheHeaderVersion_map[*obj] << "\"" << std::endl;
1635 }
1636
1637 static std::map<deUint64, std::string> VkVendorId_map = {
1638     std::make_pair(0x10001, "VK_VENDOR_ID_VIV"),
1639     std::make_pair(0x10002, "VK_VENDOR_ID_VSI"),
1640     std::make_pair(0x10003, "VK_VENDOR_ID_KAZAN"),
1641     std::make_pair(0x10004, "VK_VENDOR_ID_CODEPLAY"),
1642     std::make_pair(0x10005, "VK_VENDOR_ID_MESA"),
1643     std::make_pair(0x10006, "VK_VENDOR_ID_POCL"),
1644 };
1645 static void print_VkVendorId(VkVendorId obj, const std::string& str, bool commaNeeded=true) {
1646      PRINT_SPACE
1647      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1648      if (commaNeeded)
1649          _OUT << "\"" <<  VkVendorId_map[obj] << "\"," << std::endl;
1650      else
1651          _OUT << "\"" << VkVendorId_map[obj] << "\"" << std::endl;
1652 }
1653 static void print_VkVendorId(const VkVendorId * obj, const std::string& str, bool commaNeeded=true) {
1654      PRINT_SPACE
1655      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1656      if (commaNeeded)
1657          _OUT << "\"" <<  VkVendorId_map[*obj] << "\"," << std::endl;
1658      else
1659          _OUT << "\"" << VkVendorId_map[*obj] << "\"" << std::endl;
1660 }
1661
1662 static std::map<deUint64, std::string> VkSystemAllocationScope_map = {
1663     std::make_pair(0, "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND"),
1664     std::make_pair(1, "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT"),
1665     std::make_pair(2, "VK_SYSTEM_ALLOCATION_SCOPE_CACHE"),
1666     std::make_pair(3, "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE"),
1667     std::make_pair(4, "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE"),
1668 };
1669 static void print_VkSystemAllocationScope(VkSystemAllocationScope obj, const std::string& str, bool commaNeeded=true) {
1670      PRINT_SPACE
1671      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1672      if (commaNeeded)
1673          _OUT << "\"" <<  VkSystemAllocationScope_map[obj] << "\"," << std::endl;
1674      else
1675          _OUT << "\"" << VkSystemAllocationScope_map[obj] << "\"" << std::endl;
1676 }
1677 static void print_VkSystemAllocationScope(const VkSystemAllocationScope * obj, const std::string& str, bool commaNeeded=true) {
1678      PRINT_SPACE
1679      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1680      if (commaNeeded)
1681          _OUT << "\"" <<  VkSystemAllocationScope_map[*obj] << "\"," << std::endl;
1682      else
1683          _OUT << "\"" << VkSystemAllocationScope_map[*obj] << "\"" << std::endl;
1684 }
1685
1686 static std::map<deUint64, std::string> VkInternalAllocationType_map = {
1687     std::make_pair(0, "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE"),
1688 };
1689 static void print_VkInternalAllocationType(VkInternalAllocationType obj, const std::string& str, bool commaNeeded=true) {
1690      PRINT_SPACE
1691      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1692      if (commaNeeded)
1693          _OUT << "\"" <<  VkInternalAllocationType_map[obj] << "\"," << std::endl;
1694      else
1695          _OUT << "\"" << VkInternalAllocationType_map[obj] << "\"" << std::endl;
1696 }
1697 static void print_VkInternalAllocationType(const VkInternalAllocationType * obj, const std::string& str, bool commaNeeded=true) {
1698      PRINT_SPACE
1699      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1700      if (commaNeeded)
1701          _OUT << "\"" <<  VkInternalAllocationType_map[*obj] << "\"," << std::endl;
1702      else
1703          _OUT << "\"" << VkInternalAllocationType_map[*obj] << "\"" << std::endl;
1704 }
1705
1706 static std::map<deUint64, std::string> VkFormat_map = {
1707     std::make_pair(0, "VK_FORMAT_UNDEFINED"),
1708     std::make_pair(1, "VK_FORMAT_R4G4_UNORM_PACK8"),
1709     std::make_pair(2, "VK_FORMAT_R4G4B4A4_UNORM_PACK16"),
1710     std::make_pair(3, "VK_FORMAT_B4G4R4A4_UNORM_PACK16"),
1711     std::make_pair(4, "VK_FORMAT_R5G6B5_UNORM_PACK16"),
1712     std::make_pair(5, "VK_FORMAT_B5G6R5_UNORM_PACK16"),
1713     std::make_pair(6, "VK_FORMAT_R5G5B5A1_UNORM_PACK16"),
1714     std::make_pair(7, "VK_FORMAT_B5G5R5A1_UNORM_PACK16"),
1715     std::make_pair(8, "VK_FORMAT_A1R5G5B5_UNORM_PACK16"),
1716     std::make_pair(9, "VK_FORMAT_R8_UNORM"),
1717     std::make_pair(10, "VK_FORMAT_R8_SNORM"),
1718     std::make_pair(11, "VK_FORMAT_R8_USCALED"),
1719     std::make_pair(12, "VK_FORMAT_R8_SSCALED"),
1720     std::make_pair(13, "VK_FORMAT_R8_UINT"),
1721     std::make_pair(14, "VK_FORMAT_R8_SINT"),
1722     std::make_pair(15, "VK_FORMAT_R8_SRGB"),
1723     std::make_pair(16, "VK_FORMAT_R8G8_UNORM"),
1724     std::make_pair(17, "VK_FORMAT_R8G8_SNORM"),
1725     std::make_pair(18, "VK_FORMAT_R8G8_USCALED"),
1726     std::make_pair(19, "VK_FORMAT_R8G8_SSCALED"),
1727     std::make_pair(20, "VK_FORMAT_R8G8_UINT"),
1728     std::make_pair(21, "VK_FORMAT_R8G8_SINT"),
1729     std::make_pair(22, "VK_FORMAT_R8G8_SRGB"),
1730     std::make_pair(23, "VK_FORMAT_R8G8B8_UNORM"),
1731     std::make_pair(24, "VK_FORMAT_R8G8B8_SNORM"),
1732     std::make_pair(25, "VK_FORMAT_R8G8B8_USCALED"),
1733     std::make_pair(26, "VK_FORMAT_R8G8B8_SSCALED"),
1734     std::make_pair(27, "VK_FORMAT_R8G8B8_UINT"),
1735     std::make_pair(28, "VK_FORMAT_R8G8B8_SINT"),
1736     std::make_pair(29, "VK_FORMAT_R8G8B8_SRGB"),
1737     std::make_pair(30, "VK_FORMAT_B8G8R8_UNORM"),
1738     std::make_pair(31, "VK_FORMAT_B8G8R8_SNORM"),
1739     std::make_pair(32, "VK_FORMAT_B8G8R8_USCALED"),
1740     std::make_pair(33, "VK_FORMAT_B8G8R8_SSCALED"),
1741     std::make_pair(34, "VK_FORMAT_B8G8R8_UINT"),
1742     std::make_pair(35, "VK_FORMAT_B8G8R8_SINT"),
1743     std::make_pair(36, "VK_FORMAT_B8G8R8_SRGB"),
1744     std::make_pair(37, "VK_FORMAT_R8G8B8A8_UNORM"),
1745     std::make_pair(38, "VK_FORMAT_R8G8B8A8_SNORM"),
1746     std::make_pair(39, "VK_FORMAT_R8G8B8A8_USCALED"),
1747     std::make_pair(40, "VK_FORMAT_R8G8B8A8_SSCALED"),
1748     std::make_pair(41, "VK_FORMAT_R8G8B8A8_UINT"),
1749     std::make_pair(42, "VK_FORMAT_R8G8B8A8_SINT"),
1750     std::make_pair(43, "VK_FORMAT_R8G8B8A8_SRGB"),
1751     std::make_pair(44, "VK_FORMAT_B8G8R8A8_UNORM"),
1752     std::make_pair(45, "VK_FORMAT_B8G8R8A8_SNORM"),
1753     std::make_pair(46, "VK_FORMAT_B8G8R8A8_USCALED"),
1754     std::make_pair(47, "VK_FORMAT_B8G8R8A8_SSCALED"),
1755     std::make_pair(48, "VK_FORMAT_B8G8R8A8_UINT"),
1756     std::make_pair(49, "VK_FORMAT_B8G8R8A8_SINT"),
1757     std::make_pair(50, "VK_FORMAT_B8G8R8A8_SRGB"),
1758     std::make_pair(51, "VK_FORMAT_A8B8G8R8_UNORM_PACK32"),
1759     std::make_pair(52, "VK_FORMAT_A8B8G8R8_SNORM_PACK32"),
1760     std::make_pair(53, "VK_FORMAT_A8B8G8R8_USCALED_PACK32"),
1761     std::make_pair(54, "VK_FORMAT_A8B8G8R8_SSCALED_PACK32"),
1762     std::make_pair(55, "VK_FORMAT_A8B8G8R8_UINT_PACK32"),
1763     std::make_pair(56, "VK_FORMAT_A8B8G8R8_SINT_PACK32"),
1764     std::make_pair(57, "VK_FORMAT_A8B8G8R8_SRGB_PACK32"),
1765     std::make_pair(58, "VK_FORMAT_A2R10G10B10_UNORM_PACK32"),
1766     std::make_pair(59, "VK_FORMAT_A2R10G10B10_SNORM_PACK32"),
1767     std::make_pair(60, "VK_FORMAT_A2R10G10B10_USCALED_PACK32"),
1768     std::make_pair(61, "VK_FORMAT_A2R10G10B10_SSCALED_PACK32"),
1769     std::make_pair(62, "VK_FORMAT_A2R10G10B10_UINT_PACK32"),
1770     std::make_pair(63, "VK_FORMAT_A2R10G10B10_SINT_PACK32"),
1771     std::make_pair(64, "VK_FORMAT_A2B10G10R10_UNORM_PACK32"),
1772     std::make_pair(65, "VK_FORMAT_A2B10G10R10_SNORM_PACK32"),
1773     std::make_pair(66, "VK_FORMAT_A2B10G10R10_USCALED_PACK32"),
1774     std::make_pair(67, "VK_FORMAT_A2B10G10R10_SSCALED_PACK32"),
1775     std::make_pair(68, "VK_FORMAT_A2B10G10R10_UINT_PACK32"),
1776     std::make_pair(69, "VK_FORMAT_A2B10G10R10_SINT_PACK32"),
1777     std::make_pair(70, "VK_FORMAT_R16_UNORM"),
1778     std::make_pair(71, "VK_FORMAT_R16_SNORM"),
1779     std::make_pair(72, "VK_FORMAT_R16_USCALED"),
1780     std::make_pair(73, "VK_FORMAT_R16_SSCALED"),
1781     std::make_pair(74, "VK_FORMAT_R16_UINT"),
1782     std::make_pair(75, "VK_FORMAT_R16_SINT"),
1783     std::make_pair(76, "VK_FORMAT_R16_SFLOAT"),
1784     std::make_pair(77, "VK_FORMAT_R16G16_UNORM"),
1785     std::make_pair(78, "VK_FORMAT_R16G16_SNORM"),
1786     std::make_pair(79, "VK_FORMAT_R16G16_USCALED"),
1787     std::make_pair(80, "VK_FORMAT_R16G16_SSCALED"),
1788     std::make_pair(81, "VK_FORMAT_R16G16_UINT"),
1789     std::make_pair(82, "VK_FORMAT_R16G16_SINT"),
1790     std::make_pair(83, "VK_FORMAT_R16G16_SFLOAT"),
1791     std::make_pair(84, "VK_FORMAT_R16G16B16_UNORM"),
1792     std::make_pair(85, "VK_FORMAT_R16G16B16_SNORM"),
1793     std::make_pair(86, "VK_FORMAT_R16G16B16_USCALED"),
1794     std::make_pair(87, "VK_FORMAT_R16G16B16_SSCALED"),
1795     std::make_pair(88, "VK_FORMAT_R16G16B16_UINT"),
1796     std::make_pair(89, "VK_FORMAT_R16G16B16_SINT"),
1797     std::make_pair(90, "VK_FORMAT_R16G16B16_SFLOAT"),
1798     std::make_pair(91, "VK_FORMAT_R16G16B16A16_UNORM"),
1799     std::make_pair(92, "VK_FORMAT_R16G16B16A16_SNORM"),
1800     std::make_pair(93, "VK_FORMAT_R16G16B16A16_USCALED"),
1801     std::make_pair(94, "VK_FORMAT_R16G16B16A16_SSCALED"),
1802     std::make_pair(95, "VK_FORMAT_R16G16B16A16_UINT"),
1803     std::make_pair(96, "VK_FORMAT_R16G16B16A16_SINT"),
1804     std::make_pair(97, "VK_FORMAT_R16G16B16A16_SFLOAT"),
1805     std::make_pair(98, "VK_FORMAT_R32_UINT"),
1806     std::make_pair(99, "VK_FORMAT_R32_SINT"),
1807     std::make_pair(100, "VK_FORMAT_R32_SFLOAT"),
1808     std::make_pair(101, "VK_FORMAT_R32G32_UINT"),
1809     std::make_pair(102, "VK_FORMAT_R32G32_SINT"),
1810     std::make_pair(103, "VK_FORMAT_R32G32_SFLOAT"),
1811     std::make_pair(104, "VK_FORMAT_R32G32B32_UINT"),
1812     std::make_pair(105, "VK_FORMAT_R32G32B32_SINT"),
1813     std::make_pair(106, "VK_FORMAT_R32G32B32_SFLOAT"),
1814     std::make_pair(107, "VK_FORMAT_R32G32B32A32_UINT"),
1815     std::make_pair(108, "VK_FORMAT_R32G32B32A32_SINT"),
1816     std::make_pair(109, "VK_FORMAT_R32G32B32A32_SFLOAT"),
1817     std::make_pair(110, "VK_FORMAT_R64_UINT"),
1818     std::make_pair(111, "VK_FORMAT_R64_SINT"),
1819     std::make_pair(112, "VK_FORMAT_R64_SFLOAT"),
1820     std::make_pair(113, "VK_FORMAT_R64G64_UINT"),
1821     std::make_pair(114, "VK_FORMAT_R64G64_SINT"),
1822     std::make_pair(115, "VK_FORMAT_R64G64_SFLOAT"),
1823     std::make_pair(116, "VK_FORMAT_R64G64B64_UINT"),
1824     std::make_pair(117, "VK_FORMAT_R64G64B64_SINT"),
1825     std::make_pair(118, "VK_FORMAT_R64G64B64_SFLOAT"),
1826     std::make_pair(119, "VK_FORMAT_R64G64B64A64_UINT"),
1827     std::make_pair(120, "VK_FORMAT_R64G64B64A64_SINT"),
1828     std::make_pair(121, "VK_FORMAT_R64G64B64A64_SFLOAT"),
1829     std::make_pair(122, "VK_FORMAT_B10G11R11_UFLOAT_PACK32"),
1830     std::make_pair(123, "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32"),
1831     std::make_pair(124, "VK_FORMAT_D16_UNORM"),
1832     std::make_pair(125, "VK_FORMAT_X8_D24_UNORM_PACK32"),
1833     std::make_pair(126, "VK_FORMAT_D32_SFLOAT"),
1834     std::make_pair(127, "VK_FORMAT_S8_UINT"),
1835     std::make_pair(128, "VK_FORMAT_D16_UNORM_S8_UINT"),
1836     std::make_pair(129, "VK_FORMAT_D24_UNORM_S8_UINT"),
1837     std::make_pair(130, "VK_FORMAT_D32_SFLOAT_S8_UINT"),
1838     std::make_pair(131, "VK_FORMAT_BC1_RGB_UNORM_BLOCK"),
1839     std::make_pair(132, "VK_FORMAT_BC1_RGB_SRGB_BLOCK"),
1840     std::make_pair(133, "VK_FORMAT_BC1_RGBA_UNORM_BLOCK"),
1841     std::make_pair(134, "VK_FORMAT_BC1_RGBA_SRGB_BLOCK"),
1842     std::make_pair(135, "VK_FORMAT_BC2_UNORM_BLOCK"),
1843     std::make_pair(136, "VK_FORMAT_BC2_SRGB_BLOCK"),
1844     std::make_pair(137, "VK_FORMAT_BC3_UNORM_BLOCK"),
1845     std::make_pair(138, "VK_FORMAT_BC3_SRGB_BLOCK"),
1846     std::make_pair(139, "VK_FORMAT_BC4_UNORM_BLOCK"),
1847     std::make_pair(140, "VK_FORMAT_BC4_SNORM_BLOCK"),
1848     std::make_pair(141, "VK_FORMAT_BC5_UNORM_BLOCK"),
1849     std::make_pair(142, "VK_FORMAT_BC5_SNORM_BLOCK"),
1850     std::make_pair(143, "VK_FORMAT_BC6H_UFLOAT_BLOCK"),
1851     std::make_pair(144, "VK_FORMAT_BC6H_SFLOAT_BLOCK"),
1852     std::make_pair(145, "VK_FORMAT_BC7_UNORM_BLOCK"),
1853     std::make_pair(146, "VK_FORMAT_BC7_SRGB_BLOCK"),
1854     std::make_pair(147, "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK"),
1855     std::make_pair(148, "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK"),
1856     std::make_pair(149, "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK"),
1857     std::make_pair(150, "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK"),
1858     std::make_pair(151, "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK"),
1859     std::make_pair(152, "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK"),
1860     std::make_pair(153, "VK_FORMAT_EAC_R11_UNORM_BLOCK"),
1861     std::make_pair(154, "VK_FORMAT_EAC_R11_SNORM_BLOCK"),
1862     std::make_pair(155, "VK_FORMAT_EAC_R11G11_UNORM_BLOCK"),
1863     std::make_pair(156, "VK_FORMAT_EAC_R11G11_SNORM_BLOCK"),
1864     std::make_pair(157, "VK_FORMAT_ASTC_4x4_UNORM_BLOCK"),
1865     std::make_pair(158, "VK_FORMAT_ASTC_4x4_SRGB_BLOCK"),
1866     std::make_pair(159, "VK_FORMAT_ASTC_5x4_UNORM_BLOCK"),
1867     std::make_pair(160, "VK_FORMAT_ASTC_5x4_SRGB_BLOCK"),
1868     std::make_pair(161, "VK_FORMAT_ASTC_5x5_UNORM_BLOCK"),
1869     std::make_pair(162, "VK_FORMAT_ASTC_5x5_SRGB_BLOCK"),
1870     std::make_pair(163, "VK_FORMAT_ASTC_6x5_UNORM_BLOCK"),
1871     std::make_pair(164, "VK_FORMAT_ASTC_6x5_SRGB_BLOCK"),
1872     std::make_pair(165, "VK_FORMAT_ASTC_6x6_UNORM_BLOCK"),
1873     std::make_pair(166, "VK_FORMAT_ASTC_6x6_SRGB_BLOCK"),
1874     std::make_pair(167, "VK_FORMAT_ASTC_8x5_UNORM_BLOCK"),
1875     std::make_pair(168, "VK_FORMAT_ASTC_8x5_SRGB_BLOCK"),
1876     std::make_pair(169, "VK_FORMAT_ASTC_8x6_UNORM_BLOCK"),
1877     std::make_pair(170, "VK_FORMAT_ASTC_8x6_SRGB_BLOCK"),
1878     std::make_pair(171, "VK_FORMAT_ASTC_8x8_UNORM_BLOCK"),
1879     std::make_pair(172, "VK_FORMAT_ASTC_8x8_SRGB_BLOCK"),
1880     std::make_pair(173, "VK_FORMAT_ASTC_10x5_UNORM_BLOCK"),
1881     std::make_pair(174, "VK_FORMAT_ASTC_10x5_SRGB_BLOCK"),
1882     std::make_pair(175, "VK_FORMAT_ASTC_10x6_UNORM_BLOCK"),
1883     std::make_pair(176, "VK_FORMAT_ASTC_10x6_SRGB_BLOCK"),
1884     std::make_pair(177, "VK_FORMAT_ASTC_10x8_UNORM_BLOCK"),
1885     std::make_pair(178, "VK_FORMAT_ASTC_10x8_SRGB_BLOCK"),
1886     std::make_pair(179, "VK_FORMAT_ASTC_10x10_UNORM_BLOCK"),
1887     std::make_pair(180, "VK_FORMAT_ASTC_10x10_SRGB_BLOCK"),
1888     std::make_pair(181, "VK_FORMAT_ASTC_12x10_UNORM_BLOCK"),
1889     std::make_pair(182, "VK_FORMAT_ASTC_12x10_SRGB_BLOCK"),
1890     std::make_pair(183, "VK_FORMAT_ASTC_12x12_UNORM_BLOCK"),
1891     std::make_pair(184, "VK_FORMAT_ASTC_12x12_SRGB_BLOCK"),
1892     std::make_pair(1000156000, "VK_FORMAT_G8B8G8R8_422_UNORM"),
1893     std::make_pair(1000156001, "VK_FORMAT_B8G8R8G8_422_UNORM"),
1894     std::make_pair(1000156002, "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM"),
1895     std::make_pair(1000156003, "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM"),
1896     std::make_pair(1000156004, "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM"),
1897     std::make_pair(1000156005, "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM"),
1898     std::make_pair(1000156006, "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM"),
1899     std::make_pair(1000156007, "VK_FORMAT_R10X6_UNORM_PACK16"),
1900     std::make_pair(1000156008, "VK_FORMAT_R10X6G10X6_UNORM_2PACK16"),
1901     std::make_pair(1000156009, "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16"),
1902     std::make_pair(1000156010, "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"),
1903     std::make_pair(1000156011, "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"),
1904     std::make_pair(1000156012, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"),
1905     std::make_pair(1000156013, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"),
1906     std::make_pair(1000156014, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"),
1907     std::make_pair(1000156015, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"),
1908     std::make_pair(1000156016, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"),
1909     std::make_pair(1000156017, "VK_FORMAT_R12X4_UNORM_PACK16"),
1910     std::make_pair(1000156018, "VK_FORMAT_R12X4G12X4_UNORM_2PACK16"),
1911     std::make_pair(1000156019, "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16"),
1912     std::make_pair(1000156020, "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"),
1913     std::make_pair(1000156021, "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"),
1914     std::make_pair(1000156022, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"),
1915     std::make_pair(1000156023, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"),
1916     std::make_pair(1000156024, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"),
1917     std::make_pair(1000156025, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"),
1918     std::make_pair(1000156026, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"),
1919     std::make_pair(1000156027, "VK_FORMAT_G16B16G16R16_422_UNORM"),
1920     std::make_pair(1000156028, "VK_FORMAT_B16G16R16G16_422_UNORM"),
1921     std::make_pair(1000156029, "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM"),
1922     std::make_pair(1000156030, "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM"),
1923     std::make_pair(1000156031, "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM"),
1924     std::make_pair(1000156032, "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM"),
1925     std::make_pair(1000156033, "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM"),
1926     std::make_pair(1000054000, "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG"),
1927     std::make_pair(1000054001, "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG"),
1928     std::make_pair(1000054002, "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG"),
1929     std::make_pair(1000054003, "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG"),
1930     std::make_pair(1000054004, "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG"),
1931     std::make_pair(1000054005, "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG"),
1932     std::make_pair(1000054006, "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG"),
1933     std::make_pair(1000054007, "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"),
1934     std::make_pair(1000066000, "VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT"),
1935     std::make_pair(1000066001, "VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT"),
1936     std::make_pair(1000066002, "VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT"),
1937     std::make_pair(1000066003, "VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT"),
1938     std::make_pair(1000066004, "VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT"),
1939     std::make_pair(1000066005, "VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT"),
1940     std::make_pair(1000066006, "VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT"),
1941     std::make_pair(1000066007, "VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT"),
1942     std::make_pair(1000066008, "VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT"),
1943     std::make_pair(1000066009, "VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT"),
1944     std::make_pair(1000066010, "VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT"),
1945     std::make_pair(1000066011, "VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT"),
1946     std::make_pair(1000066012, "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT"),
1947     std::make_pair(1000066013, "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT"),
1948     std::make_pair(1000288000, "VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT"),
1949     std::make_pair(1000288001, "VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT"),
1950     std::make_pair(1000288002, "VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT"),
1951     std::make_pair(1000288003, "VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT"),
1952     std::make_pair(1000288004, "VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT"),
1953     std::make_pair(1000288005, "VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT"),
1954     std::make_pair(1000288006, "VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT"),
1955     std::make_pair(1000288007, "VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT"),
1956     std::make_pair(1000288008, "VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT"),
1957     std::make_pair(1000288009, "VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT"),
1958     std::make_pair(1000288010, "VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT"),
1959     std::make_pair(1000288011, "VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT"),
1960     std::make_pair(1000288012, "VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT"),
1961     std::make_pair(1000288013, "VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT"),
1962     std::make_pair(1000288014, "VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT"),
1963     std::make_pair(1000288015, "VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT"),
1964     std::make_pair(1000288016, "VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT"),
1965     std::make_pair(1000288017, "VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT"),
1966     std::make_pair(1000288018, "VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT"),
1967     std::make_pair(1000288019, "VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT"),
1968     std::make_pair(1000288020, "VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT"),
1969     std::make_pair(1000288021, "VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT"),
1970     std::make_pair(1000288022, "VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT"),
1971     std::make_pair(1000288023, "VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT"),
1972     std::make_pair(1000288024, "VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT"),
1973     std::make_pair(1000288025, "VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT"),
1974     std::make_pair(1000288026, "VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT"),
1975     std::make_pair(1000288027, "VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT"),
1976     std::make_pair(1000288028, "VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT"),
1977     std::make_pair(1000288029, "VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT"),
1978     std::make_pair(1000330000, "VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT"),
1979     std::make_pair(1000330001, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT"),
1980     std::make_pair(1000330002, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT"),
1981     std::make_pair(1000330003, "VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT"),
1982     std::make_pair(1000340000, "VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT"),
1983     std::make_pair(1000340001, "VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT"),
1984 };
1985 static void print_VkFormat(VkFormat obj, const std::string& str, bool commaNeeded=true) {
1986      PRINT_SPACE
1987      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1988      if (commaNeeded)
1989          _OUT << "\"" <<  VkFormat_map[obj] << "\"," << std::endl;
1990      else
1991          _OUT << "\"" << VkFormat_map[obj] << "\"" << std::endl;
1992 }
1993 static void print_VkFormat(const VkFormat * obj, const std::string& str, bool commaNeeded=true) {
1994      PRINT_SPACE
1995      if (str != "") _OUT << "\"" << str << "\"" << " : ";
1996      if (commaNeeded)
1997          _OUT << "\"" <<  VkFormat_map[*obj] << "\"," << std::endl;
1998      else
1999          _OUT << "\"" << VkFormat_map[*obj] << "\"" << std::endl;
2000 }
2001
2002 static std::map<deUint64, std::string> VkFormatFeatureFlagBits_map = {
2003     std::make_pair(1ULL << 0, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"),
2004     std::make_pair(1ULL << 1, "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"),
2005     std::make_pair(1ULL << 2, "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"),
2006     std::make_pair(1ULL << 3, "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"),
2007     std::make_pair(1ULL << 4, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"),
2008     std::make_pair(1ULL << 5, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"),
2009     std::make_pair(1ULL << 6, "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"),
2010     std::make_pair(1ULL << 7, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"),
2011     std::make_pair(1ULL << 8, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"),
2012     std::make_pair(1ULL << 9, "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"),
2013     std::make_pair(1ULL << 10, "VK_FORMAT_FEATURE_BLIT_SRC_BIT"),
2014     std::make_pair(1ULL << 11, "VK_FORMAT_FEATURE_BLIT_DST_BIT"),
2015     std::make_pair(1ULL << 12, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"),
2016     std::make_pair(1ULL << 14, "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT"),
2017     std::make_pair(1ULL << 15, "VK_FORMAT_FEATURE_TRANSFER_DST_BIT"),
2018     std::make_pair(1ULL << 17, "VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT"),
2019     std::make_pair(1ULL << 18, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"),
2020     std::make_pair(1ULL << 19, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"),
2021     std::make_pair(1ULL << 20, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"),
2022     std::make_pair(1ULL << 21, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"),
2023     std::make_pair(1ULL << 22, "VK_FORMAT_FEATURE_DISJOINT_BIT"),
2024     std::make_pair(1ULL << 23, "VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT"),
2025     std::make_pair(1ULL << 16, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT"),
2026     std::make_pair(1ULL << 13, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG"),
2027     std::make_pair(1ULL << 25, "VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR"),
2028     std::make_pair(1ULL << 26, "VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR"),
2029     std::make_pair(1ULL << 29, "VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"),
2030     std::make_pair(1ULL << 24, "VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT"),
2031     std::make_pair(1ULL << 30, "VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"),
2032     std::make_pair(1ULL << 27, "VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR"),
2033     std::make_pair(1ULL << 28, "VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR"),
2034 };
2035 static void print_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) {
2036      PRINT_SPACE
2037      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2038      if (commaNeeded)
2039          _OUT << "\"" <<  VkFormatFeatureFlagBits_map[obj] << "\"," << std::endl;
2040      else
2041          _OUT << "\"" << VkFormatFeatureFlagBits_map[obj] << "\"" << std::endl;
2042 }
2043 static void print_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2044      PRINT_SPACE
2045      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2046      if (commaNeeded)
2047          _OUT << "\"" <<  VkFormatFeatureFlagBits_map[*obj] << "\"," << std::endl;
2048      else
2049          _OUT << "\"" << VkFormatFeatureFlagBits_map[*obj] << "\"" << std::endl;
2050 }
2051
2052 static std::map<deUint64, std::string> VkImageCreateFlagBits_map = {
2053     std::make_pair(1ULL << 0, "VK_IMAGE_CREATE_SPARSE_BINDING_BIT"),
2054     std::make_pair(1ULL << 1, "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"),
2055     std::make_pair(1ULL << 2, "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"),
2056     std::make_pair(1ULL << 3, "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"),
2057     std::make_pair(1ULL << 4, "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"),
2058     std::make_pair(1ULL << 10, "VK_IMAGE_CREATE_ALIAS_BIT"),
2059     std::make_pair(1ULL << 6, "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"),
2060     std::make_pair(1ULL << 5, "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT"),
2061     std::make_pair(1ULL << 7, "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT"),
2062     std::make_pair(1ULL << 8, "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT"),
2063     std::make_pair(1ULL << 11, "VK_IMAGE_CREATE_PROTECTED_BIT"),
2064     std::make_pair(1ULL << 9, "VK_IMAGE_CREATE_DISJOINT_BIT"),
2065     std::make_pair(1ULL << 13, "VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV"),
2066     std::make_pair(1ULL << 12, "VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT"),
2067     std::make_pair(1ULL << 14, "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT"),
2068     std::make_pair(1ULL << 16, "VK_IMAGE_CREATE_RESERVED_16_BIT_AMD"),
2069     std::make_pair(1ULL << 17, "VK_IMAGE_CREATE_RESERVED_394_BIT_EXT"),
2070     std::make_pair(1ULL << 15, "VK_IMAGE_CREATE_RESERVED_426_BIT_QCOM"),
2071 };
2072 static void print_VkImageCreateFlagBits(VkImageCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
2073      PRINT_SPACE
2074      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2075      if (commaNeeded)
2076          _OUT << "\"" <<  VkImageCreateFlagBits_map[obj] << "\"," << std::endl;
2077      else
2078          _OUT << "\"" << VkImageCreateFlagBits_map[obj] << "\"" << std::endl;
2079 }
2080 static void print_VkImageCreateFlagBits(const VkImageCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2081      PRINT_SPACE
2082      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2083      if (commaNeeded)
2084          _OUT << "\"" <<  VkImageCreateFlagBits_map[*obj] << "\"," << std::endl;
2085      else
2086          _OUT << "\"" << VkImageCreateFlagBits_map[*obj] << "\"" << std::endl;
2087 }
2088
2089 static std::map<deUint64, std::string> VkSampleCountFlagBits_map = {
2090     std::make_pair(1ULL << 0, "VK_SAMPLE_COUNT_1_BIT"),
2091     std::make_pair(1ULL << 1, "VK_SAMPLE_COUNT_2_BIT"),
2092     std::make_pair(1ULL << 2, "VK_SAMPLE_COUNT_4_BIT"),
2093     std::make_pair(1ULL << 3, "VK_SAMPLE_COUNT_8_BIT"),
2094     std::make_pair(1ULL << 4, "VK_SAMPLE_COUNT_16_BIT"),
2095     std::make_pair(1ULL << 5, "VK_SAMPLE_COUNT_32_BIT"),
2096     std::make_pair(1ULL << 6, "VK_SAMPLE_COUNT_64_BIT"),
2097 };
2098 static void print_VkSampleCountFlagBits(VkSampleCountFlagBits obj, const std::string& str, bool commaNeeded=true) {
2099      PRINT_SPACE
2100      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2101      if (commaNeeded)
2102          _OUT << "\"" <<  VkSampleCountFlagBits_map[obj] << "\"," << std::endl;
2103      else
2104          _OUT << "\"" << VkSampleCountFlagBits_map[obj] << "\"" << std::endl;
2105 }
2106 static void print_VkSampleCountFlagBits(const VkSampleCountFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2107      PRINT_SPACE
2108      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2109      if (commaNeeded)
2110          _OUT << "\"" <<  VkSampleCountFlagBits_map[*obj] << "\"," << std::endl;
2111      else
2112          _OUT << "\"" << VkSampleCountFlagBits_map[*obj] << "\"" << std::endl;
2113 }
2114
2115 static std::map<deUint64, std::string> VkImageTiling_map = {
2116     std::make_pair(0, "VK_IMAGE_TILING_OPTIMAL"),
2117     std::make_pair(1, "VK_IMAGE_TILING_LINEAR"),
2118     std::make_pair(1000158000, "VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT"),
2119 };
2120 static void print_VkImageTiling(VkImageTiling obj, const std::string& str, bool commaNeeded=true) {
2121      PRINT_SPACE
2122      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2123      if (commaNeeded)
2124          _OUT << "\"" <<  VkImageTiling_map[obj] << "\"," << std::endl;
2125      else
2126          _OUT << "\"" << VkImageTiling_map[obj] << "\"" << std::endl;
2127 }
2128 static void print_VkImageTiling(const VkImageTiling * obj, const std::string& str, bool commaNeeded=true) {
2129      PRINT_SPACE
2130      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2131      if (commaNeeded)
2132          _OUT << "\"" <<  VkImageTiling_map[*obj] << "\"," << std::endl;
2133      else
2134          _OUT << "\"" << VkImageTiling_map[*obj] << "\"" << std::endl;
2135 }
2136
2137 static std::map<deUint64, std::string> VkImageType_map = {
2138     std::make_pair(0, "VK_IMAGE_TYPE_1D"),
2139     std::make_pair(1, "VK_IMAGE_TYPE_2D"),
2140     std::make_pair(2, "VK_IMAGE_TYPE_3D"),
2141 };
2142 static void print_VkImageType(VkImageType obj, const std::string& str, bool commaNeeded=true) {
2143      PRINT_SPACE
2144      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2145      if (commaNeeded)
2146          _OUT << "\"" <<  VkImageType_map[obj] << "\"," << std::endl;
2147      else
2148          _OUT << "\"" << VkImageType_map[obj] << "\"" << std::endl;
2149 }
2150 static void print_VkImageType(const VkImageType * obj, const std::string& str, bool commaNeeded=true) {
2151      PRINT_SPACE
2152      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2153      if (commaNeeded)
2154          _OUT << "\"" <<  VkImageType_map[*obj] << "\"," << std::endl;
2155      else
2156          _OUT << "\"" << VkImageType_map[*obj] << "\"" << std::endl;
2157 }
2158
2159 static std::map<deUint64, std::string> VkImageUsageFlagBits_map = {
2160     std::make_pair(1ULL << 0, "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"),
2161     std::make_pair(1ULL << 1, "VK_IMAGE_USAGE_TRANSFER_DST_BIT"),
2162     std::make_pair(1ULL << 2, "VK_IMAGE_USAGE_SAMPLED_BIT"),
2163     std::make_pair(1ULL << 3, "VK_IMAGE_USAGE_STORAGE_BIT"),
2164     std::make_pair(1ULL << 4, "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"),
2165     std::make_pair(1ULL << 5, "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT"),
2166     std::make_pair(1ULL << 6, "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"),
2167     std::make_pair(1ULL << 7, "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"),
2168     std::make_pair(1ULL << 10, "VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR"),
2169     std::make_pair(1ULL << 11, "VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR"),
2170     std::make_pair(1ULL << 12, "VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR"),
2171     std::make_pair(1ULL << 16, "VK_IMAGE_USAGE_RESERVED_16_BIT_QCOM"),
2172     std::make_pair(1ULL << 17, "VK_IMAGE_USAGE_RESERVED_17_BIT_QCOM"),
2173     std::make_pair(1ULL << 9, "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT"),
2174     std::make_pair(1ULL << 8, "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"),
2175     std::make_pair(1ULL << 13, "VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR"),
2176     std::make_pair(1ULL << 14, "VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"),
2177     std::make_pair(1ULL << 15, "VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR"),
2178     std::make_pair(1ULL << 19, "VK_IMAGE_USAGE_RESERVED_19_BIT_EXT"),
2179     std::make_pair(1ULL << 18, "VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI"),
2180 };
2181 static void print_VkImageUsageFlagBits(VkImageUsageFlagBits obj, const std::string& str, bool commaNeeded=true) {
2182      PRINT_SPACE
2183      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2184      if (commaNeeded)
2185          _OUT << "\"" <<  VkImageUsageFlagBits_map[obj] << "\"," << std::endl;
2186      else
2187          _OUT << "\"" << VkImageUsageFlagBits_map[obj] << "\"" << std::endl;
2188 }
2189 static void print_VkImageUsageFlagBits(const VkImageUsageFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2190      PRINT_SPACE
2191      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2192      if (commaNeeded)
2193          _OUT << "\"" <<  VkImageUsageFlagBits_map[*obj] << "\"," << std::endl;
2194      else
2195          _OUT << "\"" << VkImageUsageFlagBits_map[*obj] << "\"" << std::endl;
2196 }
2197
2198 static std::map<deUint64, std::string> VkMemoryHeapFlagBits_map = {
2199     std::make_pair(1ULL << 0, "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT"),
2200     std::make_pair(1ULL << 1, "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT"),
2201     std::make_pair(1ULL << 2, "VK_MEMORY_HEAP_SEU_SAFE_BIT"),
2202 };
2203 static void print_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits obj, const std::string& str, bool commaNeeded=true) {
2204      PRINT_SPACE
2205      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2206      if (commaNeeded)
2207          _OUT << "\"" <<  VkMemoryHeapFlagBits_map[obj] << "\"," << std::endl;
2208      else
2209          _OUT << "\"" << VkMemoryHeapFlagBits_map[obj] << "\"" << std::endl;
2210 }
2211 static void print_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2212      PRINT_SPACE
2213      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2214      if (commaNeeded)
2215          _OUT << "\"" <<  VkMemoryHeapFlagBits_map[*obj] << "\"," << std::endl;
2216      else
2217          _OUT << "\"" << VkMemoryHeapFlagBits_map[*obj] << "\"" << std::endl;
2218 }
2219
2220 static std::map<deUint64, std::string> VkMemoryPropertyFlagBits_map = {
2221     std::make_pair(1ULL << 0, "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT"),
2222     std::make_pair(1ULL << 1, "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT"),
2223     std::make_pair(1ULL << 2, "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT"),
2224     std::make_pair(1ULL << 3, "VK_MEMORY_PROPERTY_HOST_CACHED_BIT"),
2225     std::make_pair(1ULL << 4, "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT"),
2226     std::make_pair(1ULL << 5, "VK_MEMORY_PROPERTY_PROTECTED_BIT"),
2227     std::make_pair(1ULL << 6, "VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD"),
2228     std::make_pair(1ULL << 7, "VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD"),
2229     std::make_pair(1ULL << 8, "VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV"),
2230 };
2231 static void print_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBits obj, const std::string& str, bool commaNeeded=true) {
2232      PRINT_SPACE
2233      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2234      if (commaNeeded)
2235          _OUT << "\"" <<  VkMemoryPropertyFlagBits_map[obj] << "\"," << std::endl;
2236      else
2237          _OUT << "\"" << VkMemoryPropertyFlagBits_map[obj] << "\"" << std::endl;
2238 }
2239 static void print_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2240      PRINT_SPACE
2241      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2242      if (commaNeeded)
2243          _OUT << "\"" <<  VkMemoryPropertyFlagBits_map[*obj] << "\"," << std::endl;
2244      else
2245          _OUT << "\"" << VkMemoryPropertyFlagBits_map[*obj] << "\"" << std::endl;
2246 }
2247
2248 static std::map<deUint64, std::string> VkPhysicalDeviceType_map = {
2249     std::make_pair(0, "VK_PHYSICAL_DEVICE_TYPE_OTHER"),
2250     std::make_pair(1, "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU"),
2251     std::make_pair(2, "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU"),
2252     std::make_pair(3, "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU"),
2253     std::make_pair(4, "VK_PHYSICAL_DEVICE_TYPE_CPU"),
2254 };
2255 static void print_VkPhysicalDeviceType(VkPhysicalDeviceType obj, const std::string& str, bool commaNeeded=true) {
2256      PRINT_SPACE
2257      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2258      if (commaNeeded)
2259          _OUT << "\"" <<  VkPhysicalDeviceType_map[obj] << "\"," << std::endl;
2260      else
2261          _OUT << "\"" << VkPhysicalDeviceType_map[obj] << "\"" << std::endl;
2262 }
2263 static void print_VkPhysicalDeviceType(const VkPhysicalDeviceType * obj, const std::string& str, bool commaNeeded=true) {
2264      PRINT_SPACE
2265      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2266      if (commaNeeded)
2267          _OUT << "\"" <<  VkPhysicalDeviceType_map[*obj] << "\"," << std::endl;
2268      else
2269          _OUT << "\"" << VkPhysicalDeviceType_map[*obj] << "\"" << std::endl;
2270 }
2271
2272 static std::map<deUint64, std::string> VkQueueFlagBits_map = {
2273     std::make_pair(1ULL << 0, "VK_QUEUE_GRAPHICS_BIT"),
2274     std::make_pair(1ULL << 1, "VK_QUEUE_COMPUTE_BIT"),
2275     std::make_pair(1ULL << 2, "VK_QUEUE_TRANSFER_BIT"),
2276     std::make_pair(1ULL << 4, "VK_QUEUE_PROTECTED_BIT"),
2277     std::make_pair(1ULL << 5, "VK_QUEUE_VIDEO_DECODE_BIT_KHR"),
2278     std::make_pair(1ULL << 6, "VK_QUEUE_VIDEO_ENCODE_BIT_KHR"),
2279 };
2280 static void print_VkQueueFlagBits(VkQueueFlagBits obj, const std::string& str, bool commaNeeded=true) {
2281      PRINT_SPACE
2282      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2283      if (commaNeeded)
2284          _OUT << "\"" <<  VkQueueFlagBits_map[obj] << "\"," << std::endl;
2285      else
2286          _OUT << "\"" << VkQueueFlagBits_map[obj] << "\"" << std::endl;
2287 }
2288 static void print_VkQueueFlagBits(const VkQueueFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2289      PRINT_SPACE
2290      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2291      if (commaNeeded)
2292          _OUT << "\"" <<  VkQueueFlagBits_map[*obj] << "\"," << std::endl;
2293      else
2294          _OUT << "\"" << VkQueueFlagBits_map[*obj] << "\"" << std::endl;
2295 }
2296
2297 static std::map<deUint64, std::string> VkDeviceQueueCreateFlagBits_map = {
2298     std::make_pair(1ULL << 0, "VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT"),
2299 };
2300 static void print_VkDeviceQueueCreateFlagBits(VkDeviceQueueCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
2301      PRINT_SPACE
2302      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2303      if (commaNeeded)
2304          _OUT << "\"" <<  VkDeviceQueueCreateFlagBits_map[obj] << "\"," << std::endl;
2305      else
2306          _OUT << "\"" << VkDeviceQueueCreateFlagBits_map[obj] << "\"" << std::endl;
2307 }
2308 static void print_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2309      PRINT_SPACE
2310      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2311      if (commaNeeded)
2312          _OUT << "\"" <<  VkDeviceQueueCreateFlagBits_map[*obj] << "\"," << std::endl;
2313      else
2314          _OUT << "\"" << VkDeviceQueueCreateFlagBits_map[*obj] << "\"" << std::endl;
2315 }
2316
2317 static std::map<deUint64, std::string> VkPipelineStageFlagBits_map = {
2318     std::make_pair(1ULL << 0, "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT"),
2319     std::make_pair(1ULL << 1, "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT"),
2320     std::make_pair(1ULL << 2, "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT"),
2321     std::make_pair(1ULL << 3, "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT"),
2322     std::make_pair(1ULL << 4, "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT"),
2323     std::make_pair(1ULL << 5, "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT"),
2324     std::make_pair(1ULL << 6, "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT"),
2325     std::make_pair(1ULL << 7, "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT"),
2326     std::make_pair(1ULL << 8, "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT"),
2327     std::make_pair(1ULL << 9, "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT"),
2328     std::make_pair(1ULL << 10, "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT"),
2329     std::make_pair(1ULL << 11, "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT"),
2330     std::make_pair(1ULL << 12, "VK_PIPELINE_STAGE_TRANSFER_BIT"),
2331     std::make_pair(1ULL << 13, "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT"),
2332     std::make_pair(1ULL << 14, "VK_PIPELINE_STAGE_HOST_BIT"),
2333     std::make_pair(1ULL << 15, "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT"),
2334     std::make_pair(1ULL << 16, "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT"),
2335     std::make_pair(1ULL << 24, "VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT"),
2336     std::make_pair(1ULL << 18, "VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT"),
2337     std::make_pair(1ULL << 25, "VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"),
2338     std::make_pair(1ULL << 21, "VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR"),
2339     std::make_pair(1ULL << 19, "VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV"),
2340     std::make_pair(1ULL << 20, "VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV"),
2341     std::make_pair(1ULL << 23, "VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT"),
2342     std::make_pair(1ULL << 22, "VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"),
2343     std::make_pair(1ULL << 17, "VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV"),
2344     std::make_pair(0, "VK_PIPELINE_STAGE_NONE_KHR"),
2345 };
2346 static void print_VkPipelineStageFlagBits(VkPipelineStageFlagBits obj, const std::string& str, bool commaNeeded=true) {
2347      PRINT_SPACE
2348      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2349      if (commaNeeded)
2350          _OUT << "\"" <<  VkPipelineStageFlagBits_map[obj] << "\"," << std::endl;
2351      else
2352          _OUT << "\"" << VkPipelineStageFlagBits_map[obj] << "\"" << std::endl;
2353 }
2354 static void print_VkPipelineStageFlagBits(const VkPipelineStageFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2355      PRINT_SPACE
2356      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2357      if (commaNeeded)
2358          _OUT << "\"" <<  VkPipelineStageFlagBits_map[*obj] << "\"," << std::endl;
2359      else
2360          _OUT << "\"" << VkPipelineStageFlagBits_map[*obj] << "\"" << std::endl;
2361 }
2362
2363 static std::map<deUint64, std::string> VkFenceCreateFlagBits_map = {
2364     std::make_pair(1ULL << 0, "VK_FENCE_CREATE_SIGNALED_BIT"),
2365 };
2366 static void print_VkFenceCreateFlagBits(VkFenceCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
2367      PRINT_SPACE
2368      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2369      if (commaNeeded)
2370          _OUT << "\"" <<  VkFenceCreateFlagBits_map[obj] << "\"," << std::endl;
2371      else
2372          _OUT << "\"" << VkFenceCreateFlagBits_map[obj] << "\"" << std::endl;
2373 }
2374 static void print_VkFenceCreateFlagBits(const VkFenceCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2375      PRINT_SPACE
2376      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2377      if (commaNeeded)
2378          _OUT << "\"" <<  VkFenceCreateFlagBits_map[*obj] << "\"," << std::endl;
2379      else
2380          _OUT << "\"" << VkFenceCreateFlagBits_map[*obj] << "\"" << std::endl;
2381 }
2382
2383 static std::map<deUint64, std::string> VkEventCreateFlagBits_map = {
2384     std::make_pair(1ULL << 0, "VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR"),
2385 };
2386 static void print_VkEventCreateFlagBits(VkEventCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
2387      PRINT_SPACE
2388      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2389      if (commaNeeded)
2390          _OUT << "\"" <<  VkEventCreateFlagBits_map[obj] << "\"," << std::endl;
2391      else
2392          _OUT << "\"" << VkEventCreateFlagBits_map[obj] << "\"" << std::endl;
2393 }
2394 static void print_VkEventCreateFlagBits(const VkEventCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2395      PRINT_SPACE
2396      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2397      if (commaNeeded)
2398          _OUT << "\"" <<  VkEventCreateFlagBits_map[*obj] << "\"," << std::endl;
2399      else
2400          _OUT << "\"" << VkEventCreateFlagBits_map[*obj] << "\"" << std::endl;
2401 }
2402
2403 static std::map<deUint64, std::string> VkQueryPipelineStatisticFlagBits_map = {
2404     std::make_pair(1ULL << 0, "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT"),
2405     std::make_pair(1ULL << 1, "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT"),
2406     std::make_pair(1ULL << 2, "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT"),
2407     std::make_pair(1ULL << 3, "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT"),
2408     std::make_pair(1ULL << 4, "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT"),
2409     std::make_pair(1ULL << 5, "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT"),
2410     std::make_pair(1ULL << 6, "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT"),
2411     std::make_pair(1ULL << 7, "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT"),
2412     std::make_pair(1ULL << 8, "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT"),
2413     std::make_pair(1ULL << 9, "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT"),
2414     std::make_pair(1ULL << 10, "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT"),
2415 };
2416 static void print_VkQueryPipelineStatisticFlagBits(VkQueryPipelineStatisticFlagBits obj, const std::string& str, bool commaNeeded=true) {
2417      PRINT_SPACE
2418      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2419      if (commaNeeded)
2420          _OUT << "\"" <<  VkQueryPipelineStatisticFlagBits_map[obj] << "\"," << std::endl;
2421      else
2422          _OUT << "\"" << VkQueryPipelineStatisticFlagBits_map[obj] << "\"" << std::endl;
2423 }
2424 static void print_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2425      PRINT_SPACE
2426      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2427      if (commaNeeded)
2428          _OUT << "\"" <<  VkQueryPipelineStatisticFlagBits_map[*obj] << "\"," << std::endl;
2429      else
2430          _OUT << "\"" << VkQueryPipelineStatisticFlagBits_map[*obj] << "\"" << std::endl;
2431 }
2432
2433 static std::map<deUint64, std::string> VkQueryType_map = {
2434     std::make_pair(0, "VK_QUERY_TYPE_OCCLUSION"),
2435     std::make_pair(1, "VK_QUERY_TYPE_PIPELINE_STATISTICS"),
2436     std::make_pair(2, "VK_QUERY_TYPE_TIMESTAMP"),
2437     std::make_pair(1000023000, "VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR"),
2438     std::make_pair(1000028004, "VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT"),
2439     std::make_pair(1000116000, "VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR"),
2440     std::make_pair(1000150000, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR"),
2441     std::make_pair(1000150001, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR"),
2442     std::make_pair(1000165000, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV"),
2443     std::make_pair(1000210000, "VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL"),
2444     std::make_pair(1000299000, "VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR"),
2445 };
2446 static void print_VkQueryType(VkQueryType obj, const std::string& str, bool commaNeeded=true) {
2447      PRINT_SPACE
2448      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2449      if (commaNeeded)
2450          _OUT << "\"" <<  VkQueryType_map[obj] << "\"," << std::endl;
2451      else
2452          _OUT << "\"" << VkQueryType_map[obj] << "\"" << std::endl;
2453 }
2454 static void print_VkQueryType(const VkQueryType * obj, const std::string& str, bool commaNeeded=true) {
2455      PRINT_SPACE
2456      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2457      if (commaNeeded)
2458          _OUT << "\"" <<  VkQueryType_map[*obj] << "\"," << std::endl;
2459      else
2460          _OUT << "\"" << VkQueryType_map[*obj] << "\"" << std::endl;
2461 }
2462
2463 static std::map<deUint64, std::string> VkQueryResultFlagBits_map = {
2464     std::make_pair(1ULL << 0, "VK_QUERY_RESULT_64_BIT"),
2465     std::make_pair(1ULL << 1, "VK_QUERY_RESULT_WAIT_BIT"),
2466     std::make_pair(1ULL << 2, "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT"),
2467     std::make_pair(1ULL << 3, "VK_QUERY_RESULT_PARTIAL_BIT"),
2468     std::make_pair(1ULL << 4, "VK_QUERY_RESULT_WITH_STATUS_BIT_KHR"),
2469 };
2470 static void print_VkQueryResultFlagBits(VkQueryResultFlagBits obj, const std::string& str, bool commaNeeded=true) {
2471      PRINT_SPACE
2472      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2473      if (commaNeeded)
2474          _OUT << "\"" <<  VkQueryResultFlagBits_map[obj] << "\"," << std::endl;
2475      else
2476          _OUT << "\"" << VkQueryResultFlagBits_map[obj] << "\"" << std::endl;
2477 }
2478 static void print_VkQueryResultFlagBits(const VkQueryResultFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2479      PRINT_SPACE
2480      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2481      if (commaNeeded)
2482          _OUT << "\"" <<  VkQueryResultFlagBits_map[*obj] << "\"," << std::endl;
2483      else
2484          _OUT << "\"" << VkQueryResultFlagBits_map[*obj] << "\"" << std::endl;
2485 }
2486
2487 static std::map<deUint64, std::string> VkBufferCreateFlagBits_map = {
2488     std::make_pair(1ULL << 0, "VK_BUFFER_CREATE_SPARSE_BINDING_BIT"),
2489     std::make_pair(1ULL << 1, "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT"),
2490     std::make_pair(1ULL << 2, "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT"),
2491     std::make_pair(1ULL << 3, "VK_BUFFER_CREATE_PROTECTED_BIT"),
2492     std::make_pair(1ULL << 4, "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"),
2493     std::make_pair(1ULL << 5, "VK_BUFFER_CREATE_RESERVED_5_BIT_AMD"),
2494 };
2495 static void print_VkBufferCreateFlagBits(VkBufferCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
2496      PRINT_SPACE
2497      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2498      if (commaNeeded)
2499          _OUT << "\"" <<  VkBufferCreateFlagBits_map[obj] << "\"," << std::endl;
2500      else
2501          _OUT << "\"" << VkBufferCreateFlagBits_map[obj] << "\"" << std::endl;
2502 }
2503 static void print_VkBufferCreateFlagBits(const VkBufferCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2504      PRINT_SPACE
2505      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2506      if (commaNeeded)
2507          _OUT << "\"" <<  VkBufferCreateFlagBits_map[*obj] << "\"," << std::endl;
2508      else
2509          _OUT << "\"" << VkBufferCreateFlagBits_map[*obj] << "\"" << std::endl;
2510 }
2511
2512 static std::map<deUint64, std::string> VkBufferUsageFlagBits_map = {
2513     std::make_pair(1ULL << 0, "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"),
2514     std::make_pair(1ULL << 1, "VK_BUFFER_USAGE_TRANSFER_DST_BIT"),
2515     std::make_pair(1ULL << 2, "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"),
2516     std::make_pair(1ULL << 3, "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"),
2517     std::make_pair(1ULL << 4, "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"),
2518     std::make_pair(1ULL << 5, "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"),
2519     std::make_pair(1ULL << 6, "VK_BUFFER_USAGE_INDEX_BUFFER_BIT"),
2520     std::make_pair(1ULL << 7, "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"),
2521     std::make_pair(1ULL << 8, "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT"),
2522     std::make_pair(1ULL << 17, "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT"),
2523     std::make_pair(1ULL << 13, "VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR"),
2524     std::make_pair(1ULL << 14, "VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR"),
2525     std::make_pair(1ULL << 11, "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"),
2526     std::make_pair(1ULL << 12, "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"),
2527     std::make_pair(1ULL << 9, "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"),
2528     std::make_pair(1ULL << 19, "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"),
2529     std::make_pair(1ULL << 20, "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"),
2530     std::make_pair(1ULL << 10, "VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR"),
2531     std::make_pair(1ULL << 18, "VK_BUFFER_USAGE_RESERVED_18_BIT_QCOM"),
2532     std::make_pair(1ULL << 15, "VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR"),
2533     std::make_pair(1ULL << 16, "VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"),
2534     std::make_pair(1ULL << 21, "VK_BUFFER_USAGE_RESERVED_21_BIT_AMD"),
2535     std::make_pair(1ULL << 22, "VK_BUFFER_USAGE_RESERVED_22_BIT_AMD"),
2536 };
2537 static void print_VkBufferUsageFlagBits(VkBufferUsageFlagBits obj, const std::string& str, bool commaNeeded=true) {
2538      PRINT_SPACE
2539      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2540      if (commaNeeded)
2541          _OUT << "\"" <<  VkBufferUsageFlagBits_map[obj] << "\"," << std::endl;
2542      else
2543          _OUT << "\"" << VkBufferUsageFlagBits_map[obj] << "\"" << std::endl;
2544 }
2545 static void print_VkBufferUsageFlagBits(const VkBufferUsageFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2546      PRINT_SPACE
2547      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2548      if (commaNeeded)
2549          _OUT << "\"" <<  VkBufferUsageFlagBits_map[*obj] << "\"," << std::endl;
2550      else
2551          _OUT << "\"" << VkBufferUsageFlagBits_map[*obj] << "\"" << std::endl;
2552 }
2553
2554 static std::map<deUint64, std::string> VkSharingMode_map = {
2555     std::make_pair(0, "VK_SHARING_MODE_EXCLUSIVE"),
2556     std::make_pair(1, "VK_SHARING_MODE_CONCURRENT"),
2557 };
2558 static void print_VkSharingMode(VkSharingMode obj, const std::string& str, bool commaNeeded=true) {
2559      PRINT_SPACE
2560      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2561      if (commaNeeded)
2562          _OUT << "\"" <<  VkSharingMode_map[obj] << "\"," << std::endl;
2563      else
2564          _OUT << "\"" << VkSharingMode_map[obj] << "\"" << std::endl;
2565 }
2566 static void print_VkSharingMode(const VkSharingMode * obj, const std::string& str, bool commaNeeded=true) {
2567      PRINT_SPACE
2568      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2569      if (commaNeeded)
2570          _OUT << "\"" <<  VkSharingMode_map[*obj] << "\"," << std::endl;
2571      else
2572          _OUT << "\"" << VkSharingMode_map[*obj] << "\"" << std::endl;
2573 }
2574
2575 static std::map<deUint64, std::string> VkComponentSwizzle_map = {
2576     std::make_pair(0, "VK_COMPONENT_SWIZZLE_IDENTITY"),
2577     std::make_pair(1, "VK_COMPONENT_SWIZZLE_ZERO"),
2578     std::make_pair(2, "VK_COMPONENT_SWIZZLE_ONE"),
2579     std::make_pair(3, "VK_COMPONENT_SWIZZLE_R"),
2580     std::make_pair(4, "VK_COMPONENT_SWIZZLE_G"),
2581     std::make_pair(5, "VK_COMPONENT_SWIZZLE_B"),
2582     std::make_pair(6, "VK_COMPONENT_SWIZZLE_A"),
2583 };
2584 static void print_VkComponentSwizzle(VkComponentSwizzle obj, const std::string& str, bool commaNeeded=true) {
2585      PRINT_SPACE
2586      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2587      if (commaNeeded)
2588          _OUT << "\"" <<  VkComponentSwizzle_map[obj] << "\"," << std::endl;
2589      else
2590          _OUT << "\"" << VkComponentSwizzle_map[obj] << "\"" << std::endl;
2591 }
2592 static void print_VkComponentSwizzle(const VkComponentSwizzle * obj, const std::string& str, bool commaNeeded=true) {
2593      PRINT_SPACE
2594      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2595      if (commaNeeded)
2596          _OUT << "\"" <<  VkComponentSwizzle_map[*obj] << "\"," << std::endl;
2597      else
2598          _OUT << "\"" << VkComponentSwizzle_map[*obj] << "\"" << std::endl;
2599 }
2600
2601 static std::map<deUint64, std::string> VkImageViewCreateFlagBits_map = {
2602     std::make_pair(1ULL << 0, "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT"),
2603     std::make_pair(1ULL << 1, "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT"),
2604 };
2605 static void print_VkImageViewCreateFlagBits(VkImageViewCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
2606      PRINT_SPACE
2607      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2608      if (commaNeeded)
2609          _OUT << "\"" <<  VkImageViewCreateFlagBits_map[obj] << "\"," << std::endl;
2610      else
2611          _OUT << "\"" << VkImageViewCreateFlagBits_map[obj] << "\"" << std::endl;
2612 }
2613 static void print_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2614      PRINT_SPACE
2615      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2616      if (commaNeeded)
2617          _OUT << "\"" <<  VkImageViewCreateFlagBits_map[*obj] << "\"," << std::endl;
2618      else
2619          _OUT << "\"" << VkImageViewCreateFlagBits_map[*obj] << "\"" << std::endl;
2620 }
2621
2622 static std::map<deUint64, std::string> VkImageViewType_map = {
2623     std::make_pair(0, "VK_IMAGE_VIEW_TYPE_1D"),
2624     std::make_pair(1, "VK_IMAGE_VIEW_TYPE_2D"),
2625     std::make_pair(2, "VK_IMAGE_VIEW_TYPE_3D"),
2626     std::make_pair(3, "VK_IMAGE_VIEW_TYPE_CUBE"),
2627     std::make_pair(4, "VK_IMAGE_VIEW_TYPE_1D_ARRAY"),
2628     std::make_pair(5, "VK_IMAGE_VIEW_TYPE_2D_ARRAY"),
2629     std::make_pair(6, "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY"),
2630 };
2631 static void print_VkImageViewType(VkImageViewType obj, const std::string& str, bool commaNeeded=true) {
2632      PRINT_SPACE
2633      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2634      if (commaNeeded)
2635          _OUT << "\"" <<  VkImageViewType_map[obj] << "\"," << std::endl;
2636      else
2637          _OUT << "\"" << VkImageViewType_map[obj] << "\"" << std::endl;
2638 }
2639 static void print_VkImageViewType(const VkImageViewType * obj, const std::string& str, bool commaNeeded=true) {
2640      PRINT_SPACE
2641      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2642      if (commaNeeded)
2643          _OUT << "\"" <<  VkImageViewType_map[*obj] << "\"," << std::endl;
2644      else
2645          _OUT << "\"" << VkImageViewType_map[*obj] << "\"" << std::endl;
2646 }
2647
2648 static std::map<deUint64, std::string> VkPipelineCacheCreateFlagBits_map = {
2649     std::make_pair(1ULL << 2, "VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT"),
2650     std::make_pair(1ULL << 1, "VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT"),
2651     std::make_pair(1ULL << 0, "VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT"),
2652 };
2653 static void print_VkPipelineCacheCreateFlagBits(VkPipelineCacheCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
2654      PRINT_SPACE
2655      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2656      if (commaNeeded)
2657          _OUT << "\"" <<  VkPipelineCacheCreateFlagBits_map[obj] << "\"," << std::endl;
2658      else
2659          _OUT << "\"" << VkPipelineCacheCreateFlagBits_map[obj] << "\"" << std::endl;
2660 }
2661 static void print_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2662      PRINT_SPACE
2663      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2664      if (commaNeeded)
2665          _OUT << "\"" <<  VkPipelineCacheCreateFlagBits_map[*obj] << "\"," << std::endl;
2666      else
2667          _OUT << "\"" << VkPipelineCacheCreateFlagBits_map[*obj] << "\"" << std::endl;
2668 }
2669
2670 static std::map<deUint64, std::string> VkBlendFactor_map = {
2671     std::make_pair(0, "VK_BLEND_FACTOR_ZERO"),
2672     std::make_pair(1, "VK_BLEND_FACTOR_ONE"),
2673     std::make_pair(2, "VK_BLEND_FACTOR_SRC_COLOR"),
2674     std::make_pair(3, "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR"),
2675     std::make_pair(4, "VK_BLEND_FACTOR_DST_COLOR"),
2676     std::make_pair(5, "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR"),
2677     std::make_pair(6, "VK_BLEND_FACTOR_SRC_ALPHA"),
2678     std::make_pair(7, "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA"),
2679     std::make_pair(8, "VK_BLEND_FACTOR_DST_ALPHA"),
2680     std::make_pair(9, "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA"),
2681     std::make_pair(10, "VK_BLEND_FACTOR_CONSTANT_COLOR"),
2682     std::make_pair(11, "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR"),
2683     std::make_pair(12, "VK_BLEND_FACTOR_CONSTANT_ALPHA"),
2684     std::make_pair(13, "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA"),
2685     std::make_pair(14, "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE"),
2686     std::make_pair(15, "VK_BLEND_FACTOR_SRC1_COLOR"),
2687     std::make_pair(16, "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR"),
2688     std::make_pair(17, "VK_BLEND_FACTOR_SRC1_ALPHA"),
2689     std::make_pair(18, "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA"),
2690 };
2691 static void print_VkBlendFactor(VkBlendFactor obj, const std::string& str, bool commaNeeded=true) {
2692      PRINT_SPACE
2693      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2694      if (commaNeeded)
2695          _OUT << "\"" <<  VkBlendFactor_map[obj] << "\"," << std::endl;
2696      else
2697          _OUT << "\"" << VkBlendFactor_map[obj] << "\"" << std::endl;
2698 }
2699 static void print_VkBlendFactor(const VkBlendFactor * obj, const std::string& str, bool commaNeeded=true) {
2700      PRINT_SPACE
2701      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2702      if (commaNeeded)
2703          _OUT << "\"" <<  VkBlendFactor_map[*obj] << "\"," << std::endl;
2704      else
2705          _OUT << "\"" << VkBlendFactor_map[*obj] << "\"" << std::endl;
2706 }
2707
2708 static std::map<deUint64, std::string> VkBlendOp_map = {
2709     std::make_pair(0, "VK_BLEND_OP_ADD"),
2710     std::make_pair(1, "VK_BLEND_OP_SUBTRACT"),
2711     std::make_pair(2, "VK_BLEND_OP_REVERSE_SUBTRACT"),
2712     std::make_pair(3, "VK_BLEND_OP_MIN"),
2713     std::make_pair(4, "VK_BLEND_OP_MAX"),
2714     std::make_pair(1000148000, "VK_BLEND_OP_ZERO_EXT"),
2715     std::make_pair(1000148001, "VK_BLEND_OP_SRC_EXT"),
2716     std::make_pair(1000148002, "VK_BLEND_OP_DST_EXT"),
2717     std::make_pair(1000148003, "VK_BLEND_OP_SRC_OVER_EXT"),
2718     std::make_pair(1000148004, "VK_BLEND_OP_DST_OVER_EXT"),
2719     std::make_pair(1000148005, "VK_BLEND_OP_SRC_IN_EXT"),
2720     std::make_pair(1000148006, "VK_BLEND_OP_DST_IN_EXT"),
2721     std::make_pair(1000148007, "VK_BLEND_OP_SRC_OUT_EXT"),
2722     std::make_pair(1000148008, "VK_BLEND_OP_DST_OUT_EXT"),
2723     std::make_pair(1000148009, "VK_BLEND_OP_SRC_ATOP_EXT"),
2724     std::make_pair(1000148010, "VK_BLEND_OP_DST_ATOP_EXT"),
2725     std::make_pair(1000148011, "VK_BLEND_OP_XOR_EXT"),
2726     std::make_pair(1000148012, "VK_BLEND_OP_MULTIPLY_EXT"),
2727     std::make_pair(1000148013, "VK_BLEND_OP_SCREEN_EXT"),
2728     std::make_pair(1000148014, "VK_BLEND_OP_OVERLAY_EXT"),
2729     std::make_pair(1000148015, "VK_BLEND_OP_DARKEN_EXT"),
2730     std::make_pair(1000148016, "VK_BLEND_OP_LIGHTEN_EXT"),
2731     std::make_pair(1000148017, "VK_BLEND_OP_COLORDODGE_EXT"),
2732     std::make_pair(1000148018, "VK_BLEND_OP_COLORBURN_EXT"),
2733     std::make_pair(1000148019, "VK_BLEND_OP_HARDLIGHT_EXT"),
2734     std::make_pair(1000148020, "VK_BLEND_OP_SOFTLIGHT_EXT"),
2735     std::make_pair(1000148021, "VK_BLEND_OP_DIFFERENCE_EXT"),
2736     std::make_pair(1000148022, "VK_BLEND_OP_EXCLUSION_EXT"),
2737     std::make_pair(1000148023, "VK_BLEND_OP_INVERT_EXT"),
2738     std::make_pair(1000148024, "VK_BLEND_OP_INVERT_RGB_EXT"),
2739     std::make_pair(1000148025, "VK_BLEND_OP_LINEARDODGE_EXT"),
2740     std::make_pair(1000148026, "VK_BLEND_OP_LINEARBURN_EXT"),
2741     std::make_pair(1000148027, "VK_BLEND_OP_VIVIDLIGHT_EXT"),
2742     std::make_pair(1000148028, "VK_BLEND_OP_LINEARLIGHT_EXT"),
2743     std::make_pair(1000148029, "VK_BLEND_OP_PINLIGHT_EXT"),
2744     std::make_pair(1000148030, "VK_BLEND_OP_HARDMIX_EXT"),
2745     std::make_pair(1000148031, "VK_BLEND_OP_HSL_HUE_EXT"),
2746     std::make_pair(1000148032, "VK_BLEND_OP_HSL_SATURATION_EXT"),
2747     std::make_pair(1000148033, "VK_BLEND_OP_HSL_COLOR_EXT"),
2748     std::make_pair(1000148034, "VK_BLEND_OP_HSL_LUMINOSITY_EXT"),
2749     std::make_pair(1000148035, "VK_BLEND_OP_PLUS_EXT"),
2750     std::make_pair(1000148036, "VK_BLEND_OP_PLUS_CLAMPED_EXT"),
2751     std::make_pair(1000148037, "VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT"),
2752     std::make_pair(1000148038, "VK_BLEND_OP_PLUS_DARKER_EXT"),
2753     std::make_pair(1000148039, "VK_BLEND_OP_MINUS_EXT"),
2754     std::make_pair(1000148040, "VK_BLEND_OP_MINUS_CLAMPED_EXT"),
2755     std::make_pair(1000148041, "VK_BLEND_OP_CONTRAST_EXT"),
2756     std::make_pair(1000148042, "VK_BLEND_OP_INVERT_OVG_EXT"),
2757     std::make_pair(1000148043, "VK_BLEND_OP_RED_EXT"),
2758     std::make_pair(1000148044, "VK_BLEND_OP_GREEN_EXT"),
2759     std::make_pair(1000148045, "VK_BLEND_OP_BLUE_EXT"),
2760 };
2761 static void print_VkBlendOp(VkBlendOp obj, const std::string& str, bool commaNeeded=true) {
2762      PRINT_SPACE
2763      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2764      if (commaNeeded)
2765          _OUT << "\"" <<  VkBlendOp_map[obj] << "\"," << std::endl;
2766      else
2767          _OUT << "\"" << VkBlendOp_map[obj] << "\"" << std::endl;
2768 }
2769 static void print_VkBlendOp(const VkBlendOp * obj, const std::string& str, bool commaNeeded=true) {
2770      PRINT_SPACE
2771      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2772      if (commaNeeded)
2773          _OUT << "\"" <<  VkBlendOp_map[*obj] << "\"," << std::endl;
2774      else
2775          _OUT << "\"" << VkBlendOp_map[*obj] << "\"" << std::endl;
2776 }
2777
2778 static std::map<deUint64, std::string> VkColorComponentFlagBits_map = {
2779     std::make_pair(1ULL << 0, "VK_COLOR_COMPONENT_R_BIT"),
2780     std::make_pair(1ULL << 1, "VK_COLOR_COMPONENT_G_BIT"),
2781     std::make_pair(1ULL << 2, "VK_COLOR_COMPONENT_B_BIT"),
2782     std::make_pair(1ULL << 3, "VK_COLOR_COMPONENT_A_BIT"),
2783 };
2784 static void print_VkColorComponentFlagBits(VkColorComponentFlagBits obj, const std::string& str, bool commaNeeded=true) {
2785      PRINT_SPACE
2786      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2787      if (commaNeeded)
2788          _OUT << "\"" <<  VkColorComponentFlagBits_map[obj] << "\"," << std::endl;
2789      else
2790          _OUT << "\"" << VkColorComponentFlagBits_map[obj] << "\"" << std::endl;
2791 }
2792 static void print_VkColorComponentFlagBits(const VkColorComponentFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2793      PRINT_SPACE
2794      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2795      if (commaNeeded)
2796          _OUT << "\"" <<  VkColorComponentFlagBits_map[*obj] << "\"," << std::endl;
2797      else
2798          _OUT << "\"" << VkColorComponentFlagBits_map[*obj] << "\"" << std::endl;
2799 }
2800
2801 static std::map<deUint64, std::string> VkCompareOp_map = {
2802     std::make_pair(0, "VK_COMPARE_OP_NEVER"),
2803     std::make_pair(1, "VK_COMPARE_OP_LESS"),
2804     std::make_pair(2, "VK_COMPARE_OP_EQUAL"),
2805     std::make_pair(3, "VK_COMPARE_OP_LESS_OR_EQUAL"),
2806     std::make_pair(4, "VK_COMPARE_OP_GREATER"),
2807     std::make_pair(5, "VK_COMPARE_OP_NOT_EQUAL"),
2808     std::make_pair(6, "VK_COMPARE_OP_GREATER_OR_EQUAL"),
2809     std::make_pair(7, "VK_COMPARE_OP_ALWAYS"),
2810 };
2811 static void print_VkCompareOp(VkCompareOp obj, const std::string& str, bool commaNeeded=true) {
2812      PRINT_SPACE
2813      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2814      if (commaNeeded)
2815          _OUT << "\"" <<  VkCompareOp_map[obj] << "\"," << std::endl;
2816      else
2817          _OUT << "\"" << VkCompareOp_map[obj] << "\"" << std::endl;
2818 }
2819 static void print_VkCompareOp(const VkCompareOp * obj, const std::string& str, bool commaNeeded=true) {
2820      PRINT_SPACE
2821      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2822      if (commaNeeded)
2823          _OUT << "\"" <<  VkCompareOp_map[*obj] << "\"," << std::endl;
2824      else
2825          _OUT << "\"" << VkCompareOp_map[*obj] << "\"" << std::endl;
2826 }
2827
2828 static std::map<deUint64, std::string> VkPipelineCreateFlagBits_map = {
2829     std::make_pair(1ULL << 0, "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"),
2830     std::make_pair(1ULL << 1, "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"),
2831     std::make_pair(1ULL << 3, "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"),
2832     std::make_pair(1ULL << 4, "VK_PIPELINE_CREATE_DISPATCH_BASE_BIT"),
2833     std::make_pair(1ULL << 21, "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"),
2834     std::make_pair(1ULL << 22, "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"),
2835     std::make_pair(1ULL << 14, "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"),
2836     std::make_pair(1ULL << 15, "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"),
2837     std::make_pair(1ULL << 16, "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"),
2838     std::make_pair(1ULL << 17, "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"),
2839     std::make_pair(1ULL << 12, "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"),
2840     std::make_pair(1ULL << 13, "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR"),
2841     std::make_pair(1ULL << 19, "VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"),
2842     std::make_pair(1ULL << 5, "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV"),
2843     std::make_pair(1ULL << 6, "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR"),
2844     std::make_pair(1ULL << 7, "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"),
2845     std::make_pair(1ULL << 18, "VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV"),
2846     std::make_pair(1ULL << 11, "VK_PIPELINE_CREATE_LIBRARY_BIT_KHR"),
2847     std::make_pair(1ULL << 8, "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT"),
2848     std::make_pair(1ULL << 9, "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT"),
2849     std::make_pair(1ULL << 23, "VK_PIPELINE_CREATE_RESERVED_23_BIT_AMD"),
2850     std::make_pair(1ULL << 10, "VK_PIPELINE_CREATE_RESERVED_10_BIT_AMD"),
2851     std::make_pair(1ULL << 20, "VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV"),
2852 };
2853 static void print_VkPipelineCreateFlagBits(VkPipelineCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
2854      PRINT_SPACE
2855      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2856      if (commaNeeded)
2857          _OUT << "\"" <<  VkPipelineCreateFlagBits_map[obj] << "\"," << std::endl;
2858      else
2859          _OUT << "\"" << VkPipelineCreateFlagBits_map[obj] << "\"" << std::endl;
2860 }
2861 static void print_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2862      PRINT_SPACE
2863      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2864      if (commaNeeded)
2865          _OUT << "\"" <<  VkPipelineCreateFlagBits_map[*obj] << "\"," << std::endl;
2866      else
2867          _OUT << "\"" << VkPipelineCreateFlagBits_map[*obj] << "\"" << std::endl;
2868 }
2869
2870 static std::map<deUint64, std::string> VkPipelineShaderStageCreateFlagBits_map = {
2871     std::make_pair(1ULL << 2, "VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_2_BIT_NV"),
2872     std::make_pair(1ULL << 0, "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT"),
2873     std::make_pair(1ULL << 1, "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT"),
2874     std::make_pair(1ULL << 3, "VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_3_BIT_KHR"),
2875 };
2876 static void print_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
2877      PRINT_SPACE
2878      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2879      if (commaNeeded)
2880          _OUT << "\"" <<  VkPipelineShaderStageCreateFlagBits_map[obj] << "\"," << std::endl;
2881      else
2882          _OUT << "\"" << VkPipelineShaderStageCreateFlagBits_map[obj] << "\"" << std::endl;
2883 }
2884 static void print_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2885      PRINT_SPACE
2886      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2887      if (commaNeeded)
2888          _OUT << "\"" <<  VkPipelineShaderStageCreateFlagBits_map[*obj] << "\"," << std::endl;
2889      else
2890          _OUT << "\"" << VkPipelineShaderStageCreateFlagBits_map[*obj] << "\"" << std::endl;
2891 }
2892
2893 static std::map<deUint64, std::string> VkShaderStageFlagBits_map = {
2894     std::make_pair(1ULL << 0, "VK_SHADER_STAGE_VERTEX_BIT"),
2895     std::make_pair(1ULL << 1, "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT"),
2896     std::make_pair(1ULL << 2, "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT"),
2897     std::make_pair(1ULL << 3, "VK_SHADER_STAGE_GEOMETRY_BIT"),
2898     std::make_pair(1ULL << 4, "VK_SHADER_STAGE_FRAGMENT_BIT"),
2899     std::make_pair(1ULL << 5, "VK_SHADER_STAGE_COMPUTE_BIT"),
2900     std::make_pair(0x0000001F, "VK_SHADER_STAGE_ALL_GRAPHICS"),
2901     std::make_pair(0x7FFFFFFF, "VK_SHADER_STAGE_ALL"),
2902     std::make_pair(1ULL << 8, "VK_SHADER_STAGE_RAYGEN_BIT_KHR"),
2903     std::make_pair(1ULL << 9, "VK_SHADER_STAGE_ANY_HIT_BIT_KHR"),
2904     std::make_pair(1ULL << 10, "VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR"),
2905     std::make_pair(1ULL << 11, "VK_SHADER_STAGE_MISS_BIT_KHR"),
2906     std::make_pair(1ULL << 12, "VK_SHADER_STAGE_INTERSECTION_BIT_KHR"),
2907     std::make_pair(1ULL << 13, "VK_SHADER_STAGE_CALLABLE_BIT_KHR"),
2908     std::make_pair(1ULL << 6, "VK_SHADER_STAGE_TASK_BIT_NV"),
2909     std::make_pair(1ULL << 7, "VK_SHADER_STAGE_MESH_BIT_NV"),
2910     std::make_pair(1ULL << 14, "VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI"),
2911 };
2912 static void print_VkShaderStageFlagBits(VkShaderStageFlagBits obj, const std::string& str, bool commaNeeded=true) {
2913      PRINT_SPACE
2914      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2915      if (commaNeeded)
2916          _OUT << "\"" <<  VkShaderStageFlagBits_map[obj] << "\"," << std::endl;
2917      else
2918          _OUT << "\"" << VkShaderStageFlagBits_map[obj] << "\"" << std::endl;
2919 }
2920 static void print_VkShaderStageFlagBits(const VkShaderStageFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2921      PRINT_SPACE
2922      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2923      if (commaNeeded)
2924          _OUT << "\"" <<  VkShaderStageFlagBits_map[*obj] << "\"," << std::endl;
2925      else
2926          _OUT << "\"" << VkShaderStageFlagBits_map[*obj] << "\"" << std::endl;
2927 }
2928
2929 static std::map<deUint64, std::string> VkCullModeFlagBits_map = {
2930     std::make_pair(0, "VK_CULL_MODE_NONE"),
2931     std::make_pair(1ULL << 0, "VK_CULL_MODE_FRONT_BIT"),
2932     std::make_pair(1ULL << 1, "VK_CULL_MODE_BACK_BIT"),
2933     std::make_pair(0x00000003, "VK_CULL_MODE_FRONT_AND_BACK"),
2934 };
2935 static void print_VkCullModeFlagBits(VkCullModeFlagBits obj, const std::string& str, bool commaNeeded=true) {
2936      PRINT_SPACE
2937      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2938      if (commaNeeded)
2939          _OUT << "\"" <<  VkCullModeFlagBits_map[obj] << "\"," << std::endl;
2940      else
2941          _OUT << "\"" << VkCullModeFlagBits_map[obj] << "\"" << std::endl;
2942 }
2943 static void print_VkCullModeFlagBits(const VkCullModeFlagBits * obj, const std::string& str, bool commaNeeded=true) {
2944      PRINT_SPACE
2945      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2946      if (commaNeeded)
2947          _OUT << "\"" <<  VkCullModeFlagBits_map[*obj] << "\"," << std::endl;
2948      else
2949          _OUT << "\"" << VkCullModeFlagBits_map[*obj] << "\"" << std::endl;
2950 }
2951
2952 static std::map<deUint64, std::string> VkDynamicState_map = {
2953     std::make_pair(0, "VK_DYNAMIC_STATE_VIEWPORT"),
2954     std::make_pair(1, "VK_DYNAMIC_STATE_SCISSOR"),
2955     std::make_pair(2, "VK_DYNAMIC_STATE_LINE_WIDTH"),
2956     std::make_pair(3, "VK_DYNAMIC_STATE_DEPTH_BIAS"),
2957     std::make_pair(4, "VK_DYNAMIC_STATE_BLEND_CONSTANTS"),
2958     std::make_pair(5, "VK_DYNAMIC_STATE_DEPTH_BOUNDS"),
2959     std::make_pair(6, "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK"),
2960     std::make_pair(7, "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK"),
2961     std::make_pair(8, "VK_DYNAMIC_STATE_STENCIL_REFERENCE"),
2962     std::make_pair(1000087000, "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV"),
2963     std::make_pair(1000099000, "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT"),
2964     std::make_pair(1000143000, "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT"),
2965     std::make_pair(1000347000, "VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR"),
2966     std::make_pair(1000164004, "VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV"),
2967     std::make_pair(1000164006, "VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV"),
2968     std::make_pair(1000205001, "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV"),
2969     std::make_pair(1000226000, "VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR"),
2970     std::make_pair(1000259000, "VK_DYNAMIC_STATE_LINE_STIPPLE_EXT"),
2971     std::make_pair(1000267000, "VK_DYNAMIC_STATE_CULL_MODE_EXT"),
2972     std::make_pair(1000267001, "VK_DYNAMIC_STATE_FRONT_FACE_EXT"),
2973     std::make_pair(1000267002, "VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT"),
2974     std::make_pair(1000267003, "VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT"),
2975     std::make_pair(1000267004, "VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT"),
2976     std::make_pair(1000267005, "VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT"),
2977     std::make_pair(1000267006, "VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT"),
2978     std::make_pair(1000267007, "VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT"),
2979     std::make_pair(1000267008, "VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT"),
2980     std::make_pair(1000267009, "VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT"),
2981     std::make_pair(1000267010, "VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT"),
2982     std::make_pair(1000267011, "VK_DYNAMIC_STATE_STENCIL_OP_EXT"),
2983     std::make_pair(1000352000, "VK_DYNAMIC_STATE_VERTEX_INPUT_EXT"),
2984     std::make_pair(1000377000, "VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT"),
2985     std::make_pair(1000377001, "VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT"),
2986     std::make_pair(1000377002, "VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT"),
2987     std::make_pair(1000377003, "VK_DYNAMIC_STATE_LOGIC_OP_EXT"),
2988     std::make_pair(1000377004, "VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT"),
2989     std::make_pair(1000381000, "VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT"),
2990 };
2991 static void print_VkDynamicState(VkDynamicState obj, const std::string& str, bool commaNeeded=true) {
2992      PRINT_SPACE
2993      if (str != "") _OUT << "\"" << str << "\"" << " : ";
2994      if (commaNeeded)
2995          _OUT << "\"" <<  VkDynamicState_map[obj] << "\"," << std::endl;
2996      else
2997          _OUT << "\"" << VkDynamicState_map[obj] << "\"" << std::endl;
2998 }
2999 static void print_VkDynamicState(const VkDynamicState * obj, const std::string& str, bool commaNeeded=true) {
3000      PRINT_SPACE
3001      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3002      if (commaNeeded)
3003          _OUT << "\"" <<  VkDynamicState_map[*obj] << "\"," << std::endl;
3004      else
3005          _OUT << "\"" << VkDynamicState_map[*obj] << "\"" << std::endl;
3006 }
3007
3008 static std::map<deUint64, std::string> VkFrontFace_map = {
3009     std::make_pair(0, "VK_FRONT_FACE_COUNTER_CLOCKWISE"),
3010     std::make_pair(1, "VK_FRONT_FACE_CLOCKWISE"),
3011 };
3012 static void print_VkFrontFace(VkFrontFace obj, const std::string& str, bool commaNeeded=true) {
3013      PRINT_SPACE
3014      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3015      if (commaNeeded)
3016          _OUT << "\"" <<  VkFrontFace_map[obj] << "\"," << std::endl;
3017      else
3018          _OUT << "\"" << VkFrontFace_map[obj] << "\"" << std::endl;
3019 }
3020 static void print_VkFrontFace(const VkFrontFace * obj, const std::string& str, bool commaNeeded=true) {
3021      PRINT_SPACE
3022      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3023      if (commaNeeded)
3024          _OUT << "\"" <<  VkFrontFace_map[*obj] << "\"," << std::endl;
3025      else
3026          _OUT << "\"" << VkFrontFace_map[*obj] << "\"" << std::endl;
3027 }
3028
3029 static std::map<deUint64, std::string> VkVertexInputRate_map = {
3030     std::make_pair(0, "VK_VERTEX_INPUT_RATE_VERTEX"),
3031     std::make_pair(1, "VK_VERTEX_INPUT_RATE_INSTANCE"),
3032 };
3033 static void print_VkVertexInputRate(VkVertexInputRate obj, const std::string& str, bool commaNeeded=true) {
3034      PRINT_SPACE
3035      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3036      if (commaNeeded)
3037          _OUT << "\"" <<  VkVertexInputRate_map[obj] << "\"," << std::endl;
3038      else
3039          _OUT << "\"" << VkVertexInputRate_map[obj] << "\"" << std::endl;
3040 }
3041 static void print_VkVertexInputRate(const VkVertexInputRate * obj, const std::string& str, bool commaNeeded=true) {
3042      PRINT_SPACE
3043      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3044      if (commaNeeded)
3045          _OUT << "\"" <<  VkVertexInputRate_map[*obj] << "\"," << std::endl;
3046      else
3047          _OUT << "\"" << VkVertexInputRate_map[*obj] << "\"" << std::endl;
3048 }
3049
3050 static std::map<deUint64, std::string> VkPrimitiveTopology_map = {
3051     std::make_pair(0, "VK_PRIMITIVE_TOPOLOGY_POINT_LIST"),
3052     std::make_pair(1, "VK_PRIMITIVE_TOPOLOGY_LINE_LIST"),
3053     std::make_pair(2, "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP"),
3054     std::make_pair(3, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST"),
3055     std::make_pair(4, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP"),
3056     std::make_pair(5, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN"),
3057     std::make_pair(6, "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY"),
3058     std::make_pair(7, "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY"),
3059     std::make_pair(8, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY"),
3060     std::make_pair(9, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY"),
3061     std::make_pair(10, "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST"),
3062 };
3063 static void print_VkPrimitiveTopology(VkPrimitiveTopology obj, const std::string& str, bool commaNeeded=true) {
3064      PRINT_SPACE
3065      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3066      if (commaNeeded)
3067          _OUT << "\"" <<  VkPrimitiveTopology_map[obj] << "\"," << std::endl;
3068      else
3069          _OUT << "\"" << VkPrimitiveTopology_map[obj] << "\"" << std::endl;
3070 }
3071 static void print_VkPrimitiveTopology(const VkPrimitiveTopology * obj, const std::string& str, bool commaNeeded=true) {
3072      PRINT_SPACE
3073      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3074      if (commaNeeded)
3075          _OUT << "\"" <<  VkPrimitiveTopology_map[*obj] << "\"," << std::endl;
3076      else
3077          _OUT << "\"" << VkPrimitiveTopology_map[*obj] << "\"" << std::endl;
3078 }
3079
3080 static std::map<deUint64, std::string> VkPolygonMode_map = {
3081     std::make_pair(0, "VK_POLYGON_MODE_FILL"),
3082     std::make_pair(1, "VK_POLYGON_MODE_LINE"),
3083     std::make_pair(2, "VK_POLYGON_MODE_POINT"),
3084     std::make_pair(1000153000, "VK_POLYGON_MODE_FILL_RECTANGLE_NV"),
3085 };
3086 static void print_VkPolygonMode(VkPolygonMode obj, const std::string& str, bool commaNeeded=true) {
3087      PRINT_SPACE
3088      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3089      if (commaNeeded)
3090          _OUT << "\"" <<  VkPolygonMode_map[obj] << "\"," << std::endl;
3091      else
3092          _OUT << "\"" << VkPolygonMode_map[obj] << "\"" << std::endl;
3093 }
3094 static void print_VkPolygonMode(const VkPolygonMode * obj, const std::string& str, bool commaNeeded=true) {
3095      PRINT_SPACE
3096      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3097      if (commaNeeded)
3098          _OUT << "\"" <<  VkPolygonMode_map[*obj] << "\"," << std::endl;
3099      else
3100          _OUT << "\"" << VkPolygonMode_map[*obj] << "\"" << std::endl;
3101 }
3102
3103 static std::map<deUint64, std::string> VkStencilOp_map = {
3104     std::make_pair(0, "VK_STENCIL_OP_KEEP"),
3105     std::make_pair(1, "VK_STENCIL_OP_ZERO"),
3106     std::make_pair(2, "VK_STENCIL_OP_REPLACE"),
3107     std::make_pair(3, "VK_STENCIL_OP_INCREMENT_AND_CLAMP"),
3108     std::make_pair(4, "VK_STENCIL_OP_DECREMENT_AND_CLAMP"),
3109     std::make_pair(5, "VK_STENCIL_OP_INVERT"),
3110     std::make_pair(6, "VK_STENCIL_OP_INCREMENT_AND_WRAP"),
3111     std::make_pair(7, "VK_STENCIL_OP_DECREMENT_AND_WRAP"),
3112 };
3113 static void print_VkStencilOp(VkStencilOp obj, const std::string& str, bool commaNeeded=true) {
3114      PRINT_SPACE
3115      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3116      if (commaNeeded)
3117          _OUT << "\"" <<  VkStencilOp_map[obj] << "\"," << std::endl;
3118      else
3119          _OUT << "\"" << VkStencilOp_map[obj] << "\"" << std::endl;
3120 }
3121 static void print_VkStencilOp(const VkStencilOp * obj, const std::string& str, bool commaNeeded=true) {
3122      PRINT_SPACE
3123      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3124      if (commaNeeded)
3125          _OUT << "\"" <<  VkStencilOp_map[*obj] << "\"," << std::endl;
3126      else
3127          _OUT << "\"" << VkStencilOp_map[*obj] << "\"" << std::endl;
3128 }
3129
3130 static std::map<deUint64, std::string> VkLogicOp_map = {
3131     std::make_pair(0, "VK_LOGIC_OP_CLEAR"),
3132     std::make_pair(1, "VK_LOGIC_OP_AND"),
3133     std::make_pair(2, "VK_LOGIC_OP_AND_REVERSE"),
3134     std::make_pair(3, "VK_LOGIC_OP_COPY"),
3135     std::make_pair(4, "VK_LOGIC_OP_AND_INVERTED"),
3136     std::make_pair(5, "VK_LOGIC_OP_NO_OP"),
3137     std::make_pair(6, "VK_LOGIC_OP_XOR"),
3138     std::make_pair(7, "VK_LOGIC_OP_OR"),
3139     std::make_pair(8, "VK_LOGIC_OP_NOR"),
3140     std::make_pair(9, "VK_LOGIC_OP_EQUIVALENT"),
3141     std::make_pair(10, "VK_LOGIC_OP_INVERT"),
3142     std::make_pair(11, "VK_LOGIC_OP_OR_REVERSE"),
3143     std::make_pair(12, "VK_LOGIC_OP_COPY_INVERTED"),
3144     std::make_pair(13, "VK_LOGIC_OP_OR_INVERTED"),
3145     std::make_pair(14, "VK_LOGIC_OP_NAND"),
3146     std::make_pair(15, "VK_LOGIC_OP_SET"),
3147 };
3148 static void print_VkLogicOp(VkLogicOp obj, const std::string& str, bool commaNeeded=true) {
3149      PRINT_SPACE
3150      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3151      if (commaNeeded)
3152          _OUT << "\"" <<  VkLogicOp_map[obj] << "\"," << std::endl;
3153      else
3154          _OUT << "\"" << VkLogicOp_map[obj] << "\"" << std::endl;
3155 }
3156 static void print_VkLogicOp(const VkLogicOp * obj, const std::string& str, bool commaNeeded=true) {
3157      PRINT_SPACE
3158      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3159      if (commaNeeded)
3160          _OUT << "\"" <<  VkLogicOp_map[*obj] << "\"," << std::endl;
3161      else
3162          _OUT << "\"" << VkLogicOp_map[*obj] << "\"" << std::endl;
3163 }
3164
3165 static std::map<deUint64, std::string> VkBorderColor_map = {
3166     std::make_pair(0, "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK"),
3167     std::make_pair(1, "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK"),
3168     std::make_pair(2, "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK"),
3169     std::make_pair(3, "VK_BORDER_COLOR_INT_OPAQUE_BLACK"),
3170     std::make_pair(4, "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE"),
3171     std::make_pair(5, "VK_BORDER_COLOR_INT_OPAQUE_WHITE"),
3172     std::make_pair(1000287003, "VK_BORDER_COLOR_FLOAT_CUSTOM_EXT"),
3173     std::make_pair(1000287004, "VK_BORDER_COLOR_INT_CUSTOM_EXT"),
3174 };
3175 static void print_VkBorderColor(VkBorderColor obj, const std::string& str, bool commaNeeded=true) {
3176      PRINT_SPACE
3177      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3178      if (commaNeeded)
3179          _OUT << "\"" <<  VkBorderColor_map[obj] << "\"," << std::endl;
3180      else
3181          _OUT << "\"" << VkBorderColor_map[obj] << "\"" << std::endl;
3182 }
3183 static void print_VkBorderColor(const VkBorderColor * obj, const std::string& str, bool commaNeeded=true) {
3184      PRINT_SPACE
3185      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3186      if (commaNeeded)
3187          _OUT << "\"" <<  VkBorderColor_map[*obj] << "\"," << std::endl;
3188      else
3189          _OUT << "\"" << VkBorderColor_map[*obj] << "\"" << std::endl;
3190 }
3191
3192 static std::map<deUint64, std::string> VkFilter_map = {
3193     std::make_pair(0, "VK_FILTER_NEAREST"),
3194     std::make_pair(1, "VK_FILTER_LINEAR"),
3195     std::make_pair(1000015000, "VK_FILTER_CUBIC_IMG"),
3196 };
3197 static void print_VkFilter(VkFilter obj, const std::string& str, bool commaNeeded=true) {
3198      PRINT_SPACE
3199      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3200      if (commaNeeded)
3201          _OUT << "\"" <<  VkFilter_map[obj] << "\"," << std::endl;
3202      else
3203          _OUT << "\"" << VkFilter_map[obj] << "\"" << std::endl;
3204 }
3205 static void print_VkFilter(const VkFilter * obj, const std::string& str, bool commaNeeded=true) {
3206      PRINT_SPACE
3207      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3208      if (commaNeeded)
3209          _OUT << "\"" <<  VkFilter_map[*obj] << "\"," << std::endl;
3210      else
3211          _OUT << "\"" << VkFilter_map[*obj] << "\"" << std::endl;
3212 }
3213
3214 static std::map<deUint64, std::string> VkSamplerAddressMode_map = {
3215     std::make_pair(0, "VK_SAMPLER_ADDRESS_MODE_REPEAT"),
3216     std::make_pair(1, "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT"),
3217     std::make_pair(2, "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE"),
3218     std::make_pair(3, "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER"),
3219     std::make_pair(4, "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE"),
3220     std::make_pair(4, "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE"),
3221 };
3222 static void print_VkSamplerAddressMode(VkSamplerAddressMode obj, const std::string& str, bool commaNeeded=true) {
3223      PRINT_SPACE
3224      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3225      if (commaNeeded)
3226          _OUT << "\"" <<  VkSamplerAddressMode_map[obj] << "\"," << std::endl;
3227      else
3228          _OUT << "\"" << VkSamplerAddressMode_map[obj] << "\"" << std::endl;
3229 }
3230 static void print_VkSamplerAddressMode(const VkSamplerAddressMode * obj, const std::string& str, bool commaNeeded=true) {
3231      PRINT_SPACE
3232      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3233      if (commaNeeded)
3234          _OUT << "\"" <<  VkSamplerAddressMode_map[*obj] << "\"," << std::endl;
3235      else
3236          _OUT << "\"" << VkSamplerAddressMode_map[*obj] << "\"" << std::endl;
3237 }
3238
3239 static std::map<deUint64, std::string> VkSamplerCreateFlagBits_map = {
3240     std::make_pair(1ULL << 0, "VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT"),
3241     std::make_pair(1ULL << 1, "VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT"),
3242     std::make_pair(1ULL << 3, "VK_SAMPLER_CREATE_RESERVED_3_BIT_AMD"),
3243     std::make_pair(1ULL << 2, "VK_SAMPLER_CREATE_RESERVED_2_BIT_EXT"),
3244 };
3245 static void print_VkSamplerCreateFlagBits(VkSamplerCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
3246      PRINT_SPACE
3247      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3248      if (commaNeeded)
3249          _OUT << "\"" <<  VkSamplerCreateFlagBits_map[obj] << "\"," << std::endl;
3250      else
3251          _OUT << "\"" << VkSamplerCreateFlagBits_map[obj] << "\"" << std::endl;
3252 }
3253 static void print_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3254      PRINT_SPACE
3255      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3256      if (commaNeeded)
3257          _OUT << "\"" <<  VkSamplerCreateFlagBits_map[*obj] << "\"," << std::endl;
3258      else
3259          _OUT << "\"" << VkSamplerCreateFlagBits_map[*obj] << "\"" << std::endl;
3260 }
3261
3262 static std::map<deUint64, std::string> VkSamplerMipmapMode_map = {
3263     std::make_pair(0, "VK_SAMPLER_MIPMAP_MODE_NEAREST"),
3264     std::make_pair(1, "VK_SAMPLER_MIPMAP_MODE_LINEAR"),
3265 };
3266 static void print_VkSamplerMipmapMode(VkSamplerMipmapMode obj, const std::string& str, bool commaNeeded=true) {
3267      PRINT_SPACE
3268      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3269      if (commaNeeded)
3270          _OUT << "\"" <<  VkSamplerMipmapMode_map[obj] << "\"," << std::endl;
3271      else
3272          _OUT << "\"" << VkSamplerMipmapMode_map[obj] << "\"" << std::endl;
3273 }
3274 static void print_VkSamplerMipmapMode(const VkSamplerMipmapMode * obj, const std::string& str, bool commaNeeded=true) {
3275      PRINT_SPACE
3276      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3277      if (commaNeeded)
3278          _OUT << "\"" <<  VkSamplerMipmapMode_map[*obj] << "\"," << std::endl;
3279      else
3280          _OUT << "\"" << VkSamplerMipmapMode_map[*obj] << "\"" << std::endl;
3281 }
3282
3283 static std::map<deUint64, std::string> VkDescriptorPoolCreateFlagBits_map = {
3284     std::make_pair(1ULL << 0, "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT"),
3285     std::make_pair(1ULL << 1, "VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT"),
3286     std::make_pair(1ULL << 2, "VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE"),
3287 };
3288 static void print_VkDescriptorPoolCreateFlagBits(VkDescriptorPoolCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
3289      PRINT_SPACE
3290      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3291      if (commaNeeded)
3292          _OUT << "\"" <<  VkDescriptorPoolCreateFlagBits_map[obj] << "\"," << std::endl;
3293      else
3294          _OUT << "\"" << VkDescriptorPoolCreateFlagBits_map[obj] << "\"" << std::endl;
3295 }
3296 static void print_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3297      PRINT_SPACE
3298      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3299      if (commaNeeded)
3300          _OUT << "\"" <<  VkDescriptorPoolCreateFlagBits_map[*obj] << "\"," << std::endl;
3301      else
3302          _OUT << "\"" << VkDescriptorPoolCreateFlagBits_map[*obj] << "\"" << std::endl;
3303 }
3304
3305 static std::map<deUint64, std::string> VkDescriptorType_map = {
3306     std::make_pair(0, "VK_DESCRIPTOR_TYPE_SAMPLER"),
3307     std::make_pair(1, "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER"),
3308     std::make_pair(2, "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE"),
3309     std::make_pair(3, "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"),
3310     std::make_pair(4, "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER"),
3311     std::make_pair(5, "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER"),
3312     std::make_pair(6, "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER"),
3313     std::make_pair(7, "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER"),
3314     std::make_pair(8, "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC"),
3315     std::make_pair(9, "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC"),
3316     std::make_pair(10, "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT"),
3317     std::make_pair(1000138000, "VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT"),
3318     std::make_pair(1000150000, "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR"),
3319     std::make_pair(1000165000, "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV"),
3320     std::make_pair(1000351000, "VK_DESCRIPTOR_TYPE_MUTABLE_VALVE"),
3321 };
3322 static void print_VkDescriptorType(VkDescriptorType obj, const std::string& str, bool commaNeeded=true) {
3323      PRINT_SPACE
3324      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3325      if (commaNeeded)
3326          _OUT << "\"" <<  VkDescriptorType_map[obj] << "\"," << std::endl;
3327      else
3328          _OUT << "\"" << VkDescriptorType_map[obj] << "\"" << std::endl;
3329 }
3330 static void print_VkDescriptorType(const VkDescriptorType * obj, const std::string& str, bool commaNeeded=true) {
3331      PRINT_SPACE
3332      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3333      if (commaNeeded)
3334          _OUT << "\"" <<  VkDescriptorType_map[*obj] << "\"," << std::endl;
3335      else
3336          _OUT << "\"" << VkDescriptorType_map[*obj] << "\"" << std::endl;
3337 }
3338
3339 static std::map<deUint64, std::string> VkDescriptorSetLayoutCreateFlagBits_map = {
3340     std::make_pair(1ULL << 1, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT"),
3341     std::make_pair(1ULL << 0, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR"),
3342     std::make_pair(1ULL << 4, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_4_BIT_AMD"),
3343     std::make_pair(1ULL << 3, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_3_BIT_AMD"),
3344     std::make_pair(1ULL << 2, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE"),
3345 };
3346 static void print_VkDescriptorSetLayoutCreateFlagBits(VkDescriptorSetLayoutCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
3347      PRINT_SPACE
3348      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3349      if (commaNeeded)
3350          _OUT << "\"" <<  VkDescriptorSetLayoutCreateFlagBits_map[obj] << "\"," << std::endl;
3351      else
3352          _OUT << "\"" << VkDescriptorSetLayoutCreateFlagBits_map[obj] << "\"" << std::endl;
3353 }
3354 static void print_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3355      PRINT_SPACE
3356      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3357      if (commaNeeded)
3358          _OUT << "\"" <<  VkDescriptorSetLayoutCreateFlagBits_map[*obj] << "\"," << std::endl;
3359      else
3360          _OUT << "\"" << VkDescriptorSetLayoutCreateFlagBits_map[*obj] << "\"" << std::endl;
3361 }
3362
3363 static std::map<deUint64, std::string> VkAttachmentDescriptionFlagBits_map = {
3364     std::make_pair(1ULL << 0, "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT"),
3365 };
3366 static void print_VkAttachmentDescriptionFlagBits(VkAttachmentDescriptionFlagBits obj, const std::string& str, bool commaNeeded=true) {
3367      PRINT_SPACE
3368      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3369      if (commaNeeded)
3370          _OUT << "\"" <<  VkAttachmentDescriptionFlagBits_map[obj] << "\"," << std::endl;
3371      else
3372          _OUT << "\"" << VkAttachmentDescriptionFlagBits_map[obj] << "\"" << std::endl;
3373 }
3374 static void print_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3375      PRINT_SPACE
3376      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3377      if (commaNeeded)
3378          _OUT << "\"" <<  VkAttachmentDescriptionFlagBits_map[*obj] << "\"," << std::endl;
3379      else
3380          _OUT << "\"" << VkAttachmentDescriptionFlagBits_map[*obj] << "\"" << std::endl;
3381 }
3382
3383 static std::map<deUint64, std::string> VkAttachmentLoadOp_map = {
3384     std::make_pair(0, "VK_ATTACHMENT_LOAD_OP_LOAD"),
3385     std::make_pair(1, "VK_ATTACHMENT_LOAD_OP_CLEAR"),
3386     std::make_pair(2, "VK_ATTACHMENT_LOAD_OP_DONT_CARE"),
3387     std::make_pair(1000400000, "VK_ATTACHMENT_LOAD_OP_NONE_EXT"),
3388 };
3389 static void print_VkAttachmentLoadOp(VkAttachmentLoadOp obj, const std::string& str, bool commaNeeded=true) {
3390      PRINT_SPACE
3391      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3392      if (commaNeeded)
3393          _OUT << "\"" <<  VkAttachmentLoadOp_map[obj] << "\"," << std::endl;
3394      else
3395          _OUT << "\"" << VkAttachmentLoadOp_map[obj] << "\"" << std::endl;
3396 }
3397 static void print_VkAttachmentLoadOp(const VkAttachmentLoadOp * obj, const std::string& str, bool commaNeeded=true) {
3398      PRINT_SPACE
3399      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3400      if (commaNeeded)
3401          _OUT << "\"" <<  VkAttachmentLoadOp_map[*obj] << "\"," << std::endl;
3402      else
3403          _OUT << "\"" << VkAttachmentLoadOp_map[*obj] << "\"" << std::endl;
3404 }
3405
3406 static std::map<deUint64, std::string> VkAttachmentStoreOp_map = {
3407     std::make_pair(0, "VK_ATTACHMENT_STORE_OP_STORE"),
3408     std::make_pair(1, "VK_ATTACHMENT_STORE_OP_DONT_CARE"),
3409     std::make_pair(1000301000, "VK_ATTACHMENT_STORE_OP_NONE_KHR"),
3410 };
3411 static void print_VkAttachmentStoreOp(VkAttachmentStoreOp obj, const std::string& str, bool commaNeeded=true) {
3412      PRINT_SPACE
3413      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3414      if (commaNeeded)
3415          _OUT << "\"" <<  VkAttachmentStoreOp_map[obj] << "\"," << std::endl;
3416      else
3417          _OUT << "\"" << VkAttachmentStoreOp_map[obj] << "\"" << std::endl;
3418 }
3419 static void print_VkAttachmentStoreOp(const VkAttachmentStoreOp * obj, const std::string& str, bool commaNeeded=true) {
3420      PRINT_SPACE
3421      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3422      if (commaNeeded)
3423          _OUT << "\"" <<  VkAttachmentStoreOp_map[*obj] << "\"," << std::endl;
3424      else
3425          _OUT << "\"" << VkAttachmentStoreOp_map[*obj] << "\"" << std::endl;
3426 }
3427
3428 static std::map<deUint64, std::string> VkDependencyFlagBits_map = {
3429     std::make_pair(1ULL << 0, "VK_DEPENDENCY_BY_REGION_BIT"),
3430     std::make_pair(1ULL << 2, "VK_DEPENDENCY_DEVICE_GROUP_BIT"),
3431     std::make_pair(1ULL << 1, "VK_DEPENDENCY_VIEW_LOCAL_BIT"),
3432 };
3433 static void print_VkDependencyFlagBits(VkDependencyFlagBits obj, const std::string& str, bool commaNeeded=true) {
3434      PRINT_SPACE
3435      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3436      if (commaNeeded)
3437          _OUT << "\"" <<  VkDependencyFlagBits_map[obj] << "\"," << std::endl;
3438      else
3439          _OUT << "\"" << VkDependencyFlagBits_map[obj] << "\"" << std::endl;
3440 }
3441 static void print_VkDependencyFlagBits(const VkDependencyFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3442      PRINT_SPACE
3443      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3444      if (commaNeeded)
3445          _OUT << "\"" <<  VkDependencyFlagBits_map[*obj] << "\"," << std::endl;
3446      else
3447          _OUT << "\"" << VkDependencyFlagBits_map[*obj] << "\"" << std::endl;
3448 }
3449
3450 static std::map<deUint64, std::string> VkFramebufferCreateFlagBits_map = {
3451     std::make_pair(1ULL << 0, "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT"),
3452 };
3453 static void print_VkFramebufferCreateFlagBits(VkFramebufferCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
3454      PRINT_SPACE
3455      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3456      if (commaNeeded)
3457          _OUT << "\"" <<  VkFramebufferCreateFlagBits_map[obj] << "\"," << std::endl;
3458      else
3459          _OUT << "\"" << VkFramebufferCreateFlagBits_map[obj] << "\"" << std::endl;
3460 }
3461 static void print_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3462      PRINT_SPACE
3463      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3464      if (commaNeeded)
3465          _OUT << "\"" <<  VkFramebufferCreateFlagBits_map[*obj] << "\"," << std::endl;
3466      else
3467          _OUT << "\"" << VkFramebufferCreateFlagBits_map[*obj] << "\"" << std::endl;
3468 }
3469
3470 static std::map<deUint64, std::string> VkPipelineBindPoint_map = {
3471     std::make_pair(0, "VK_PIPELINE_BIND_POINT_GRAPHICS"),
3472     std::make_pair(1, "VK_PIPELINE_BIND_POINT_COMPUTE"),
3473     std::make_pair(1000165000, "VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR"),
3474     std::make_pair(1000369003, "VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI"),
3475 };
3476 static void print_VkPipelineBindPoint(VkPipelineBindPoint obj, const std::string& str, bool commaNeeded=true) {
3477      PRINT_SPACE
3478      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3479      if (commaNeeded)
3480          _OUT << "\"" <<  VkPipelineBindPoint_map[obj] << "\"," << std::endl;
3481      else
3482          _OUT << "\"" << VkPipelineBindPoint_map[obj] << "\"" << std::endl;
3483 }
3484 static void print_VkPipelineBindPoint(const VkPipelineBindPoint * obj, const std::string& str, bool commaNeeded=true) {
3485      PRINT_SPACE
3486      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3487      if (commaNeeded)
3488          _OUT << "\"" <<  VkPipelineBindPoint_map[*obj] << "\"," << std::endl;
3489      else
3490          _OUT << "\"" << VkPipelineBindPoint_map[*obj] << "\"" << std::endl;
3491 }
3492
3493 static std::map<deUint64, std::string> VkRenderPassCreateFlagBits_map = {
3494     std::make_pair(1ULL << 0, "VK_RENDER_PASS_CREATE_RESERVED_0_BIT_KHR"),
3495     std::make_pair(1ULL << 1, "VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM"),
3496 };
3497 static void print_VkRenderPassCreateFlagBits(VkRenderPassCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
3498      PRINT_SPACE
3499      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3500      if (commaNeeded)
3501          _OUT << "\"" <<  VkRenderPassCreateFlagBits_map[obj] << "\"," << std::endl;
3502      else
3503          _OUT << "\"" << VkRenderPassCreateFlagBits_map[obj] << "\"" << std::endl;
3504 }
3505 static void print_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3506      PRINT_SPACE
3507      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3508      if (commaNeeded)
3509          _OUT << "\"" <<  VkRenderPassCreateFlagBits_map[*obj] << "\"," << std::endl;
3510      else
3511          _OUT << "\"" << VkRenderPassCreateFlagBits_map[*obj] << "\"" << std::endl;
3512 }
3513
3514 static std::map<deUint64, std::string> VkSubpassDescriptionFlagBits_map = {
3515     std::make_pair(1ULL << 0, "VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX"),
3516     std::make_pair(1ULL << 1, "VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX"),
3517     std::make_pair(1ULL << 2, "VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM"),
3518     std::make_pair(1ULL << 3, "VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM"),
3519     std::make_pair(1ULL << 4, "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM"),
3520     std::make_pair(1ULL << 5, "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM"),
3521     std::make_pair(1ULL << 6, "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM"),
3522 };
3523 static void print_VkSubpassDescriptionFlagBits(VkSubpassDescriptionFlagBits obj, const std::string& str, bool commaNeeded=true) {
3524      PRINT_SPACE
3525      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3526      if (commaNeeded)
3527          _OUT << "\"" <<  VkSubpassDescriptionFlagBits_map[obj] << "\"," << std::endl;
3528      else
3529          _OUT << "\"" << VkSubpassDescriptionFlagBits_map[obj] << "\"" << std::endl;
3530 }
3531 static void print_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3532      PRINT_SPACE
3533      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3534      if (commaNeeded)
3535          _OUT << "\"" <<  VkSubpassDescriptionFlagBits_map[*obj] << "\"," << std::endl;
3536      else
3537          _OUT << "\"" << VkSubpassDescriptionFlagBits_map[*obj] << "\"" << std::endl;
3538 }
3539
3540 static std::map<deUint64, std::string> VkCommandPoolCreateFlagBits_map = {
3541     std::make_pair(1ULL << 0, "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT"),
3542     std::make_pair(1ULL << 1, "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT"),
3543     std::make_pair(1ULL << 2, "VK_COMMAND_POOL_CREATE_PROTECTED_BIT"),
3544 };
3545 static void print_VkCommandPoolCreateFlagBits(VkCommandPoolCreateFlagBits obj, const std::string& str, bool commaNeeded=true) {
3546      PRINT_SPACE
3547      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3548      if (commaNeeded)
3549          _OUT << "\"" <<  VkCommandPoolCreateFlagBits_map[obj] << "\"," << std::endl;
3550      else
3551          _OUT << "\"" << VkCommandPoolCreateFlagBits_map[obj] << "\"" << std::endl;
3552 }
3553 static void print_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3554      PRINT_SPACE
3555      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3556      if (commaNeeded)
3557          _OUT << "\"" <<  VkCommandPoolCreateFlagBits_map[*obj] << "\"," << std::endl;
3558      else
3559          _OUT << "\"" << VkCommandPoolCreateFlagBits_map[*obj] << "\"" << std::endl;
3560 }
3561
3562 static std::map<deUint64, std::string> VkCommandPoolResetFlagBits_map = {
3563     std::make_pair(1ULL << 1, "VK_COMMAND_POOL_RESET_RESERVED_1_BIT_COREAVI"),
3564 };
3565 static void print_VkCommandPoolResetFlagBits(VkCommandPoolResetFlagBits obj, const std::string& str, bool commaNeeded=true) {
3566      PRINT_SPACE
3567      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3568      if (commaNeeded)
3569          _OUT << "\"" <<  VkCommandPoolResetFlagBits_map[obj] << "\"," << std::endl;
3570      else
3571          _OUT << "\"" << VkCommandPoolResetFlagBits_map[obj] << "\"" << std::endl;
3572 }
3573 static void print_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3574      PRINT_SPACE
3575      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3576      if (commaNeeded)
3577          _OUT << "\"" <<  VkCommandPoolResetFlagBits_map[*obj] << "\"," << std::endl;
3578      else
3579          _OUT << "\"" << VkCommandPoolResetFlagBits_map[*obj] << "\"" << std::endl;
3580 }
3581
3582 static std::map<deUint64, std::string> VkCommandBufferLevel_map = {
3583     std::make_pair(0, "VK_COMMAND_BUFFER_LEVEL_PRIMARY"),
3584     std::make_pair(1, "VK_COMMAND_BUFFER_LEVEL_SECONDARY"),
3585 };
3586 static void print_VkCommandBufferLevel(VkCommandBufferLevel obj, const std::string& str, bool commaNeeded=true) {
3587      PRINT_SPACE
3588      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3589      if (commaNeeded)
3590          _OUT << "\"" <<  VkCommandBufferLevel_map[obj] << "\"," << std::endl;
3591      else
3592          _OUT << "\"" << VkCommandBufferLevel_map[obj] << "\"" << std::endl;
3593 }
3594 static void print_VkCommandBufferLevel(const VkCommandBufferLevel * obj, const std::string& str, bool commaNeeded=true) {
3595      PRINT_SPACE
3596      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3597      if (commaNeeded)
3598          _OUT << "\"" <<  VkCommandBufferLevel_map[*obj] << "\"," << std::endl;
3599      else
3600          _OUT << "\"" << VkCommandBufferLevel_map[*obj] << "\"" << std::endl;
3601 }
3602
3603 static std::map<deUint64, std::string> VkCommandBufferUsageFlagBits_map = {
3604     std::make_pair(1ULL << 0, "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT"),
3605     std::make_pair(1ULL << 1, "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT"),
3606     std::make_pair(1ULL << 2, "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT"),
3607 };
3608 static void print_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits obj, const std::string& str, bool commaNeeded=true) {
3609      PRINT_SPACE
3610      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3611      if (commaNeeded)
3612          _OUT << "\"" <<  VkCommandBufferUsageFlagBits_map[obj] << "\"," << std::endl;
3613      else
3614          _OUT << "\"" << VkCommandBufferUsageFlagBits_map[obj] << "\"" << std::endl;
3615 }
3616 static void print_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3617      PRINT_SPACE
3618      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3619      if (commaNeeded)
3620          _OUT << "\"" <<  VkCommandBufferUsageFlagBits_map[*obj] << "\"," << std::endl;
3621      else
3622          _OUT << "\"" << VkCommandBufferUsageFlagBits_map[*obj] << "\"" << std::endl;
3623 }
3624
3625 static std::map<deUint64, std::string> VkQueryControlFlagBits_map = {
3626     std::make_pair(1ULL << 0, "VK_QUERY_CONTROL_PRECISE_BIT"),
3627 };
3628 static void print_VkQueryControlFlagBits(VkQueryControlFlagBits obj, const std::string& str, bool commaNeeded=true) {
3629      PRINT_SPACE
3630      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3631      if (commaNeeded)
3632          _OUT << "\"" <<  VkQueryControlFlagBits_map[obj] << "\"," << std::endl;
3633      else
3634          _OUT << "\"" << VkQueryControlFlagBits_map[obj] << "\"" << std::endl;
3635 }
3636 static void print_VkQueryControlFlagBits(const VkQueryControlFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3637      PRINT_SPACE
3638      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3639      if (commaNeeded)
3640          _OUT << "\"" <<  VkQueryControlFlagBits_map[*obj] << "\"," << std::endl;
3641      else
3642          _OUT << "\"" << VkQueryControlFlagBits_map[*obj] << "\"" << std::endl;
3643 }
3644
3645 static std::map<deUint64, std::string> VkCommandBufferResetFlagBits_map = {
3646     std::make_pair(1ULL << 0, "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT"),
3647 };
3648 static void print_VkCommandBufferResetFlagBits(VkCommandBufferResetFlagBits obj, const std::string& str, bool commaNeeded=true) {
3649      PRINT_SPACE
3650      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3651      if (commaNeeded)
3652          _OUT << "\"" <<  VkCommandBufferResetFlagBits_map[obj] << "\"," << std::endl;
3653      else
3654          _OUT << "\"" << VkCommandBufferResetFlagBits_map[obj] << "\"" << std::endl;
3655 }
3656 static void print_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3657      PRINT_SPACE
3658      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3659      if (commaNeeded)
3660          _OUT << "\"" <<  VkCommandBufferResetFlagBits_map[*obj] << "\"," << std::endl;
3661      else
3662          _OUT << "\"" << VkCommandBufferResetFlagBits_map[*obj] << "\"" << std::endl;
3663 }
3664
3665 static std::map<deUint64, std::string> VkIndexType_map = {
3666     std::make_pair(0, "VK_INDEX_TYPE_UINT16"),
3667     std::make_pair(1, "VK_INDEX_TYPE_UINT32"),
3668     std::make_pair(1000165000, "VK_INDEX_TYPE_NONE_KHR"),
3669     std::make_pair(1000265000, "VK_INDEX_TYPE_UINT8_EXT"),
3670 };
3671 static void print_VkIndexType(VkIndexType obj, const std::string& str, bool commaNeeded=true) {
3672      PRINT_SPACE
3673      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3674      if (commaNeeded)
3675          _OUT << "\"" <<  VkIndexType_map[obj] << "\"," << std::endl;
3676      else
3677          _OUT << "\"" << VkIndexType_map[obj] << "\"" << std::endl;
3678 }
3679 static void print_VkIndexType(const VkIndexType * obj, const std::string& str, bool commaNeeded=true) {
3680      PRINT_SPACE
3681      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3682      if (commaNeeded)
3683          _OUT << "\"" <<  VkIndexType_map[*obj] << "\"," << std::endl;
3684      else
3685          _OUT << "\"" << VkIndexType_map[*obj] << "\"" << std::endl;
3686 }
3687
3688 static std::map<deUint64, std::string> VkStencilFaceFlagBits_map = {
3689     std::make_pair(1ULL << 0, "VK_STENCIL_FACE_FRONT_BIT"),
3690     std::make_pair(1ULL << 1, "VK_STENCIL_FACE_BACK_BIT"),
3691     std::make_pair(0x00000003, "VK_STENCIL_FACE_FRONT_AND_BACK"),
3692 };
3693 static void print_VkStencilFaceFlagBits(VkStencilFaceFlagBits obj, const std::string& str, bool commaNeeded=true) {
3694      PRINT_SPACE
3695      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3696      if (commaNeeded)
3697          _OUT << "\"" <<  VkStencilFaceFlagBits_map[obj] << "\"," << std::endl;
3698      else
3699          _OUT << "\"" << VkStencilFaceFlagBits_map[obj] << "\"" << std::endl;
3700 }
3701 static void print_VkStencilFaceFlagBits(const VkStencilFaceFlagBits * obj, const std::string& str, bool commaNeeded=true) {
3702      PRINT_SPACE
3703      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3704      if (commaNeeded)
3705          _OUT << "\"" <<  VkStencilFaceFlagBits_map[*obj] << "\"," << std::endl;
3706      else
3707          _OUT << "\"" << VkStencilFaceFlagBits_map[*obj] << "\"" << std::endl;
3708 }
3709
3710 static std::map<deUint64, std::string> VkSubpassContents_map = {
3711     std::make_pair(0, "VK_SUBPASS_CONTENTS_INLINE"),
3712     std::make_pair(1, "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS"),
3713 };
3714 static void print_VkSubpassContents(VkSubpassContents obj, const std::string& str, bool commaNeeded=true) {
3715      PRINT_SPACE
3716      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3717      if (commaNeeded)
3718          _OUT << "\"" <<  VkSubpassContents_map[obj] << "\"," << std::endl;
3719      else
3720          _OUT << "\"" << VkSubpassContents_map[obj] << "\"" << std::endl;
3721 }
3722 static void print_VkSubpassContents(const VkSubpassContents * obj, const std::string& str, bool commaNeeded=true) {
3723      PRINT_SPACE
3724      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3725      if (commaNeeded)
3726          _OUT << "\"" <<  VkSubpassContents_map[*obj] << "\"," << std::endl;
3727      else
3728          _OUT << "\"" << VkSubpassContents_map[*obj] << "\"" << std::endl;
3729 }
3730
3731 static void print_VkAccessFlags(VkAccessFlags obj, const std::string& str, bool commaNeeded=true) {
3732      PRINT_SPACE
3733      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3734      const int max_bits = 64; // We don't expect the number to be larger.
3735      std::bitset<max_bits> b(obj);
3736      _OUT << "\"";
3737      if (obj == 0) _OUT << "0";
3738      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
3739          if (b[i] == 1) {
3740              bitCount++;
3741              if (bitCount < b.count())
3742                  _OUT << VkAccessFlagBits_map[1ULL<<i] << " | ";
3743              else
3744                  _OUT << VkAccessFlagBits_map[1ULL<<i];
3745          }
3746      }
3747      if (commaNeeded)
3748        _OUT << "\"" << ",";
3749      else
3750        _OUT << "\""<< "";
3751      _OUT << std::endl;
3752 }
3753 static void print_VkAccessFlags(const VkAccessFlags * obj, const std::string& str, bool commaNeeded=true) {
3754      PRINT_SPACE
3755      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3756      const int max_bits = 64; // We don't expect the number to be larger.
3757      std::bitset<max_bits> b(obj);
3758      _OUT << "\"";
3759      if (obj == 0) _OUT << "0";
3760      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
3761          if (b[i] == 1) {
3762              bitCount++;
3763              if (bitCount < b.count())
3764                  _OUT << VkAccessFlagBits_map[1ULL<<i] << " | ";
3765              else
3766                  _OUT << VkAccessFlagBits_map[1ULL<<i];
3767          }
3768      }
3769      if (commaNeeded)
3770        _OUT << "\"" << ",";
3771      else
3772        _OUT << "\""<< "";
3773      _OUT << std::endl;
3774 }
3775
3776 static void print_VkImageAspectFlags(VkImageAspectFlags obj, const std::string& str, bool commaNeeded=true) {
3777      PRINT_SPACE
3778      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3779      const int max_bits = 64; // We don't expect the number to be larger.
3780      std::bitset<max_bits> b(obj);
3781      _OUT << "\"";
3782      if (obj == 0) _OUT << "0";
3783      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
3784          if (b[i] == 1) {
3785              bitCount++;
3786              if (bitCount < b.count())
3787                  _OUT << VkImageAspectFlagBits_map[1ULL<<i] << " | ";
3788              else
3789                  _OUT << VkImageAspectFlagBits_map[1ULL<<i];
3790          }
3791      }
3792      if (commaNeeded)
3793        _OUT << "\"" << ",";
3794      else
3795        _OUT << "\""<< "";
3796      _OUT << std::endl;
3797 }
3798 static void print_VkImageAspectFlags(const VkImageAspectFlags * obj, const std::string& str, bool commaNeeded=true) {
3799      PRINT_SPACE
3800      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3801      const int max_bits = 64; // We don't expect the number to be larger.
3802      std::bitset<max_bits> b(obj);
3803      _OUT << "\"";
3804      if (obj == 0) _OUT << "0";
3805      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
3806          if (b[i] == 1) {
3807              bitCount++;
3808              if (bitCount < b.count())
3809                  _OUT << VkImageAspectFlagBits_map[1ULL<<i] << " | ";
3810              else
3811                  _OUT << VkImageAspectFlagBits_map[1ULL<<i];
3812          }
3813      }
3814      if (commaNeeded)
3815        _OUT << "\"" << ",";
3816      else
3817        _OUT << "\""<< "";
3818      _OUT << std::endl;
3819 }
3820
3821 static void print_VkFormatFeatureFlags(VkFormatFeatureFlags obj, const std::string& str, bool commaNeeded=true) {
3822      PRINT_SPACE
3823      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3824      const int max_bits = 64; // We don't expect the number to be larger.
3825      std::bitset<max_bits> b(obj);
3826      _OUT << "\"";
3827      if (obj == 0) _OUT << "0";
3828      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
3829          if (b[i] == 1) {
3830              bitCount++;
3831              if (bitCount < b.count())
3832                  _OUT << VkFormatFeatureFlagBits_map[1ULL<<i] << " | ";
3833              else
3834                  _OUT << VkFormatFeatureFlagBits_map[1ULL<<i];
3835          }
3836      }
3837      if (commaNeeded)
3838        _OUT << "\"" << ",";
3839      else
3840        _OUT << "\""<< "";
3841      _OUT << std::endl;
3842 }
3843 static void print_VkFormatFeatureFlags(const VkFormatFeatureFlags * obj, const std::string& str, bool commaNeeded=true) {
3844      PRINT_SPACE
3845      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3846      const int max_bits = 64; // We don't expect the number to be larger.
3847      std::bitset<max_bits> b(obj);
3848      _OUT << "\"";
3849      if (obj == 0) _OUT << "0";
3850      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
3851          if (b[i] == 1) {
3852              bitCount++;
3853              if (bitCount < b.count())
3854                  _OUT << VkFormatFeatureFlagBits_map[1ULL<<i] << " | ";
3855              else
3856                  _OUT << VkFormatFeatureFlagBits_map[1ULL<<i];
3857          }
3858      }
3859      if (commaNeeded)
3860        _OUT << "\"" << ",";
3861      else
3862        _OUT << "\""<< "";
3863      _OUT << std::endl;
3864 }
3865
3866 static void print_VkImageCreateFlags(VkImageCreateFlags obj, const std::string& str, bool commaNeeded=true) {
3867      PRINT_SPACE
3868      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3869      const int max_bits = 64; // We don't expect the number to be larger.
3870      std::bitset<max_bits> b(obj);
3871      _OUT << "\"";
3872      if (obj == 0) _OUT << "0";
3873      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
3874          if (b[i] == 1) {
3875              bitCount++;
3876              if (bitCount < b.count())
3877                  _OUT << VkImageCreateFlagBits_map[1ULL<<i] << " | ";
3878              else
3879                  _OUT << VkImageCreateFlagBits_map[1ULL<<i];
3880          }
3881      }
3882      if (commaNeeded)
3883        _OUT << "\"" << ",";
3884      else
3885        _OUT << "\""<< "";
3886      _OUT << std::endl;
3887 }
3888 static void print_VkImageCreateFlags(const VkImageCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
3889      PRINT_SPACE
3890      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3891      const int max_bits = 64; // We don't expect the number to be larger.
3892      std::bitset<max_bits> b(obj);
3893      _OUT << "\"";
3894      if (obj == 0) _OUT << "0";
3895      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
3896          if (b[i] == 1) {
3897              bitCount++;
3898              if (bitCount < b.count())
3899                  _OUT << VkImageCreateFlagBits_map[1ULL<<i] << " | ";
3900              else
3901                  _OUT << VkImageCreateFlagBits_map[1ULL<<i];
3902          }
3903      }
3904      if (commaNeeded)
3905        _OUT << "\"" << ",";
3906      else
3907        _OUT << "\""<< "";
3908      _OUT << std::endl;
3909 }
3910
3911 static void print_VkSampleCountFlags(VkSampleCountFlags obj, const std::string& str, bool commaNeeded=true) {
3912      PRINT_SPACE
3913      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3914      const int max_bits = 64; // We don't expect the number to be larger.
3915      std::bitset<max_bits> b(obj);
3916      _OUT << "\"";
3917      if (obj == 0) _OUT << "0";
3918      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
3919          if (b[i] == 1) {
3920              bitCount++;
3921              if (bitCount < b.count())
3922                  _OUT << VkSampleCountFlagBits_map[1ULL<<i] << " | ";
3923              else
3924                  _OUT << VkSampleCountFlagBits_map[1ULL<<i];
3925          }
3926      }
3927      if (commaNeeded)
3928        _OUT << "\"" << ",";
3929      else
3930        _OUT << "\""<< "";
3931      _OUT << std::endl;
3932 }
3933 static void print_VkSampleCountFlags(const VkSampleCountFlags * obj, const std::string& str, bool commaNeeded=true) {
3934      PRINT_SPACE
3935      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3936      const int max_bits = 64; // We don't expect the number to be larger.
3937      std::bitset<max_bits> b(obj);
3938      _OUT << "\"";
3939      if (obj == 0) _OUT << "0";
3940      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
3941          if (b[i] == 1) {
3942              bitCount++;
3943              if (bitCount < b.count())
3944                  _OUT << VkSampleCountFlagBits_map[1ULL<<i] << " | ";
3945              else
3946                  _OUT << VkSampleCountFlagBits_map[1ULL<<i];
3947          }
3948      }
3949      if (commaNeeded)
3950        _OUT << "\"" << ",";
3951      else
3952        _OUT << "\""<< "";
3953      _OUT << std::endl;
3954 }
3955
3956 static void print_VkImageUsageFlags(VkImageUsageFlags obj, const std::string& str, bool commaNeeded=true) {
3957      PRINT_SPACE
3958      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3959      const int max_bits = 64; // We don't expect the number to be larger.
3960      std::bitset<max_bits> b(obj);
3961      _OUT << "\"";
3962      if (obj == 0) _OUT << "0";
3963      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
3964          if (b[i] == 1) {
3965              bitCount++;
3966              if (bitCount < b.count())
3967                  _OUT << VkImageUsageFlagBits_map[1ULL<<i] << " | ";
3968              else
3969                  _OUT << VkImageUsageFlagBits_map[1ULL<<i];
3970          }
3971      }
3972      if (commaNeeded)
3973        _OUT << "\"" << ",";
3974      else
3975        _OUT << "\""<< "";
3976      _OUT << std::endl;
3977 }
3978 static void print_VkImageUsageFlags(const VkImageUsageFlags * obj, const std::string& str, bool commaNeeded=true) {
3979      PRINT_SPACE
3980      if (str != "") _OUT << "\"" << str << "\"" << " : ";
3981      const int max_bits = 64; // We don't expect the number to be larger.
3982      std::bitset<max_bits> b(obj);
3983      _OUT << "\"";
3984      if (obj == 0) _OUT << "0";
3985      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
3986          if (b[i] == 1) {
3987              bitCount++;
3988              if (bitCount < b.count())
3989                  _OUT << VkImageUsageFlagBits_map[1ULL<<i] << " | ";
3990              else
3991                  _OUT << VkImageUsageFlagBits_map[1ULL<<i];
3992          }
3993      }
3994      if (commaNeeded)
3995        _OUT << "\"" << ",";
3996      else
3997        _OUT << "\""<< "";
3998      _OUT << std::endl;
3999 }
4000
4001 static void print_VkInstanceCreateFlags(VkInstanceCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4002      PRINT_SPACE
4003      if (commaNeeded)
4004          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4005      else
4006          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4007 }
4008 static void print_VkInstanceCreateFlags(const VkInstanceCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4009      PRINT_SPACE
4010      if (commaNeeded)
4011          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4012      else
4013          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4014 }
4015
4016 static void print_VkMemoryHeapFlags(VkMemoryHeapFlags obj, const std::string& str, bool commaNeeded=true) {
4017      PRINT_SPACE
4018      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4019      const int max_bits = 64; // We don't expect the number to be larger.
4020      std::bitset<max_bits> b(obj);
4021      _OUT << "\"";
4022      if (obj == 0) _OUT << "0";
4023      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4024          if (b[i] == 1) {
4025              bitCount++;
4026              if (bitCount < b.count())
4027                  _OUT << VkMemoryHeapFlagBits_map[1ULL<<i] << " | ";
4028              else
4029                  _OUT << VkMemoryHeapFlagBits_map[1ULL<<i];
4030          }
4031      }
4032      if (commaNeeded)
4033        _OUT << "\"" << ",";
4034      else
4035        _OUT << "\""<< "";
4036      _OUT << std::endl;
4037 }
4038 static void print_VkMemoryHeapFlags(const VkMemoryHeapFlags * obj, const std::string& str, bool commaNeeded=true) {
4039      PRINT_SPACE
4040      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4041      const int max_bits = 64; // We don't expect the number to be larger.
4042      std::bitset<max_bits> b(obj);
4043      _OUT << "\"";
4044      if (obj == 0) _OUT << "0";
4045      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4046          if (b[i] == 1) {
4047              bitCount++;
4048              if (bitCount < b.count())
4049                  _OUT << VkMemoryHeapFlagBits_map[1ULL<<i] << " | ";
4050              else
4051                  _OUT << VkMemoryHeapFlagBits_map[1ULL<<i];
4052          }
4053      }
4054      if (commaNeeded)
4055        _OUT << "\"" << ",";
4056      else
4057        _OUT << "\""<< "";
4058      _OUT << std::endl;
4059 }
4060
4061 static void print_VkMemoryPropertyFlags(VkMemoryPropertyFlags obj, const std::string& str, bool commaNeeded=true) {
4062      PRINT_SPACE
4063      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4064      const int max_bits = 64; // We don't expect the number to be larger.
4065      std::bitset<max_bits> b(obj);
4066      _OUT << "\"";
4067      if (obj == 0) _OUT << "0";
4068      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4069          if (b[i] == 1) {
4070              bitCount++;
4071              if (bitCount < b.count())
4072                  _OUT << VkMemoryPropertyFlagBits_map[1ULL<<i] << " | ";
4073              else
4074                  _OUT << VkMemoryPropertyFlagBits_map[1ULL<<i];
4075          }
4076      }
4077      if (commaNeeded)
4078        _OUT << "\"" << ",";
4079      else
4080        _OUT << "\""<< "";
4081      _OUT << std::endl;
4082 }
4083 static void print_VkMemoryPropertyFlags(const VkMemoryPropertyFlags * obj, const std::string& str, bool commaNeeded=true) {
4084      PRINT_SPACE
4085      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4086      const int max_bits = 64; // We don't expect the number to be larger.
4087      std::bitset<max_bits> b(obj);
4088      _OUT << "\"";
4089      if (obj == 0) _OUT << "0";
4090      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4091          if (b[i] == 1) {
4092              bitCount++;
4093              if (bitCount < b.count())
4094                  _OUT << VkMemoryPropertyFlagBits_map[1ULL<<i] << " | ";
4095              else
4096                  _OUT << VkMemoryPropertyFlagBits_map[1ULL<<i];
4097          }
4098      }
4099      if (commaNeeded)
4100        _OUT << "\"" << ",";
4101      else
4102        _OUT << "\""<< "";
4103      _OUT << std::endl;
4104 }
4105
4106 static void print_VkQueueFlags(VkQueueFlags obj, const std::string& str, bool commaNeeded=true) {
4107      PRINT_SPACE
4108      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4109      const int max_bits = 64; // We don't expect the number to be larger.
4110      std::bitset<max_bits> b(obj);
4111      _OUT << "\"";
4112      if (obj == 0) _OUT << "0";
4113      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4114          if (b[i] == 1) {
4115              bitCount++;
4116              if (bitCount < b.count())
4117                  _OUT << VkQueueFlagBits_map[1ULL<<i] << " | ";
4118              else
4119                  _OUT << VkQueueFlagBits_map[1ULL<<i];
4120          }
4121      }
4122      if (commaNeeded)
4123        _OUT << "\"" << ",";
4124      else
4125        _OUT << "\""<< "";
4126      _OUT << std::endl;
4127 }
4128 static void print_VkQueueFlags(const VkQueueFlags * obj, const std::string& str, bool commaNeeded=true) {
4129      PRINT_SPACE
4130      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4131      const int max_bits = 64; // We don't expect the number to be larger.
4132      std::bitset<max_bits> b(obj);
4133      _OUT << "\"";
4134      if (obj == 0) _OUT << "0";
4135      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4136          if (b[i] == 1) {
4137              bitCount++;
4138              if (bitCount < b.count())
4139                  _OUT << VkQueueFlagBits_map[1ULL<<i] << " | ";
4140              else
4141                  _OUT << VkQueueFlagBits_map[1ULL<<i];
4142          }
4143      }
4144      if (commaNeeded)
4145        _OUT << "\"" << ",";
4146      else
4147        _OUT << "\""<< "";
4148      _OUT << std::endl;
4149 }
4150
4151 static void print_VkDeviceCreateFlags(VkDeviceCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4152      PRINT_SPACE
4153      if (commaNeeded)
4154          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4155      else
4156          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4157 }
4158 static void print_VkDeviceCreateFlags(const VkDeviceCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4159      PRINT_SPACE
4160      if (commaNeeded)
4161          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4162      else
4163          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4164 }
4165
4166 static void print_VkDeviceQueueCreateFlags(VkDeviceQueueCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4167      PRINT_SPACE
4168      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4169      const int max_bits = 64; // We don't expect the number to be larger.
4170      std::bitset<max_bits> b(obj);
4171      _OUT << "\"";
4172      if (obj == 0) _OUT << "0";
4173      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4174          if (b[i] == 1) {
4175              bitCount++;
4176              if (bitCount < b.count())
4177                  _OUT << VkDeviceQueueCreateFlagBits_map[1ULL<<i] << " | ";
4178              else
4179                  _OUT << VkDeviceQueueCreateFlagBits_map[1ULL<<i];
4180          }
4181      }
4182      if (commaNeeded)
4183        _OUT << "\"" << ",";
4184      else
4185        _OUT << "\""<< "";
4186      _OUT << std::endl;
4187 }
4188 static void print_VkDeviceQueueCreateFlags(const VkDeviceQueueCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4189      PRINT_SPACE
4190      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4191      const int max_bits = 64; // We don't expect the number to be larger.
4192      std::bitset<max_bits> b(obj);
4193      _OUT << "\"";
4194      if (obj == 0) _OUT << "0";
4195      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4196          if (b[i] == 1) {
4197              bitCount++;
4198              if (bitCount < b.count())
4199                  _OUT << VkDeviceQueueCreateFlagBits_map[1ULL<<i] << " | ";
4200              else
4201                  _OUT << VkDeviceQueueCreateFlagBits_map[1ULL<<i];
4202          }
4203      }
4204      if (commaNeeded)
4205        _OUT << "\"" << ",";
4206      else
4207        _OUT << "\""<< "";
4208      _OUT << std::endl;
4209 }
4210
4211 static void print_VkPipelineStageFlags(VkPipelineStageFlags obj, const std::string& str, bool commaNeeded=true) {
4212      PRINT_SPACE
4213      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4214      const int max_bits = 64; // We don't expect the number to be larger.
4215      std::bitset<max_bits> b(obj);
4216      _OUT << "\"";
4217      if (obj == 0) _OUT << "0";
4218      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4219          if (b[i] == 1) {
4220              bitCount++;
4221              if (bitCount < b.count())
4222                  _OUT << VkPipelineStageFlagBits_map[1ULL<<i] << " | ";
4223              else
4224                  _OUT << VkPipelineStageFlagBits_map[1ULL<<i];
4225          }
4226      }
4227      if (commaNeeded)
4228        _OUT << "\"" << ",";
4229      else
4230        _OUT << "\""<< "";
4231      _OUT << std::endl;
4232 }
4233 static void print_VkPipelineStageFlags(const VkPipelineStageFlags * obj, const std::string& str, bool commaNeeded=true) {
4234      PRINT_SPACE
4235      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4236      const int max_bits = 64; // We don't expect the number to be larger.
4237      std::bitset<max_bits> b(obj);
4238      _OUT << "\"";
4239      if (obj == 0) _OUT << "0";
4240      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4241          if (b[i] == 1) {
4242              bitCount++;
4243              if (bitCount < b.count())
4244                  _OUT << VkPipelineStageFlagBits_map[1ULL<<i] << " | ";
4245              else
4246                  _OUT << VkPipelineStageFlagBits_map[1ULL<<i];
4247          }
4248      }
4249      if (commaNeeded)
4250        _OUT << "\"" << ",";
4251      else
4252        _OUT << "\""<< "";
4253      _OUT << std::endl;
4254 }
4255
4256 static void print_VkMemoryMapFlags(VkMemoryMapFlags obj, const std::string& str, bool commaNeeded=true) {
4257      PRINT_SPACE
4258      if (commaNeeded)
4259          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4260      else
4261          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4262 }
4263 static void print_VkMemoryMapFlags(const VkMemoryMapFlags * obj, const std::string& str, bool commaNeeded=true) {
4264      PRINT_SPACE
4265      if (commaNeeded)
4266          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4267      else
4268          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4269 }
4270
4271 static void print_VkFenceCreateFlags(VkFenceCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4272      PRINT_SPACE
4273      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4274      const int max_bits = 64; // We don't expect the number to be larger.
4275      std::bitset<max_bits> b(obj);
4276      _OUT << "\"";
4277      if (obj == 0) _OUT << "0";
4278      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4279          if (b[i] == 1) {
4280              bitCount++;
4281              if (bitCount < b.count())
4282                  _OUT << VkFenceCreateFlagBits_map[1ULL<<i] << " | ";
4283              else
4284                  _OUT << VkFenceCreateFlagBits_map[1ULL<<i];
4285          }
4286      }
4287      if (commaNeeded)
4288        _OUT << "\"" << ",";
4289      else
4290        _OUT << "\""<< "";
4291      _OUT << std::endl;
4292 }
4293 static void print_VkFenceCreateFlags(const VkFenceCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4294      PRINT_SPACE
4295      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4296      const int max_bits = 64; // We don't expect the number to be larger.
4297      std::bitset<max_bits> b(obj);
4298      _OUT << "\"";
4299      if (obj == 0) _OUT << "0";
4300      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4301          if (b[i] == 1) {
4302              bitCount++;
4303              if (bitCount < b.count())
4304                  _OUT << VkFenceCreateFlagBits_map[1ULL<<i] << " | ";
4305              else
4306                  _OUT << VkFenceCreateFlagBits_map[1ULL<<i];
4307          }
4308      }
4309      if (commaNeeded)
4310        _OUT << "\"" << ",";
4311      else
4312        _OUT << "\""<< "";
4313      _OUT << std::endl;
4314 }
4315
4316 static void print_VkSemaphoreCreateFlags(VkSemaphoreCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4317      PRINT_SPACE
4318      if (commaNeeded)
4319          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4320      else
4321          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4322 }
4323 static void print_VkSemaphoreCreateFlags(const VkSemaphoreCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4324      PRINT_SPACE
4325      if (commaNeeded)
4326          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4327      else
4328          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4329 }
4330
4331 static void print_VkEventCreateFlags(VkEventCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4332      PRINT_SPACE
4333      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4334      const int max_bits = 64; // We don't expect the number to be larger.
4335      std::bitset<max_bits> b(obj);
4336      _OUT << "\"";
4337      if (obj == 0) _OUT << "0";
4338      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4339          if (b[i] == 1) {
4340              bitCount++;
4341              if (bitCount < b.count())
4342                  _OUT << VkEventCreateFlagBits_map[1ULL<<i] << " | ";
4343              else
4344                  _OUT << VkEventCreateFlagBits_map[1ULL<<i];
4345          }
4346      }
4347      if (commaNeeded)
4348        _OUT << "\"" << ",";
4349      else
4350        _OUT << "\""<< "";
4351      _OUT << std::endl;
4352 }
4353 static void print_VkEventCreateFlags(const VkEventCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4354      PRINT_SPACE
4355      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4356      const int max_bits = 64; // We don't expect the number to be larger.
4357      std::bitset<max_bits> b(obj);
4358      _OUT << "\"";
4359      if (obj == 0) _OUT << "0";
4360      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4361          if (b[i] == 1) {
4362              bitCount++;
4363              if (bitCount < b.count())
4364                  _OUT << VkEventCreateFlagBits_map[1ULL<<i] << " | ";
4365              else
4366                  _OUT << VkEventCreateFlagBits_map[1ULL<<i];
4367          }
4368      }
4369      if (commaNeeded)
4370        _OUT << "\"" << ",";
4371      else
4372        _OUT << "\""<< "";
4373      _OUT << std::endl;
4374 }
4375
4376 static void print_VkQueryPipelineStatisticFlags(VkQueryPipelineStatisticFlags obj, const std::string& str, bool commaNeeded=true) {
4377      PRINT_SPACE
4378      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4379      const int max_bits = 64; // We don't expect the number to be larger.
4380      std::bitset<max_bits> b(obj);
4381      _OUT << "\"";
4382      if (obj == 0) _OUT << "0";
4383      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4384          if (b[i] == 1) {
4385              bitCount++;
4386              if (bitCount < b.count())
4387                  _OUT << VkQueryPipelineStatisticFlagBits_map[1ULL<<i] << " | ";
4388              else
4389                  _OUT << VkQueryPipelineStatisticFlagBits_map[1ULL<<i];
4390          }
4391      }
4392      if (commaNeeded)
4393        _OUT << "\"" << ",";
4394      else
4395        _OUT << "\""<< "";
4396      _OUT << std::endl;
4397 }
4398 static void print_VkQueryPipelineStatisticFlags(const VkQueryPipelineStatisticFlags * obj, const std::string& str, bool commaNeeded=true) {
4399      PRINT_SPACE
4400      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4401      const int max_bits = 64; // We don't expect the number to be larger.
4402      std::bitset<max_bits> b(obj);
4403      _OUT << "\"";
4404      if (obj == 0) _OUT << "0";
4405      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4406          if (b[i] == 1) {
4407              bitCount++;
4408              if (bitCount < b.count())
4409                  _OUT << VkQueryPipelineStatisticFlagBits_map[1ULL<<i] << " | ";
4410              else
4411                  _OUT << VkQueryPipelineStatisticFlagBits_map[1ULL<<i];
4412          }
4413      }
4414      if (commaNeeded)
4415        _OUT << "\"" << ",";
4416      else
4417        _OUT << "\""<< "";
4418      _OUT << std::endl;
4419 }
4420
4421 static void print_VkQueryPoolCreateFlags(VkQueryPoolCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4422      PRINT_SPACE
4423      if (commaNeeded)
4424          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4425      else
4426          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4427 }
4428 static void print_VkQueryPoolCreateFlags(const VkQueryPoolCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4429      PRINT_SPACE
4430      if (commaNeeded)
4431          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4432      else
4433          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4434 }
4435
4436 static void print_VkQueryResultFlags(VkQueryResultFlags obj, const std::string& str, bool commaNeeded=true) {
4437      PRINT_SPACE
4438      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4439      const int max_bits = 64; // We don't expect the number to be larger.
4440      std::bitset<max_bits> b(obj);
4441      _OUT << "\"";
4442      if (obj == 0) _OUT << "0";
4443      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4444          if (b[i] == 1) {
4445              bitCount++;
4446              if (bitCount < b.count())
4447                  _OUT << VkQueryResultFlagBits_map[1ULL<<i] << " | ";
4448              else
4449                  _OUT << VkQueryResultFlagBits_map[1ULL<<i];
4450          }
4451      }
4452      if (commaNeeded)
4453        _OUT << "\"" << ",";
4454      else
4455        _OUT << "\""<< "";
4456      _OUT << std::endl;
4457 }
4458 static void print_VkQueryResultFlags(const VkQueryResultFlags * obj, const std::string& str, bool commaNeeded=true) {
4459      PRINT_SPACE
4460      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4461      const int max_bits = 64; // We don't expect the number to be larger.
4462      std::bitset<max_bits> b(obj);
4463      _OUT << "\"";
4464      if (obj == 0) _OUT << "0";
4465      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4466          if (b[i] == 1) {
4467              bitCount++;
4468              if (bitCount < b.count())
4469                  _OUT << VkQueryResultFlagBits_map[1ULL<<i] << " | ";
4470              else
4471                  _OUT << VkQueryResultFlagBits_map[1ULL<<i];
4472          }
4473      }
4474      if (commaNeeded)
4475        _OUT << "\"" << ",";
4476      else
4477        _OUT << "\""<< "";
4478      _OUT << std::endl;
4479 }
4480
4481 static void print_VkBufferCreateFlags(VkBufferCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4482      PRINT_SPACE
4483      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4484      const int max_bits = 64; // We don't expect the number to be larger.
4485      std::bitset<max_bits> b(obj);
4486      _OUT << "\"";
4487      if (obj == 0) _OUT << "0";
4488      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4489          if (b[i] == 1) {
4490              bitCount++;
4491              if (bitCount < b.count())
4492                  _OUT << VkBufferCreateFlagBits_map[1ULL<<i] << " | ";
4493              else
4494                  _OUT << VkBufferCreateFlagBits_map[1ULL<<i];
4495          }
4496      }
4497      if (commaNeeded)
4498        _OUT << "\"" << ",";
4499      else
4500        _OUT << "\""<< "";
4501      _OUT << std::endl;
4502 }
4503 static void print_VkBufferCreateFlags(const VkBufferCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4504      PRINT_SPACE
4505      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4506      const int max_bits = 64; // We don't expect the number to be larger.
4507      std::bitset<max_bits> b(obj);
4508      _OUT << "\"";
4509      if (obj == 0) _OUT << "0";
4510      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4511          if (b[i] == 1) {
4512              bitCount++;
4513              if (bitCount < b.count())
4514                  _OUT << VkBufferCreateFlagBits_map[1ULL<<i] << " | ";
4515              else
4516                  _OUT << VkBufferCreateFlagBits_map[1ULL<<i];
4517          }
4518      }
4519      if (commaNeeded)
4520        _OUT << "\"" << ",";
4521      else
4522        _OUT << "\""<< "";
4523      _OUT << std::endl;
4524 }
4525
4526 static void print_VkBufferUsageFlags(VkBufferUsageFlags obj, const std::string& str, bool commaNeeded=true) {
4527      PRINT_SPACE
4528      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4529      const int max_bits = 64; // We don't expect the number to be larger.
4530      std::bitset<max_bits> b(obj);
4531      _OUT << "\"";
4532      if (obj == 0) _OUT << "0";
4533      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4534          if (b[i] == 1) {
4535              bitCount++;
4536              if (bitCount < b.count())
4537                  _OUT << VkBufferUsageFlagBits_map[1ULL<<i] << " | ";
4538              else
4539                  _OUT << VkBufferUsageFlagBits_map[1ULL<<i];
4540          }
4541      }
4542      if (commaNeeded)
4543        _OUT << "\"" << ",";
4544      else
4545        _OUT << "\""<< "";
4546      _OUT << std::endl;
4547 }
4548 static void print_VkBufferUsageFlags(const VkBufferUsageFlags * obj, const std::string& str, bool commaNeeded=true) {
4549      PRINT_SPACE
4550      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4551      const int max_bits = 64; // We don't expect the number to be larger.
4552      std::bitset<max_bits> b(obj);
4553      _OUT << "\"";
4554      if (obj == 0) _OUT << "0";
4555      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4556          if (b[i] == 1) {
4557              bitCount++;
4558              if (bitCount < b.count())
4559                  _OUT << VkBufferUsageFlagBits_map[1ULL<<i] << " | ";
4560              else
4561                  _OUT << VkBufferUsageFlagBits_map[1ULL<<i];
4562          }
4563      }
4564      if (commaNeeded)
4565        _OUT << "\"" << ",";
4566      else
4567        _OUT << "\""<< "";
4568      _OUT << std::endl;
4569 }
4570
4571 static void print_VkBufferViewCreateFlags(VkBufferViewCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4572      PRINT_SPACE
4573      if (commaNeeded)
4574          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4575      else
4576          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4577 }
4578 static void print_VkBufferViewCreateFlags(const VkBufferViewCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4579      PRINT_SPACE
4580      if (commaNeeded)
4581          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4582      else
4583          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4584 }
4585
4586 static void print_VkImageViewCreateFlags(VkImageViewCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4587      PRINT_SPACE
4588      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4589      const int max_bits = 64; // We don't expect the number to be larger.
4590      std::bitset<max_bits> b(obj);
4591      _OUT << "\"";
4592      if (obj == 0) _OUT << "0";
4593      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4594          if (b[i] == 1) {
4595              bitCount++;
4596              if (bitCount < b.count())
4597                  _OUT << VkImageViewCreateFlagBits_map[1ULL<<i] << " | ";
4598              else
4599                  _OUT << VkImageViewCreateFlagBits_map[1ULL<<i];
4600          }
4601      }
4602      if (commaNeeded)
4603        _OUT << "\"" << ",";
4604      else
4605        _OUT << "\""<< "";
4606      _OUT << std::endl;
4607 }
4608 static void print_VkImageViewCreateFlags(const VkImageViewCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4609      PRINT_SPACE
4610      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4611      const int max_bits = 64; // We don't expect the number to be larger.
4612      std::bitset<max_bits> b(obj);
4613      _OUT << "\"";
4614      if (obj == 0) _OUT << "0";
4615      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4616          if (b[i] == 1) {
4617              bitCount++;
4618              if (bitCount < b.count())
4619                  _OUT << VkImageViewCreateFlagBits_map[1ULL<<i] << " | ";
4620              else
4621                  _OUT << VkImageViewCreateFlagBits_map[1ULL<<i];
4622          }
4623      }
4624      if (commaNeeded)
4625        _OUT << "\"" << ",";
4626      else
4627        _OUT << "\""<< "";
4628      _OUT << std::endl;
4629 }
4630
4631 static void print_VkPipelineCacheCreateFlags(VkPipelineCacheCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4632      PRINT_SPACE
4633      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4634      const int max_bits = 64; // We don't expect the number to be larger.
4635      std::bitset<max_bits> b(obj);
4636      _OUT << "\"";
4637      if (obj == 0) _OUT << "0";
4638      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4639          if (b[i] == 1) {
4640              bitCount++;
4641              if (bitCount < b.count())
4642                  _OUT << VkPipelineCacheCreateFlagBits_map[1ULL<<i] << " | ";
4643              else
4644                  _OUT << VkPipelineCacheCreateFlagBits_map[1ULL<<i];
4645          }
4646      }
4647      if (commaNeeded)
4648        _OUT << "\"" << ",";
4649      else
4650        _OUT << "\""<< "";
4651      _OUT << std::endl;
4652 }
4653 static void print_VkPipelineCacheCreateFlags(const VkPipelineCacheCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4654      PRINT_SPACE
4655      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4656      const int max_bits = 64; // We don't expect the number to be larger.
4657      std::bitset<max_bits> b(obj);
4658      _OUT << "\"";
4659      if (obj == 0) _OUT << "0";
4660      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4661          if (b[i] == 1) {
4662              bitCount++;
4663              if (bitCount < b.count())
4664                  _OUT << VkPipelineCacheCreateFlagBits_map[1ULL<<i] << " | ";
4665              else
4666                  _OUT << VkPipelineCacheCreateFlagBits_map[1ULL<<i];
4667          }
4668      }
4669      if (commaNeeded)
4670        _OUT << "\"" << ",";
4671      else
4672        _OUT << "\""<< "";
4673      _OUT << std::endl;
4674 }
4675
4676 static void print_VkColorComponentFlags(VkColorComponentFlags obj, const std::string& str, bool commaNeeded=true) {
4677      PRINT_SPACE
4678      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4679      const int max_bits = 64; // We don't expect the number to be larger.
4680      std::bitset<max_bits> b(obj);
4681      _OUT << "\"";
4682      if (obj == 0) _OUT << "0";
4683      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4684          if (b[i] == 1) {
4685              bitCount++;
4686              if (bitCount < b.count())
4687                  _OUT << VkColorComponentFlagBits_map[1ULL<<i] << " | ";
4688              else
4689                  _OUT << VkColorComponentFlagBits_map[1ULL<<i];
4690          }
4691      }
4692      if (commaNeeded)
4693        _OUT << "\"" << ",";
4694      else
4695        _OUT << "\""<< "";
4696      _OUT << std::endl;
4697 }
4698 static void print_VkColorComponentFlags(const VkColorComponentFlags * obj, const std::string& str, bool commaNeeded=true) {
4699      PRINT_SPACE
4700      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4701      const int max_bits = 64; // We don't expect the number to be larger.
4702      std::bitset<max_bits> b(obj);
4703      _OUT << "\"";
4704      if (obj == 0) _OUT << "0";
4705      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4706          if (b[i] == 1) {
4707              bitCount++;
4708              if (bitCount < b.count())
4709                  _OUT << VkColorComponentFlagBits_map[1ULL<<i] << " | ";
4710              else
4711                  _OUT << VkColorComponentFlagBits_map[1ULL<<i];
4712          }
4713      }
4714      if (commaNeeded)
4715        _OUT << "\"" << ",";
4716      else
4717        _OUT << "\""<< "";
4718      _OUT << std::endl;
4719 }
4720
4721 static void print_VkPipelineCreateFlags(VkPipelineCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4722      PRINT_SPACE
4723      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4724      const int max_bits = 64; // We don't expect the number to be larger.
4725      std::bitset<max_bits> b(obj);
4726      _OUT << "\"";
4727      if (obj == 0) _OUT << "0";
4728      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4729          if (b[i] == 1) {
4730              bitCount++;
4731              if (bitCount < b.count())
4732                  _OUT << VkPipelineCreateFlagBits_map[1ULL<<i] << " | ";
4733              else
4734                  _OUT << VkPipelineCreateFlagBits_map[1ULL<<i];
4735          }
4736      }
4737      if (commaNeeded)
4738        _OUT << "\"" << ",";
4739      else
4740        _OUT << "\""<< "";
4741      _OUT << std::endl;
4742 }
4743 static void print_VkPipelineCreateFlags(const VkPipelineCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4744      PRINT_SPACE
4745      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4746      const int max_bits = 64; // We don't expect the number to be larger.
4747      std::bitset<max_bits> b(obj);
4748      _OUT << "\"";
4749      if (obj == 0) _OUT << "0";
4750      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4751          if (b[i] == 1) {
4752              bitCount++;
4753              if (bitCount < b.count())
4754                  _OUT << VkPipelineCreateFlagBits_map[1ULL<<i] << " | ";
4755              else
4756                  _OUT << VkPipelineCreateFlagBits_map[1ULL<<i];
4757          }
4758      }
4759      if (commaNeeded)
4760        _OUT << "\"" << ",";
4761      else
4762        _OUT << "\""<< "";
4763      _OUT << std::endl;
4764 }
4765
4766 static void print_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4767      PRINT_SPACE
4768      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4769      const int max_bits = 64; // We don't expect the number to be larger.
4770      std::bitset<max_bits> b(obj);
4771      _OUT << "\"";
4772      if (obj == 0) _OUT << "0";
4773      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4774          if (b[i] == 1) {
4775              bitCount++;
4776              if (bitCount < b.count())
4777                  _OUT << VkPipelineShaderStageCreateFlagBits_map[1ULL<<i] << " | ";
4778              else
4779                  _OUT << VkPipelineShaderStageCreateFlagBits_map[1ULL<<i];
4780          }
4781      }
4782      if (commaNeeded)
4783        _OUT << "\"" << ",";
4784      else
4785        _OUT << "\""<< "";
4786      _OUT << std::endl;
4787 }
4788 static void print_VkPipelineShaderStageCreateFlags(const VkPipelineShaderStageCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4789      PRINT_SPACE
4790      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4791      const int max_bits = 64; // We don't expect the number to be larger.
4792      std::bitset<max_bits> b(obj);
4793      _OUT << "\"";
4794      if (obj == 0) _OUT << "0";
4795      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4796          if (b[i] == 1) {
4797              bitCount++;
4798              if (bitCount < b.count())
4799                  _OUT << VkPipelineShaderStageCreateFlagBits_map[1ULL<<i] << " | ";
4800              else
4801                  _OUT << VkPipelineShaderStageCreateFlagBits_map[1ULL<<i];
4802          }
4803      }
4804      if (commaNeeded)
4805        _OUT << "\"" << ",";
4806      else
4807        _OUT << "\""<< "";
4808      _OUT << std::endl;
4809 }
4810
4811 static void print_VkCullModeFlags(VkCullModeFlags obj, const std::string& str, bool commaNeeded=true) {
4812      PRINT_SPACE
4813      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4814      const int max_bits = 64; // We don't expect the number to be larger.
4815      std::bitset<max_bits> b(obj);
4816      _OUT << "\"";
4817      if (obj == 0) _OUT << "0";
4818      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4819          if (b[i] == 1) {
4820              bitCount++;
4821              if (bitCount < b.count())
4822                  _OUT << VkCullModeFlagBits_map[1ULL<<i] << " | ";
4823              else
4824                  _OUT << VkCullModeFlagBits_map[1ULL<<i];
4825          }
4826      }
4827      if (commaNeeded)
4828        _OUT << "\"" << ",";
4829      else
4830        _OUT << "\""<< "";
4831      _OUT << std::endl;
4832 }
4833 static void print_VkCullModeFlags(const VkCullModeFlags * obj, const std::string& str, bool commaNeeded=true) {
4834      PRINT_SPACE
4835      if (str != "") _OUT << "\"" << str << "\"" << " : ";
4836      const int max_bits = 64; // We don't expect the number to be larger.
4837      std::bitset<max_bits> b(obj);
4838      _OUT << "\"";
4839      if (obj == 0) _OUT << "0";
4840      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
4841          if (b[i] == 1) {
4842              bitCount++;
4843              if (bitCount < b.count())
4844                  _OUT << VkCullModeFlagBits_map[1ULL<<i] << " | ";
4845              else
4846                  _OUT << VkCullModeFlagBits_map[1ULL<<i];
4847          }
4848      }
4849      if (commaNeeded)
4850        _OUT << "\"" << ",";
4851      else
4852        _OUT << "\""<< "";
4853      _OUT << std::endl;
4854 }
4855
4856 static void print_VkPipelineVertexInputStateCreateFlags(VkPipelineVertexInputStateCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4857      PRINT_SPACE
4858      if (commaNeeded)
4859          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4860      else
4861          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4862 }
4863 static void print_VkPipelineVertexInputStateCreateFlags(const VkPipelineVertexInputStateCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4864      PRINT_SPACE
4865      if (commaNeeded)
4866          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4867      else
4868          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4869 }
4870
4871 static void print_VkPipelineInputAssemblyStateCreateFlags(VkPipelineInputAssemblyStateCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4872      PRINT_SPACE
4873      if (commaNeeded)
4874          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4875      else
4876          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4877 }
4878 static void print_VkPipelineInputAssemblyStateCreateFlags(const VkPipelineInputAssemblyStateCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4879      PRINT_SPACE
4880      if (commaNeeded)
4881          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4882      else
4883          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4884 }
4885
4886 static void print_VkPipelineTessellationStateCreateFlags(VkPipelineTessellationStateCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4887      PRINT_SPACE
4888      if (commaNeeded)
4889          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4890      else
4891          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4892 }
4893 static void print_VkPipelineTessellationStateCreateFlags(const VkPipelineTessellationStateCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4894      PRINT_SPACE
4895      if (commaNeeded)
4896          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4897      else
4898          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4899 }
4900
4901 static void print_VkPipelineViewportStateCreateFlags(VkPipelineViewportStateCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4902      PRINT_SPACE
4903      if (commaNeeded)
4904          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4905      else
4906          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4907 }
4908 static void print_VkPipelineViewportStateCreateFlags(const VkPipelineViewportStateCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4909      PRINT_SPACE
4910      if (commaNeeded)
4911          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4912      else
4913          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4914 }
4915
4916 static void print_VkPipelineRasterizationStateCreateFlags(VkPipelineRasterizationStateCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4917      PRINT_SPACE
4918      if (commaNeeded)
4919          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4920      else
4921          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4922 }
4923 static void print_VkPipelineRasterizationStateCreateFlags(const VkPipelineRasterizationStateCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4924      PRINT_SPACE
4925      if (commaNeeded)
4926          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4927      else
4928          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4929 }
4930
4931 static void print_VkPipelineMultisampleStateCreateFlags(VkPipelineMultisampleStateCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4932      PRINT_SPACE
4933      if (commaNeeded)
4934          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4935      else
4936          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4937 }
4938 static void print_VkPipelineMultisampleStateCreateFlags(const VkPipelineMultisampleStateCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4939      PRINT_SPACE
4940      if (commaNeeded)
4941          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4942      else
4943          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4944 }
4945
4946 static void print_VkPipelineDepthStencilStateCreateFlags(VkPipelineDepthStencilStateCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4947      PRINT_SPACE
4948      if (commaNeeded)
4949          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4950      else
4951          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4952 }
4953 static void print_VkPipelineDepthStencilStateCreateFlags(const VkPipelineDepthStencilStateCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4954      PRINT_SPACE
4955      if (commaNeeded)
4956          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4957      else
4958          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4959 }
4960
4961 static void print_VkPipelineColorBlendStateCreateFlags(VkPipelineColorBlendStateCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4962      PRINT_SPACE
4963      if (commaNeeded)
4964          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4965      else
4966          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4967 }
4968 static void print_VkPipelineColorBlendStateCreateFlags(const VkPipelineColorBlendStateCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4969      PRINT_SPACE
4970      if (commaNeeded)
4971          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4972      else
4973          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4974 }
4975
4976 static void print_VkPipelineDynamicStateCreateFlags(VkPipelineDynamicStateCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4977      PRINT_SPACE
4978      if (commaNeeded)
4979          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4980      else
4981          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4982 }
4983 static void print_VkPipelineDynamicStateCreateFlags(const VkPipelineDynamicStateCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4984      PRINT_SPACE
4985      if (commaNeeded)
4986          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4987      else
4988          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4989 }
4990
4991 static void print_VkPipelineLayoutCreateFlags(VkPipelineLayoutCreateFlags obj, const std::string& str, bool commaNeeded=true) {
4992      PRINT_SPACE
4993      if (commaNeeded)
4994          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
4995      else
4996          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
4997 }
4998 static void print_VkPipelineLayoutCreateFlags(const VkPipelineLayoutCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
4999      PRINT_SPACE
5000      if (commaNeeded)
5001          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
5002      else
5003          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
5004 }
5005
5006 static void print_VkShaderStageFlags(VkShaderStageFlags obj, const std::string& str, bool commaNeeded=true) {
5007      PRINT_SPACE
5008      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5009      const int max_bits = 64; // We don't expect the number to be larger.
5010      std::bitset<max_bits> b(obj);
5011      _OUT << "\"";
5012      if (obj == 0) _OUT << "0";
5013      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5014          if (b[i] == 1) {
5015              bitCount++;
5016              if (bitCount < b.count())
5017                  _OUT << VkShaderStageFlagBits_map[1ULL<<i] << " | ";
5018              else
5019                  _OUT << VkShaderStageFlagBits_map[1ULL<<i];
5020          }
5021      }
5022      if (commaNeeded)
5023        _OUT << "\"" << ",";
5024      else
5025        _OUT << "\""<< "";
5026      _OUT << std::endl;
5027 }
5028 static void print_VkShaderStageFlags(const VkShaderStageFlags * obj, const std::string& str, bool commaNeeded=true) {
5029      PRINT_SPACE
5030      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5031      const int max_bits = 64; // We don't expect the number to be larger.
5032      std::bitset<max_bits> b(obj);
5033      _OUT << "\"";
5034      if (obj == 0) _OUT << "0";
5035      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5036          if (b[i] == 1) {
5037              bitCount++;
5038              if (bitCount < b.count())
5039                  _OUT << VkShaderStageFlagBits_map[1ULL<<i] << " | ";
5040              else
5041                  _OUT << VkShaderStageFlagBits_map[1ULL<<i];
5042          }
5043      }
5044      if (commaNeeded)
5045        _OUT << "\"" << ",";
5046      else
5047        _OUT << "\""<< "";
5048      _OUT << std::endl;
5049 }
5050
5051 static void print_VkSamplerCreateFlags(VkSamplerCreateFlags obj, const std::string& str, bool commaNeeded=true) {
5052      PRINT_SPACE
5053      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5054      const int max_bits = 64; // We don't expect the number to be larger.
5055      std::bitset<max_bits> b(obj);
5056      _OUT << "\"";
5057      if (obj == 0) _OUT << "0";
5058      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5059          if (b[i] == 1) {
5060              bitCount++;
5061              if (bitCount < b.count())
5062                  _OUT << VkSamplerCreateFlagBits_map[1ULL<<i] << " | ";
5063              else
5064                  _OUT << VkSamplerCreateFlagBits_map[1ULL<<i];
5065          }
5066      }
5067      if (commaNeeded)
5068        _OUT << "\"" << ",";
5069      else
5070        _OUT << "\""<< "";
5071      _OUT << std::endl;
5072 }
5073 static void print_VkSamplerCreateFlags(const VkSamplerCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
5074      PRINT_SPACE
5075      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5076      const int max_bits = 64; // We don't expect the number to be larger.
5077      std::bitset<max_bits> b(obj);
5078      _OUT << "\"";
5079      if (obj == 0) _OUT << "0";
5080      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5081          if (b[i] == 1) {
5082              bitCount++;
5083              if (bitCount < b.count())
5084                  _OUT << VkSamplerCreateFlagBits_map[1ULL<<i] << " | ";
5085              else
5086                  _OUT << VkSamplerCreateFlagBits_map[1ULL<<i];
5087          }
5088      }
5089      if (commaNeeded)
5090        _OUT << "\"" << ",";
5091      else
5092        _OUT << "\""<< "";
5093      _OUT << std::endl;
5094 }
5095
5096 static void print_VkDescriptorPoolCreateFlags(VkDescriptorPoolCreateFlags obj, const std::string& str, bool commaNeeded=true) {
5097      PRINT_SPACE
5098      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5099      const int max_bits = 64; // We don't expect the number to be larger.
5100      std::bitset<max_bits> b(obj);
5101      _OUT << "\"";
5102      if (obj == 0) _OUT << "0";
5103      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5104          if (b[i] == 1) {
5105              bitCount++;
5106              if (bitCount < b.count())
5107                  _OUT << VkDescriptorPoolCreateFlagBits_map[1ULL<<i] << " | ";
5108              else
5109                  _OUT << VkDescriptorPoolCreateFlagBits_map[1ULL<<i];
5110          }
5111      }
5112      if (commaNeeded)
5113        _OUT << "\"" << ",";
5114      else
5115        _OUT << "\""<< "";
5116      _OUT << std::endl;
5117 }
5118 static void print_VkDescriptorPoolCreateFlags(const VkDescriptorPoolCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
5119      PRINT_SPACE
5120      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5121      const int max_bits = 64; // We don't expect the number to be larger.
5122      std::bitset<max_bits> b(obj);
5123      _OUT << "\"";
5124      if (obj == 0) _OUT << "0";
5125      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5126          if (b[i] == 1) {
5127              bitCount++;
5128              if (bitCount < b.count())
5129                  _OUT << VkDescriptorPoolCreateFlagBits_map[1ULL<<i] << " | ";
5130              else
5131                  _OUT << VkDescriptorPoolCreateFlagBits_map[1ULL<<i];
5132          }
5133      }
5134      if (commaNeeded)
5135        _OUT << "\"" << ",";
5136      else
5137        _OUT << "\""<< "";
5138      _OUT << std::endl;
5139 }
5140
5141 static void print_VkDescriptorPoolResetFlags(VkDescriptorPoolResetFlags obj, const std::string& str, bool commaNeeded=true) {
5142      PRINT_SPACE
5143      if (commaNeeded)
5144          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
5145      else
5146          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
5147 }
5148 static void print_VkDescriptorPoolResetFlags(const VkDescriptorPoolResetFlags * obj, const std::string& str, bool commaNeeded=true) {
5149      PRINT_SPACE
5150      if (commaNeeded)
5151          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
5152      else
5153          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
5154 }
5155
5156 static void print_VkDescriptorSetLayoutCreateFlags(VkDescriptorSetLayoutCreateFlags obj, const std::string& str, bool commaNeeded=true) {
5157      PRINT_SPACE
5158      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5159      const int max_bits = 64; // We don't expect the number to be larger.
5160      std::bitset<max_bits> b(obj);
5161      _OUT << "\"";
5162      if (obj == 0) _OUT << "0";
5163      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5164          if (b[i] == 1) {
5165              bitCount++;
5166              if (bitCount < b.count())
5167                  _OUT << VkDescriptorSetLayoutCreateFlagBits_map[1ULL<<i] << " | ";
5168              else
5169                  _OUT << VkDescriptorSetLayoutCreateFlagBits_map[1ULL<<i];
5170          }
5171      }
5172      if (commaNeeded)
5173        _OUT << "\"" << ",";
5174      else
5175        _OUT << "\""<< "";
5176      _OUT << std::endl;
5177 }
5178 static void print_VkDescriptorSetLayoutCreateFlags(const VkDescriptorSetLayoutCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
5179      PRINT_SPACE
5180      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5181      const int max_bits = 64; // We don't expect the number to be larger.
5182      std::bitset<max_bits> b(obj);
5183      _OUT << "\"";
5184      if (obj == 0) _OUT << "0";
5185      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5186          if (b[i] == 1) {
5187              bitCount++;
5188              if (bitCount < b.count())
5189                  _OUT << VkDescriptorSetLayoutCreateFlagBits_map[1ULL<<i] << " | ";
5190              else
5191                  _OUT << VkDescriptorSetLayoutCreateFlagBits_map[1ULL<<i];
5192          }
5193      }
5194      if (commaNeeded)
5195        _OUT << "\"" << ",";
5196      else
5197        _OUT << "\""<< "";
5198      _OUT << std::endl;
5199 }
5200
5201 static void print_VkAttachmentDescriptionFlags(VkAttachmentDescriptionFlags obj, const std::string& str, bool commaNeeded=true) {
5202      PRINT_SPACE
5203      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5204      const int max_bits = 64; // We don't expect the number to be larger.
5205      std::bitset<max_bits> b(obj);
5206      _OUT << "\"";
5207      if (obj == 0) _OUT << "0";
5208      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5209          if (b[i] == 1) {
5210              bitCount++;
5211              if (bitCount < b.count())
5212                  _OUT << VkAttachmentDescriptionFlagBits_map[1ULL<<i] << " | ";
5213              else
5214                  _OUT << VkAttachmentDescriptionFlagBits_map[1ULL<<i];
5215          }
5216      }
5217      if (commaNeeded)
5218        _OUT << "\"" << ",";
5219      else
5220        _OUT << "\""<< "";
5221      _OUT << std::endl;
5222 }
5223 static void print_VkAttachmentDescriptionFlags(const VkAttachmentDescriptionFlags * obj, const std::string& str, bool commaNeeded=true) {
5224      PRINT_SPACE
5225      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5226      const int max_bits = 64; // We don't expect the number to be larger.
5227      std::bitset<max_bits> b(obj);
5228      _OUT << "\"";
5229      if (obj == 0) _OUT << "0";
5230      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5231          if (b[i] == 1) {
5232              bitCount++;
5233              if (bitCount < b.count())
5234                  _OUT << VkAttachmentDescriptionFlagBits_map[1ULL<<i] << " | ";
5235              else
5236                  _OUT << VkAttachmentDescriptionFlagBits_map[1ULL<<i];
5237          }
5238      }
5239      if (commaNeeded)
5240        _OUT << "\"" << ",";
5241      else
5242        _OUT << "\""<< "";
5243      _OUT << std::endl;
5244 }
5245
5246 static void print_VkDependencyFlags(VkDependencyFlags obj, const std::string& str, bool commaNeeded=true) {
5247      PRINT_SPACE
5248      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5249      const int max_bits = 64; // We don't expect the number to be larger.
5250      std::bitset<max_bits> b(obj);
5251      _OUT << "\"";
5252      if (obj == 0) _OUT << "0";
5253      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5254          if (b[i] == 1) {
5255              bitCount++;
5256              if (bitCount < b.count())
5257                  _OUT << VkDependencyFlagBits_map[1ULL<<i] << " | ";
5258              else
5259                  _OUT << VkDependencyFlagBits_map[1ULL<<i];
5260          }
5261      }
5262      if (commaNeeded)
5263        _OUT << "\"" << ",";
5264      else
5265        _OUT << "\""<< "";
5266      _OUT << std::endl;
5267 }
5268 static void print_VkDependencyFlags(const VkDependencyFlags * obj, const std::string& str, bool commaNeeded=true) {
5269      PRINT_SPACE
5270      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5271      const int max_bits = 64; // We don't expect the number to be larger.
5272      std::bitset<max_bits> b(obj);
5273      _OUT << "\"";
5274      if (obj == 0) _OUT << "0";
5275      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5276          if (b[i] == 1) {
5277              bitCount++;
5278              if (bitCount < b.count())
5279                  _OUT << VkDependencyFlagBits_map[1ULL<<i] << " | ";
5280              else
5281                  _OUT << VkDependencyFlagBits_map[1ULL<<i];
5282          }
5283      }
5284      if (commaNeeded)
5285        _OUT << "\"" << ",";
5286      else
5287        _OUT << "\""<< "";
5288      _OUT << std::endl;
5289 }
5290
5291 static void print_VkFramebufferCreateFlags(VkFramebufferCreateFlags obj, const std::string& str, bool commaNeeded=true) {
5292      PRINT_SPACE
5293      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5294      const int max_bits = 64; // We don't expect the number to be larger.
5295      std::bitset<max_bits> b(obj);
5296      _OUT << "\"";
5297      if (obj == 0) _OUT << "0";
5298      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5299          if (b[i] == 1) {
5300              bitCount++;
5301              if (bitCount < b.count())
5302                  _OUT << VkFramebufferCreateFlagBits_map[1ULL<<i] << " | ";
5303              else
5304                  _OUT << VkFramebufferCreateFlagBits_map[1ULL<<i];
5305          }
5306      }
5307      if (commaNeeded)
5308        _OUT << "\"" << ",";
5309      else
5310        _OUT << "\""<< "";
5311      _OUT << std::endl;
5312 }
5313 static void print_VkFramebufferCreateFlags(const VkFramebufferCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
5314      PRINT_SPACE
5315      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5316      const int max_bits = 64; // We don't expect the number to be larger.
5317      std::bitset<max_bits> b(obj);
5318      _OUT << "\"";
5319      if (obj == 0) _OUT << "0";
5320      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5321          if (b[i] == 1) {
5322              bitCount++;
5323              if (bitCount < b.count())
5324                  _OUT << VkFramebufferCreateFlagBits_map[1ULL<<i] << " | ";
5325              else
5326                  _OUT << VkFramebufferCreateFlagBits_map[1ULL<<i];
5327          }
5328      }
5329      if (commaNeeded)
5330        _OUT << "\"" << ",";
5331      else
5332        _OUT << "\""<< "";
5333      _OUT << std::endl;
5334 }
5335
5336 static void print_VkRenderPassCreateFlags(VkRenderPassCreateFlags obj, const std::string& str, bool commaNeeded=true) {
5337      PRINT_SPACE
5338      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5339      const int max_bits = 64; // We don't expect the number to be larger.
5340      std::bitset<max_bits> b(obj);
5341      _OUT << "\"";
5342      if (obj == 0) _OUT << "0";
5343      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5344          if (b[i] == 1) {
5345              bitCount++;
5346              if (bitCount < b.count())
5347                  _OUT << VkRenderPassCreateFlagBits_map[1ULL<<i] << " | ";
5348              else
5349                  _OUT << VkRenderPassCreateFlagBits_map[1ULL<<i];
5350          }
5351      }
5352      if (commaNeeded)
5353        _OUT << "\"" << ",";
5354      else
5355        _OUT << "\""<< "";
5356      _OUT << std::endl;
5357 }
5358 static void print_VkRenderPassCreateFlags(const VkRenderPassCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
5359      PRINT_SPACE
5360      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5361      const int max_bits = 64; // We don't expect the number to be larger.
5362      std::bitset<max_bits> b(obj);
5363      _OUT << "\"";
5364      if (obj == 0) _OUT << "0";
5365      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5366          if (b[i] == 1) {
5367              bitCount++;
5368              if (bitCount < b.count())
5369                  _OUT << VkRenderPassCreateFlagBits_map[1ULL<<i] << " | ";
5370              else
5371                  _OUT << VkRenderPassCreateFlagBits_map[1ULL<<i];
5372          }
5373      }
5374      if (commaNeeded)
5375        _OUT << "\"" << ",";
5376      else
5377        _OUT << "\""<< "";
5378      _OUT << std::endl;
5379 }
5380
5381 static void print_VkSubpassDescriptionFlags(VkSubpassDescriptionFlags obj, const std::string& str, bool commaNeeded=true) {
5382      PRINT_SPACE
5383      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5384      const int max_bits = 64; // We don't expect the number to be larger.
5385      std::bitset<max_bits> b(obj);
5386      _OUT << "\"";
5387      if (obj == 0) _OUT << "0";
5388      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5389          if (b[i] == 1) {
5390              bitCount++;
5391              if (bitCount < b.count())
5392                  _OUT << VkSubpassDescriptionFlagBits_map[1ULL<<i] << " | ";
5393              else
5394                  _OUT << VkSubpassDescriptionFlagBits_map[1ULL<<i];
5395          }
5396      }
5397      if (commaNeeded)
5398        _OUT << "\"" << ",";
5399      else
5400        _OUT << "\""<< "";
5401      _OUT << std::endl;
5402 }
5403 static void print_VkSubpassDescriptionFlags(const VkSubpassDescriptionFlags * obj, const std::string& str, bool commaNeeded=true) {
5404      PRINT_SPACE
5405      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5406      const int max_bits = 64; // We don't expect the number to be larger.
5407      std::bitset<max_bits> b(obj);
5408      _OUT << "\"";
5409      if (obj == 0) _OUT << "0";
5410      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5411          if (b[i] == 1) {
5412              bitCount++;
5413              if (bitCount < b.count())
5414                  _OUT << VkSubpassDescriptionFlagBits_map[1ULL<<i] << " | ";
5415              else
5416                  _OUT << VkSubpassDescriptionFlagBits_map[1ULL<<i];
5417          }
5418      }
5419      if (commaNeeded)
5420        _OUT << "\"" << ",";
5421      else
5422        _OUT << "\""<< "";
5423      _OUT << std::endl;
5424 }
5425
5426 static void print_VkCommandPoolCreateFlags(VkCommandPoolCreateFlags obj, const std::string& str, bool commaNeeded=true) {
5427      PRINT_SPACE
5428      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5429      const int max_bits = 64; // We don't expect the number to be larger.
5430      std::bitset<max_bits> b(obj);
5431      _OUT << "\"";
5432      if (obj == 0) _OUT << "0";
5433      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5434          if (b[i] == 1) {
5435              bitCount++;
5436              if (bitCount < b.count())
5437                  _OUT << VkCommandPoolCreateFlagBits_map[1ULL<<i] << " | ";
5438              else
5439                  _OUT << VkCommandPoolCreateFlagBits_map[1ULL<<i];
5440          }
5441      }
5442      if (commaNeeded)
5443        _OUT << "\"" << ",";
5444      else
5445        _OUT << "\""<< "";
5446      _OUT << std::endl;
5447 }
5448 static void print_VkCommandPoolCreateFlags(const VkCommandPoolCreateFlags * obj, const std::string& str, bool commaNeeded=true) {
5449      PRINT_SPACE
5450      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5451      const int max_bits = 64; // We don't expect the number to be larger.
5452      std::bitset<max_bits> b(obj);
5453      _OUT << "\"";
5454      if (obj == 0) _OUT << "0";
5455      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5456          if (b[i] == 1) {
5457              bitCount++;
5458              if (bitCount < b.count())
5459                  _OUT << VkCommandPoolCreateFlagBits_map[1ULL<<i] << " | ";
5460              else
5461                  _OUT << VkCommandPoolCreateFlagBits_map[1ULL<<i];
5462          }
5463      }
5464      if (commaNeeded)
5465        _OUT << "\"" << ",";
5466      else
5467        _OUT << "\""<< "";
5468      _OUT << std::endl;
5469 }
5470
5471 static void print_VkCommandPoolResetFlags(VkCommandPoolResetFlags obj, const std::string& str, bool commaNeeded=true) {
5472      PRINT_SPACE
5473      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5474      const int max_bits = 64; // We don't expect the number to be larger.
5475      std::bitset<max_bits> b(obj);
5476      _OUT << "\"";
5477      if (obj == 0) _OUT << "0";
5478      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5479          if (b[i] == 1) {
5480              bitCount++;
5481              if (bitCount < b.count())
5482                  _OUT << VkCommandPoolResetFlagBits_map[1ULL<<i] << " | ";
5483              else
5484                  _OUT << VkCommandPoolResetFlagBits_map[1ULL<<i];
5485          }
5486      }
5487      if (commaNeeded)
5488        _OUT << "\"" << ",";
5489      else
5490        _OUT << "\""<< "";
5491      _OUT << std::endl;
5492 }
5493 static void print_VkCommandPoolResetFlags(const VkCommandPoolResetFlags * obj, const std::string& str, bool commaNeeded=true) {
5494      PRINT_SPACE
5495      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5496      const int max_bits = 64; // We don't expect the number to be larger.
5497      std::bitset<max_bits> b(obj);
5498      _OUT << "\"";
5499      if (obj == 0) _OUT << "0";
5500      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5501          if (b[i] == 1) {
5502              bitCount++;
5503              if (bitCount < b.count())
5504                  _OUT << VkCommandPoolResetFlagBits_map[1ULL<<i] << " | ";
5505              else
5506                  _OUT << VkCommandPoolResetFlagBits_map[1ULL<<i];
5507          }
5508      }
5509      if (commaNeeded)
5510        _OUT << "\"" << ",";
5511      else
5512        _OUT << "\""<< "";
5513      _OUT << std::endl;
5514 }
5515
5516 static void print_VkCommandBufferUsageFlags(VkCommandBufferUsageFlags obj, const std::string& str, bool commaNeeded=true) {
5517      PRINT_SPACE
5518      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5519      const int max_bits = 64; // We don't expect the number to be larger.
5520      std::bitset<max_bits> b(obj);
5521      _OUT << "\"";
5522      if (obj == 0) _OUT << "0";
5523      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5524          if (b[i] == 1) {
5525              bitCount++;
5526              if (bitCount < b.count())
5527                  _OUT << VkCommandBufferUsageFlagBits_map[1ULL<<i] << " | ";
5528              else
5529                  _OUT << VkCommandBufferUsageFlagBits_map[1ULL<<i];
5530          }
5531      }
5532      if (commaNeeded)
5533        _OUT << "\"" << ",";
5534      else
5535        _OUT << "\""<< "";
5536      _OUT << std::endl;
5537 }
5538 static void print_VkCommandBufferUsageFlags(const VkCommandBufferUsageFlags * obj, const std::string& str, bool commaNeeded=true) {
5539      PRINT_SPACE
5540      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5541      const int max_bits = 64; // We don't expect the number to be larger.
5542      std::bitset<max_bits> b(obj);
5543      _OUT << "\"";
5544      if (obj == 0) _OUT << "0";
5545      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5546          if (b[i] == 1) {
5547              bitCount++;
5548              if (bitCount < b.count())
5549                  _OUT << VkCommandBufferUsageFlagBits_map[1ULL<<i] << " | ";
5550              else
5551                  _OUT << VkCommandBufferUsageFlagBits_map[1ULL<<i];
5552          }
5553      }
5554      if (commaNeeded)
5555        _OUT << "\"" << ",";
5556      else
5557        _OUT << "\""<< "";
5558      _OUT << std::endl;
5559 }
5560
5561 static void print_VkQueryControlFlags(VkQueryControlFlags obj, const std::string& str, bool commaNeeded=true) {
5562      PRINT_SPACE
5563      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5564      const int max_bits = 64; // We don't expect the number to be larger.
5565      std::bitset<max_bits> b(obj);
5566      _OUT << "\"";
5567      if (obj == 0) _OUT << "0";
5568      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5569          if (b[i] == 1) {
5570              bitCount++;
5571              if (bitCount < b.count())
5572                  _OUT << VkQueryControlFlagBits_map[1ULL<<i] << " | ";
5573              else
5574                  _OUT << VkQueryControlFlagBits_map[1ULL<<i];
5575          }
5576      }
5577      if (commaNeeded)
5578        _OUT << "\"" << ",";
5579      else
5580        _OUT << "\""<< "";
5581      _OUT << std::endl;
5582 }
5583 static void print_VkQueryControlFlags(const VkQueryControlFlags * obj, const std::string& str, bool commaNeeded=true) {
5584      PRINT_SPACE
5585      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5586      const int max_bits = 64; // We don't expect the number to be larger.
5587      std::bitset<max_bits> b(obj);
5588      _OUT << "\"";
5589      if (obj == 0) _OUT << "0";
5590      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5591          if (b[i] == 1) {
5592              bitCount++;
5593              if (bitCount < b.count())
5594                  _OUT << VkQueryControlFlagBits_map[1ULL<<i] << " | ";
5595              else
5596                  _OUT << VkQueryControlFlagBits_map[1ULL<<i];
5597          }
5598      }
5599      if (commaNeeded)
5600        _OUT << "\"" << ",";
5601      else
5602        _OUT << "\""<< "";
5603      _OUT << std::endl;
5604 }
5605
5606 static void print_VkCommandBufferResetFlags(VkCommandBufferResetFlags obj, const std::string& str, bool commaNeeded=true) {
5607      PRINT_SPACE
5608      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5609      const int max_bits = 64; // We don't expect the number to be larger.
5610      std::bitset<max_bits> b(obj);
5611      _OUT << "\"";
5612      if (obj == 0) _OUT << "0";
5613      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5614          if (b[i] == 1) {
5615              bitCount++;
5616              if (bitCount < b.count())
5617                  _OUT << VkCommandBufferResetFlagBits_map[1ULL<<i] << " | ";
5618              else
5619                  _OUT << VkCommandBufferResetFlagBits_map[1ULL<<i];
5620          }
5621      }
5622      if (commaNeeded)
5623        _OUT << "\"" << ",";
5624      else
5625        _OUT << "\""<< "";
5626      _OUT << std::endl;
5627 }
5628 static void print_VkCommandBufferResetFlags(const VkCommandBufferResetFlags * obj, const std::string& str, bool commaNeeded=true) {
5629      PRINT_SPACE
5630      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5631      const int max_bits = 64; // We don't expect the number to be larger.
5632      std::bitset<max_bits> b(obj);
5633      _OUT << "\"";
5634      if (obj == 0) _OUT << "0";
5635      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5636          if (b[i] == 1) {
5637              bitCount++;
5638              if (bitCount < b.count())
5639                  _OUT << VkCommandBufferResetFlagBits_map[1ULL<<i] << " | ";
5640              else
5641                  _OUT << VkCommandBufferResetFlagBits_map[1ULL<<i];
5642          }
5643      }
5644      if (commaNeeded)
5645        _OUT << "\"" << ",";
5646      else
5647        _OUT << "\""<< "";
5648      _OUT << std::endl;
5649 }
5650
5651 static void print_VkStencilFaceFlags(VkStencilFaceFlags obj, const std::string& str, bool commaNeeded=true) {
5652      PRINT_SPACE
5653      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5654      const int max_bits = 64; // We don't expect the number to be larger.
5655      std::bitset<max_bits> b(obj);
5656      _OUT << "\"";
5657      if (obj == 0) _OUT << "0";
5658      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5659          if (b[i] == 1) {
5660              bitCount++;
5661              if (bitCount < b.count())
5662                  _OUT << VkStencilFaceFlagBits_map[1ULL<<i] << " | ";
5663              else
5664                  _OUT << VkStencilFaceFlagBits_map[1ULL<<i];
5665          }
5666      }
5667      if (commaNeeded)
5668        _OUT << "\"" << ",";
5669      else
5670        _OUT << "\""<< "";
5671      _OUT << std::endl;
5672 }
5673 static void print_VkStencilFaceFlags(const VkStencilFaceFlags * obj, const std::string& str, bool commaNeeded=true) {
5674      PRINT_SPACE
5675      if (str != "") _OUT << "\"" << str << "\"" << " : ";
5676      const int max_bits = 64; // We don't expect the number to be larger.
5677      std::bitset<max_bits> b(obj);
5678      _OUT << "\"";
5679      if (obj == 0) _OUT << "0";
5680      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
5681          if (b[i] == 1) {
5682              bitCount++;
5683              if (bitCount < b.count())
5684                  _OUT << VkStencilFaceFlagBits_map[1ULL<<i] << " | ";
5685              else
5686                  _OUT << VkStencilFaceFlagBits_map[1ULL<<i];
5687          }
5688      }
5689      if (commaNeeded)
5690        _OUT << "\"" << ",";
5691      else
5692        _OUT << "\""<< "";
5693      _OUT << std::endl;
5694 }
5695
5696 static void print_VkExtent2D(VkExtent2D obj, const std::string& s, bool commaNeeded=true) {
5697      PRINT_SPACE
5698      _OUT << "{" << std::endl;
5699      INDENT(4);
5700
5701      print_uint32_t(obj.width, "width", 1);
5702
5703      print_uint32_t(obj.height, "height", 0);
5704
5705      INDENT(-4);
5706      PRINT_SPACE
5707      if (commaNeeded)
5708          _OUT << "}," << std::endl;
5709      else
5710          _OUT << "}" << std::endl;
5711 }
5712 static void print_VkExtent2D(const VkExtent2D * obj, const std::string& s, bool commaNeeded=true) {
5713      PRINT_SPACE
5714      _OUT << "{" << std::endl;
5715      INDENT(4);
5716
5717      print_uint32_t(obj->width, "width", 1);
5718
5719      print_uint32_t(obj->height, "height", 0);
5720
5721      INDENT(-4);
5722      PRINT_SPACE
5723      if (commaNeeded)
5724          _OUT << "}," << std::endl;
5725      else
5726          _OUT << "}" << std::endl;
5727 }
5728
5729 static void print_VkExtent3D(VkExtent3D obj, const std::string& s, bool commaNeeded=true) {
5730      PRINT_SPACE
5731      _OUT << "{" << std::endl;
5732      INDENT(4);
5733
5734      print_uint32_t(obj.width, "width", 1);
5735
5736      print_uint32_t(obj.height, "height", 1);
5737
5738      print_uint32_t(obj.depth, "depth", 0);
5739
5740      INDENT(-4);
5741      PRINT_SPACE
5742      if (commaNeeded)
5743          _OUT << "}," << std::endl;
5744      else
5745          _OUT << "}" << std::endl;
5746 }
5747 static void print_VkExtent3D(const VkExtent3D * obj, const std::string& s, bool commaNeeded=true) {
5748      PRINT_SPACE
5749      _OUT << "{" << std::endl;
5750      INDENT(4);
5751
5752      print_uint32_t(obj->width, "width", 1);
5753
5754      print_uint32_t(obj->height, "height", 1);
5755
5756      print_uint32_t(obj->depth, "depth", 0);
5757
5758      INDENT(-4);
5759      PRINT_SPACE
5760      if (commaNeeded)
5761          _OUT << "}," << std::endl;
5762      else
5763          _OUT << "}" << std::endl;
5764 }
5765
5766 static void print_VkOffset2D(VkOffset2D obj, const std::string& s, bool commaNeeded=true) {
5767      PRINT_SPACE
5768      _OUT << "{" << std::endl;
5769      INDENT(4);
5770
5771      print_int32_t(obj.x, "x", 1);
5772
5773      print_int32_t(obj.y, "y", 0);
5774
5775      INDENT(-4);
5776      PRINT_SPACE
5777      if (commaNeeded)
5778          _OUT << "}," << std::endl;
5779      else
5780          _OUT << "}" << std::endl;
5781 }
5782 static void print_VkOffset2D(const VkOffset2D * obj, const std::string& s, bool commaNeeded=true) {
5783      PRINT_SPACE
5784      _OUT << "{" << std::endl;
5785      INDENT(4);
5786
5787      print_int32_t(obj->x, "x", 1);
5788
5789      print_int32_t(obj->y, "y", 0);
5790
5791      INDENT(-4);
5792      PRINT_SPACE
5793      if (commaNeeded)
5794          _OUT << "}," << std::endl;
5795      else
5796          _OUT << "}" << std::endl;
5797 }
5798
5799 static void print_VkOffset3D(VkOffset3D obj, const std::string& s, bool commaNeeded=true) {
5800      PRINT_SPACE
5801      _OUT << "{" << std::endl;
5802      INDENT(4);
5803
5804      print_int32_t(obj.x, "x", 1);
5805
5806      print_int32_t(obj.y, "y", 1);
5807
5808      print_int32_t(obj.z, "z", 0);
5809
5810      INDENT(-4);
5811      PRINT_SPACE
5812      if (commaNeeded)
5813          _OUT << "}," << std::endl;
5814      else
5815          _OUT << "}" << std::endl;
5816 }
5817 static void print_VkOffset3D(const VkOffset3D * obj, const std::string& s, bool commaNeeded=true) {
5818      PRINT_SPACE
5819      _OUT << "{" << std::endl;
5820      INDENT(4);
5821
5822      print_int32_t(obj->x, "x", 1);
5823
5824      print_int32_t(obj->y, "y", 1);
5825
5826      print_int32_t(obj->z, "z", 0);
5827
5828      INDENT(-4);
5829      PRINT_SPACE
5830      if (commaNeeded)
5831          _OUT << "}," << std::endl;
5832      else
5833          _OUT << "}" << std::endl;
5834 }
5835
5836 static void print_VkRect2D(VkRect2D obj, const std::string& s, bool commaNeeded=true) {
5837      PRINT_SPACE
5838      _OUT << "{" << std::endl;
5839      INDENT(4);
5840
5841      PRINT_SPACE
5842      _OUT << "\"offset\": " << std::endl;
5843      {
5844            print_VkOffset2D(obj.offset, "offset", 1);
5845      }
5846
5847      PRINT_SPACE
5848      _OUT << "\"extent\": " << std::endl;
5849      {
5850            print_VkExtent2D(obj.extent, "extent", 0);
5851      }
5852
5853      INDENT(-4);
5854      PRINT_SPACE
5855      if (commaNeeded)
5856          _OUT << "}," << std::endl;
5857      else
5858          _OUT << "}" << std::endl;
5859 }
5860 static void print_VkRect2D(const VkRect2D * obj, const std::string& s, bool commaNeeded=true) {
5861      PRINT_SPACE
5862      _OUT << "{" << std::endl;
5863      INDENT(4);
5864
5865      PRINT_SPACE
5866      _OUT << "\"offset\": " << std::endl;
5867      {
5868            print_VkOffset2D(obj->offset, "offset", 1);
5869      }
5870
5871      PRINT_SPACE
5872      _OUT << "\"extent\": " << std::endl;
5873      {
5874            print_VkExtent2D(obj->extent, "extent", 0);
5875      }
5876
5877      INDENT(-4);
5878      PRINT_SPACE
5879      if (commaNeeded)
5880          _OUT << "}," << std::endl;
5881      else
5882          _OUT << "}" << std::endl;
5883 }
5884
5885 static void print_VkBaseInStructure(VkBaseInStructure obj, const std::string& s, bool commaNeeded=true) {
5886      PRINT_SPACE
5887      _OUT << "{" << std::endl;
5888      INDENT(4);
5889
5890      print_VkStructureType(obj.sType, "sType", 1);
5891
5892       if (obj.pNext) {
5893          dumpPNextChain(obj.pNext);
5894       } else {
5895          PRINT_SPACE
5896          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
5897      }
5898
5899      INDENT(-4);
5900      PRINT_SPACE
5901      if (commaNeeded)
5902          _OUT << "}," << std::endl;
5903      else
5904          _OUT << "}" << std::endl;
5905 }
5906 static void print_VkBaseInStructure(const VkBaseInStructure * obj, const std::string& s, bool commaNeeded=true) {
5907      PRINT_SPACE
5908      _OUT << "{" << std::endl;
5909      INDENT(4);
5910
5911      print_VkStructureType(obj->sType, "sType", 1);
5912
5913       if (obj->pNext) {
5914          dumpPNextChain(obj->pNext);
5915       } else {
5916          PRINT_SPACE
5917          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
5918      }
5919
5920      INDENT(-4);
5921      PRINT_SPACE
5922      if (commaNeeded)
5923          _OUT << "}," << std::endl;
5924      else
5925          _OUT << "}" << std::endl;
5926 }
5927
5928 static void print_VkBaseOutStructure(VkBaseOutStructure obj, const std::string& s, bool commaNeeded=true) {
5929      PRINT_SPACE
5930      _OUT << "{" << std::endl;
5931      INDENT(4);
5932
5933      print_VkStructureType(obj.sType, "sType", 1);
5934
5935       if (obj.pNext) {
5936          dumpPNextChain(obj.pNext);
5937       } else {
5938          PRINT_SPACE
5939          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
5940      }
5941
5942      INDENT(-4);
5943      PRINT_SPACE
5944      if (commaNeeded)
5945          _OUT << "}," << std::endl;
5946      else
5947          _OUT << "}" << std::endl;
5948 }
5949 static void print_VkBaseOutStructure(const VkBaseOutStructure * obj, const std::string& s, bool commaNeeded=true) {
5950      PRINT_SPACE
5951      _OUT << "{" << std::endl;
5952      INDENT(4);
5953
5954      print_VkStructureType(obj->sType, "sType", 1);
5955
5956       if (obj->pNext) {
5957          dumpPNextChain(obj->pNext);
5958       } else {
5959          PRINT_SPACE
5960          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
5961      }
5962
5963      INDENT(-4);
5964      PRINT_SPACE
5965      if (commaNeeded)
5966          _OUT << "}," << std::endl;
5967      else
5968          _OUT << "}" << std::endl;
5969 }
5970
5971 static void print_VkBufferMemoryBarrier(VkBufferMemoryBarrier obj, const std::string& s, bool commaNeeded=true) {
5972      PRINT_SPACE
5973      _OUT << "{" << std::endl;
5974      INDENT(4);
5975
5976      print_VkStructureType(obj.sType, "sType", 1);
5977
5978       if (obj.pNext) {
5979          dumpPNextChain(obj.pNext);
5980       } else {
5981          PRINT_SPACE
5982          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
5983      }
5984
5985      print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1);
5986
5987      print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 1);
5988
5989      print_uint32_t(obj.srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
5990
5991      print_uint32_t(obj.dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
5992
5993      // CTS : required value
5994      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl;
5995
5996      print_VkDeviceSize(obj.offset, "offset", 1);
5997
5998      print_VkDeviceSize(obj.size, "size", 0);
5999
6000      INDENT(-4);
6001      PRINT_SPACE
6002      if (commaNeeded)
6003          _OUT << "}," << std::endl;
6004      else
6005          _OUT << "}" << std::endl;
6006 }
6007 static void print_VkBufferMemoryBarrier(const VkBufferMemoryBarrier * obj, const std::string& s, bool commaNeeded=true) {
6008      PRINT_SPACE
6009      _OUT << "{" << std::endl;
6010      INDENT(4);
6011
6012      print_VkStructureType(obj->sType, "sType", 1);
6013
6014       if (obj->pNext) {
6015          dumpPNextChain(obj->pNext);
6016       } else {
6017          PRINT_SPACE
6018          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
6019      }
6020
6021      print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1);
6022
6023      print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 1);
6024
6025      print_uint32_t(obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
6026
6027      print_uint32_t(obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
6028
6029      // CTS : required value
6030      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl;
6031
6032      print_VkDeviceSize(obj->offset, "offset", 1);
6033
6034      print_VkDeviceSize(obj->size, "size", 0);
6035
6036      INDENT(-4);
6037      PRINT_SPACE
6038      if (commaNeeded)
6039          _OUT << "}," << std::endl;
6040      else
6041          _OUT << "}" << std::endl;
6042 }
6043
6044 static void print_VkDispatchIndirectCommand(VkDispatchIndirectCommand obj, const std::string& s, bool commaNeeded=true) {
6045      PRINT_SPACE
6046      _OUT << "{" << std::endl;
6047      INDENT(4);
6048
6049      print_uint32_t(obj.x, "x", 1);
6050
6051      print_uint32_t(obj.y, "y", 1);
6052
6053      print_uint32_t(obj.z, "z", 0);
6054
6055      INDENT(-4);
6056      PRINT_SPACE
6057      if (commaNeeded)
6058          _OUT << "}," << std::endl;
6059      else
6060          _OUT << "}" << std::endl;
6061 }
6062 static void print_VkDispatchIndirectCommand(const VkDispatchIndirectCommand * obj, const std::string& s, bool commaNeeded=true) {
6063      PRINT_SPACE
6064      _OUT << "{" << std::endl;
6065      INDENT(4);
6066
6067      print_uint32_t(obj->x, "x", 1);
6068
6069      print_uint32_t(obj->y, "y", 1);
6070
6071      print_uint32_t(obj->z, "z", 0);
6072
6073      INDENT(-4);
6074      PRINT_SPACE
6075      if (commaNeeded)
6076          _OUT << "}," << std::endl;
6077      else
6078          _OUT << "}" << std::endl;
6079 }
6080
6081 static void print_VkDrawIndexedIndirectCommand(VkDrawIndexedIndirectCommand obj, const std::string& s, bool commaNeeded=true) {
6082      PRINT_SPACE
6083      _OUT << "{" << std::endl;
6084      INDENT(4);
6085
6086      print_uint32_t(obj.indexCount, "indexCount", 1);
6087
6088      print_uint32_t(obj.instanceCount, "instanceCount", 1);
6089
6090      print_uint32_t(obj.firstIndex, "firstIndex", 1);
6091
6092      print_int32_t(obj.vertexOffset, "vertexOffset", 1);
6093
6094      print_uint32_t(obj.firstInstance, "firstInstance", 0);
6095
6096      INDENT(-4);
6097      PRINT_SPACE
6098      if (commaNeeded)
6099          _OUT << "}," << std::endl;
6100      else
6101          _OUT << "}" << std::endl;
6102 }
6103 static void print_VkDrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand * obj, const std::string& s, bool commaNeeded=true) {
6104      PRINT_SPACE
6105      _OUT << "{" << std::endl;
6106      INDENT(4);
6107
6108      print_uint32_t(obj->indexCount, "indexCount", 1);
6109
6110      print_uint32_t(obj->instanceCount, "instanceCount", 1);
6111
6112      print_uint32_t(obj->firstIndex, "firstIndex", 1);
6113
6114      print_int32_t(obj->vertexOffset, "vertexOffset", 1);
6115
6116      print_uint32_t(obj->firstInstance, "firstInstance", 0);
6117
6118      INDENT(-4);
6119      PRINT_SPACE
6120      if (commaNeeded)
6121          _OUT << "}," << std::endl;
6122      else
6123          _OUT << "}" << std::endl;
6124 }
6125
6126 static void print_VkDrawIndirectCommand(VkDrawIndirectCommand obj, const std::string& s, bool commaNeeded=true) {
6127      PRINT_SPACE
6128      _OUT << "{" << std::endl;
6129      INDENT(4);
6130
6131      print_uint32_t(obj.vertexCount, "vertexCount", 1);
6132
6133      print_uint32_t(obj.instanceCount, "instanceCount", 1);
6134
6135      print_uint32_t(obj.firstVertex, "firstVertex", 1);
6136
6137      print_uint32_t(obj.firstInstance, "firstInstance", 0);
6138
6139      INDENT(-4);
6140      PRINT_SPACE
6141      if (commaNeeded)
6142          _OUT << "}," << std::endl;
6143      else
6144          _OUT << "}" << std::endl;
6145 }
6146 static void print_VkDrawIndirectCommand(const VkDrawIndirectCommand * obj, const std::string& s, bool commaNeeded=true) {
6147      PRINT_SPACE
6148      _OUT << "{" << std::endl;
6149      INDENT(4);
6150
6151      print_uint32_t(obj->vertexCount, "vertexCount", 1);
6152
6153      print_uint32_t(obj->instanceCount, "instanceCount", 1);
6154
6155      print_uint32_t(obj->firstVertex, "firstVertex", 1);
6156
6157      print_uint32_t(obj->firstInstance, "firstInstance", 0);
6158
6159      INDENT(-4);
6160      PRINT_SPACE
6161      if (commaNeeded)
6162          _OUT << "}," << std::endl;
6163      else
6164          _OUT << "}" << std::endl;
6165 }
6166
6167 static void print_VkImageSubresourceRange(VkImageSubresourceRange obj, const std::string& s, bool commaNeeded=true) {
6168      PRINT_SPACE
6169      _OUT << "{" << std::endl;
6170      INDENT(4);
6171
6172      print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 1);
6173
6174      print_uint32_t(obj.baseMipLevel, "baseMipLevel", 1);
6175
6176      print_uint32_t(obj.levelCount, "levelCount", 1);
6177
6178      print_uint32_t(obj.baseArrayLayer, "baseArrayLayer", 1);
6179
6180      print_uint32_t(obj.layerCount, "layerCount", 0);
6181
6182      INDENT(-4);
6183      PRINT_SPACE
6184      if (commaNeeded)
6185          _OUT << "}," << std::endl;
6186      else
6187          _OUT << "}" << std::endl;
6188 }
6189 static void print_VkImageSubresourceRange(const VkImageSubresourceRange * obj, const std::string& s, bool commaNeeded=true) {
6190      PRINT_SPACE
6191      _OUT << "{" << std::endl;
6192      INDENT(4);
6193
6194      print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 1);
6195
6196      print_uint32_t(obj->baseMipLevel, "baseMipLevel", 1);
6197
6198      print_uint32_t(obj->levelCount, "levelCount", 1);
6199
6200      print_uint32_t(obj->baseArrayLayer, "baseArrayLayer", 1);
6201
6202      print_uint32_t(obj->layerCount, "layerCount", 0);
6203
6204      INDENT(-4);
6205      PRINT_SPACE
6206      if (commaNeeded)
6207          _OUT << "}," << std::endl;
6208      else
6209          _OUT << "}" << std::endl;
6210 }
6211
6212 static void print_VkImageMemoryBarrier(VkImageMemoryBarrier obj, const std::string& s, bool commaNeeded=true) {
6213      PRINT_SPACE
6214      _OUT << "{" << std::endl;
6215      INDENT(4);
6216
6217      print_VkStructureType(obj.sType, "sType", 1);
6218
6219       if (obj.pNext) {
6220          dumpPNextChain(obj.pNext);
6221       } else {
6222          PRINT_SPACE
6223          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
6224      }
6225
6226      print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1);
6227
6228      print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 1);
6229
6230      print_VkImageLayout(obj.oldLayout, "oldLayout", 1);
6231
6232      print_VkImageLayout(obj.newLayout, "newLayout", 1);
6233
6234      print_uint32_t(obj.srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
6235
6236      print_uint32_t(obj.dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
6237
6238      // CTS : required value
6239      PRINT_SPACE    _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl;
6240
6241      PRINT_SPACE
6242      _OUT << "\"subresourceRange\": " << std::endl;
6243      {
6244            print_VkImageSubresourceRange(obj.subresourceRange, "subresourceRange", 0);
6245      }
6246
6247      INDENT(-4);
6248      PRINT_SPACE
6249      if (commaNeeded)
6250          _OUT << "}," << std::endl;
6251      else
6252          _OUT << "}" << std::endl;
6253 }
6254 static void print_VkImageMemoryBarrier(const VkImageMemoryBarrier * obj, const std::string& s, bool commaNeeded=true) {
6255      PRINT_SPACE
6256      _OUT << "{" << std::endl;
6257      INDENT(4);
6258
6259      print_VkStructureType(obj->sType, "sType", 1);
6260
6261       if (obj->pNext) {
6262          dumpPNextChain(obj->pNext);
6263       } else {
6264          PRINT_SPACE
6265          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
6266      }
6267
6268      print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1);
6269
6270      print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 1);
6271
6272      print_VkImageLayout(obj->oldLayout, "oldLayout", 1);
6273
6274      print_VkImageLayout(obj->newLayout, "newLayout", 1);
6275
6276      print_uint32_t(obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
6277
6278      print_uint32_t(obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
6279
6280      // CTS : required value
6281      PRINT_SPACE    _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl;
6282
6283      PRINT_SPACE
6284      _OUT << "\"subresourceRange\": " << std::endl;
6285      {
6286            print_VkImageSubresourceRange(obj->subresourceRange, "subresourceRange", 0);
6287      }
6288
6289      INDENT(-4);
6290      PRINT_SPACE
6291      if (commaNeeded)
6292          _OUT << "}," << std::endl;
6293      else
6294          _OUT << "}" << std::endl;
6295 }
6296
6297 static void print_VkMemoryBarrier(VkMemoryBarrier obj, const std::string& s, bool commaNeeded=true) {
6298      PRINT_SPACE
6299      _OUT << "{" << std::endl;
6300      INDENT(4);
6301
6302      print_VkStructureType(obj.sType, "sType", 1);
6303
6304       if (obj.pNext) {
6305          dumpPNextChain(obj.pNext);
6306       } else {
6307          PRINT_SPACE
6308          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
6309      }
6310
6311      print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1);
6312
6313      print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 0);
6314
6315      INDENT(-4);
6316      PRINT_SPACE
6317      if (commaNeeded)
6318          _OUT << "}," << std::endl;
6319      else
6320          _OUT << "}" << std::endl;
6321 }
6322 static void print_VkMemoryBarrier(const VkMemoryBarrier * obj, const std::string& s, bool commaNeeded=true) {
6323      PRINT_SPACE
6324      _OUT << "{" << std::endl;
6325      INDENT(4);
6326
6327      print_VkStructureType(obj->sType, "sType", 1);
6328
6329       if (obj->pNext) {
6330          dumpPNextChain(obj->pNext);
6331       } else {
6332          PRINT_SPACE
6333          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
6334      }
6335
6336      print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1);
6337
6338      print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 0);
6339
6340      INDENT(-4);
6341      PRINT_SPACE
6342      if (commaNeeded)
6343          _OUT << "}," << std::endl;
6344      else
6345          _OUT << "}" << std::endl;
6346 }
6347
6348 static void print_VkPipelineCacheHeaderVersionOne(VkPipelineCacheHeaderVersionOne obj, const std::string& s, bool commaNeeded=true) {
6349      PRINT_SPACE
6350      _OUT << "{" << std::endl;
6351      INDENT(4);
6352
6353      print_uint32_t(obj.headerSize, "headerSize", 1);
6354
6355      print_VkPipelineCacheHeaderVersion(obj.headerVersion, "headerVersion", 1);
6356
6357      print_uint32_t(obj.vendorID, "vendorID", 1);
6358
6359      print_uint32_t(obj.deviceID, "deviceID", 1);
6360
6361      PRINT_SPACE
6362      _OUT << "\"pipelineCacheUUID\":" << std::endl;
6363      PRINT_SPACE
6364      if (obj.pipelineCacheUUID) {
6365        _OUT << "[" << std::endl;
6366        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
6367            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
6368            print_uint8_t(obj.pipelineCacheUUID[i], "", isCommaNeeded);
6369        }
6370        PRINT_SPACE
6371        _OUT << "]" << "" << std::endl;
6372      } else {
6373        _OUT << "\"NULL\"" << "" << std::endl;
6374      }
6375
6376      INDENT(-4);
6377      PRINT_SPACE
6378      if (commaNeeded)
6379          _OUT << "}," << std::endl;
6380      else
6381          _OUT << "}" << std::endl;
6382 }
6383 static void print_VkPipelineCacheHeaderVersionOne(const VkPipelineCacheHeaderVersionOne * obj, const std::string& s, bool commaNeeded=true) {
6384      PRINT_SPACE
6385      _OUT << "{" << std::endl;
6386      INDENT(4);
6387
6388      print_uint32_t(obj->headerSize, "headerSize", 1);
6389
6390      print_VkPipelineCacheHeaderVersion(obj->headerVersion, "headerVersion", 1);
6391
6392      print_uint32_t(obj->vendorID, "vendorID", 1);
6393
6394      print_uint32_t(obj->deviceID, "deviceID", 1);
6395
6396      PRINT_SPACE
6397      _OUT << "\"pipelineCacheUUID\":" << std::endl;
6398      PRINT_SPACE
6399      if (obj->pipelineCacheUUID) {
6400        _OUT << "[" << std::endl;
6401        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
6402            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
6403            print_uint8_t(obj->pipelineCacheUUID[i], "", isCommaNeeded);
6404        }
6405        PRINT_SPACE
6406        _OUT << "]" << "" << std::endl;
6407      } else {
6408        _OUT << "\"NULL\"" << "" << std::endl;
6409      }
6410
6411      INDENT(-4);
6412      PRINT_SPACE
6413      if (commaNeeded)
6414          _OUT << "}," << std::endl;
6415      else
6416          _OUT << "}" << std::endl;
6417 }
6418
6419 static void print_VkAllocationCallbacks(VkAllocationCallbacks obj, const std::string& s, bool commaNeeded=true) {
6420      PRINT_SPACE
6421      _OUT << "{" << std::endl;
6422      INDENT(4);
6423
6424      /** Note: Ignoring void* data. **/
6425
6426      /** Note: Ignoring function pointer (PFN_vkAllocationFunction). **/
6427
6428      /** Note: Ignoring function pointer (PFN_vkReallocationFunction). **/
6429
6430      /** Note: Ignoring function pointer (PFN_vkFreeFunction). **/
6431
6432      /** Note: Ignoring function pointer (PFN_vkInternalAllocationNotification). **/
6433
6434      /** Note: Ignoring function pointer (PFN_vkInternalFreeNotification). **/
6435
6436      INDENT(-4);
6437      PRINT_SPACE
6438      if (commaNeeded)
6439          _OUT << "}," << std::endl;
6440      else
6441          _OUT << "}" << std::endl;
6442 }
6443 static void print_VkAllocationCallbacks(const VkAllocationCallbacks * obj, const std::string& s, bool commaNeeded=true) {
6444      PRINT_SPACE
6445      _OUT << "{" << std::endl;
6446      INDENT(4);
6447
6448      /** Note: Ignoring void* data. **/
6449
6450      /** Note: Ignoring function pointer (PFN_vkAllocationFunction). **/
6451
6452      /** Note: Ignoring function pointer (PFN_vkReallocationFunction). **/
6453
6454      /** Note: Ignoring function pointer (PFN_vkFreeFunction). **/
6455
6456      /** Note: Ignoring function pointer (PFN_vkInternalAllocationNotification). **/
6457
6458      /** Note: Ignoring function pointer (PFN_vkInternalFreeNotification). **/
6459
6460      INDENT(-4);
6461      PRINT_SPACE
6462      if (commaNeeded)
6463          _OUT << "}," << std::endl;
6464      else
6465          _OUT << "}" << std::endl;
6466 }
6467
6468 static void print_VkApplicationInfo(VkApplicationInfo obj, const std::string& s, bool commaNeeded=true) {
6469      PRINT_SPACE
6470      _OUT << "{" << std::endl;
6471      INDENT(4);
6472
6473      print_VkStructureType(obj.sType, "sType", 1);
6474
6475       if (obj.pNext) {
6476          dumpPNextChain(obj.pNext);
6477       } else {
6478          PRINT_SPACE
6479          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
6480      }
6481
6482      print_char(obj.pApplicationName, "pApplicationName", 1);
6483
6484      print_uint32_t(obj.applicationVersion, "applicationVersion", 1);
6485
6486      print_char(obj.pEngineName, "pEngineName", 1);
6487
6488      print_uint32_t(obj.engineVersion, "engineVersion", 1);
6489
6490      print_uint32_t(obj.apiVersion, "apiVersion", 0);
6491
6492      INDENT(-4);
6493      PRINT_SPACE
6494      if (commaNeeded)
6495          _OUT << "}," << std::endl;
6496      else
6497          _OUT << "}" << std::endl;
6498 }
6499 static void print_VkApplicationInfo(const VkApplicationInfo * obj, const std::string& s, bool commaNeeded=true) {
6500      PRINT_SPACE
6501      _OUT << "{" << std::endl;
6502      INDENT(4);
6503
6504      print_VkStructureType(obj->sType, "sType", 1);
6505
6506       if (obj->pNext) {
6507          dumpPNextChain(obj->pNext);
6508       } else {
6509          PRINT_SPACE
6510          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
6511      }
6512
6513      print_char(obj->pApplicationName, "pApplicationName", 1);
6514
6515      print_uint32_t(obj->applicationVersion, "applicationVersion", 1);
6516
6517      print_char(obj->pEngineName, "pEngineName", 1);
6518
6519      print_uint32_t(obj->engineVersion, "engineVersion", 1);
6520
6521      print_uint32_t(obj->apiVersion, "apiVersion", 0);
6522
6523      INDENT(-4);
6524      PRINT_SPACE
6525      if (commaNeeded)
6526          _OUT << "}," << std::endl;
6527      else
6528          _OUT << "}" << std::endl;
6529 }
6530
6531 static void print_VkFormatProperties(VkFormatProperties obj, const std::string& s, bool commaNeeded=true) {
6532      PRINT_SPACE
6533      _OUT << "{" << std::endl;
6534      INDENT(4);
6535
6536      print_VkFormatFeatureFlags(obj.linearTilingFeatures, "linearTilingFeatures", 1);
6537
6538      print_VkFormatFeatureFlags(obj.optimalTilingFeatures, "optimalTilingFeatures", 1);
6539
6540      print_VkFormatFeatureFlags(obj.bufferFeatures, "bufferFeatures", 0);
6541
6542      INDENT(-4);
6543      PRINT_SPACE
6544      if (commaNeeded)
6545          _OUT << "}," << std::endl;
6546      else
6547          _OUT << "}" << std::endl;
6548 }
6549 static void print_VkFormatProperties(const VkFormatProperties * obj, const std::string& s, bool commaNeeded=true) {
6550      PRINT_SPACE
6551      _OUT << "{" << std::endl;
6552      INDENT(4);
6553
6554      print_VkFormatFeatureFlags(obj->linearTilingFeatures, "linearTilingFeatures", 1);
6555
6556      print_VkFormatFeatureFlags(obj->optimalTilingFeatures, "optimalTilingFeatures", 1);
6557
6558      print_VkFormatFeatureFlags(obj->bufferFeatures, "bufferFeatures", 0);
6559
6560      INDENT(-4);
6561      PRINT_SPACE
6562      if (commaNeeded)
6563          _OUT << "}," << std::endl;
6564      else
6565          _OUT << "}" << std::endl;
6566 }
6567
6568 static void print_VkImageFormatProperties(VkImageFormatProperties obj, const std::string& s, bool commaNeeded=true) {
6569      PRINT_SPACE
6570      _OUT << "{" << std::endl;
6571      INDENT(4);
6572
6573      PRINT_SPACE
6574      _OUT << "\"maxExtent\": " << std::endl;
6575      {
6576            print_VkExtent3D(obj.maxExtent, "maxExtent", 1);
6577      }
6578
6579      print_uint32_t(obj.maxMipLevels, "maxMipLevels", 1);
6580
6581      print_uint32_t(obj.maxArrayLayers, "maxArrayLayers", 1);
6582
6583      print_VkSampleCountFlags(obj.sampleCounts, "sampleCounts", 1);
6584
6585      print_VkDeviceSize(obj.maxResourceSize, "maxResourceSize", 0);
6586
6587      INDENT(-4);
6588      PRINT_SPACE
6589      if (commaNeeded)
6590          _OUT << "}," << std::endl;
6591      else
6592          _OUT << "}" << std::endl;
6593 }
6594 static void print_VkImageFormatProperties(const VkImageFormatProperties * obj, const std::string& s, bool commaNeeded=true) {
6595      PRINT_SPACE
6596      _OUT << "{" << std::endl;
6597      INDENT(4);
6598
6599      PRINT_SPACE
6600      _OUT << "\"maxExtent\": " << std::endl;
6601      {
6602            print_VkExtent3D(obj->maxExtent, "maxExtent", 1);
6603      }
6604
6605      print_uint32_t(obj->maxMipLevels, "maxMipLevels", 1);
6606
6607      print_uint32_t(obj->maxArrayLayers, "maxArrayLayers", 1);
6608
6609      print_VkSampleCountFlags(obj->sampleCounts, "sampleCounts", 1);
6610
6611      print_VkDeviceSize(obj->maxResourceSize, "maxResourceSize", 0);
6612
6613      INDENT(-4);
6614      PRINT_SPACE
6615      if (commaNeeded)
6616          _OUT << "}," << std::endl;
6617      else
6618          _OUT << "}" << std::endl;
6619 }
6620
6621 static void print_VkInstanceCreateInfo(VkInstanceCreateInfo obj, const std::string& s, bool commaNeeded=true) {
6622      PRINT_SPACE
6623      _OUT << "{" << std::endl;
6624      INDENT(4);
6625
6626      print_VkStructureType(obj.sType, "sType", 1);
6627
6628       if (obj.pNext) {
6629          dumpPNextChain(obj.pNext);
6630       } else {
6631          PRINT_SPACE
6632          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
6633      }
6634
6635      print_VkInstanceCreateFlags(obj.flags, "flags", 1);
6636
6637      PRINT_SPACE
6638      _OUT << "\"pApplicationInfo\": " << std::endl;
6639      if (obj.pApplicationInfo) {
6640            print_VkApplicationInfo(obj.pApplicationInfo, "pApplicationInfo", 1);
6641      }
6642      else
6643      {
6644          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
6645      }
6646
6647      print_uint32_t(obj.enabledLayerCount, "enabledLayerCount", 1);
6648
6649      print_char(obj.ppEnabledLayerNames, "ppEnabledLayerNames", 1);
6650
6651      print_uint32_t(obj.enabledExtensionCount, "enabledExtensionCount", 1);
6652
6653      print_char(obj.ppEnabledExtensionNames, "ppEnabledExtensionNames", 0);
6654
6655      INDENT(-4);
6656      PRINT_SPACE
6657      if (commaNeeded)
6658          _OUT << "}," << std::endl;
6659      else
6660          _OUT << "}" << std::endl;
6661 }
6662 static void print_VkInstanceCreateInfo(const VkInstanceCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
6663      PRINT_SPACE
6664      _OUT << "{" << std::endl;
6665      INDENT(4);
6666
6667      print_VkStructureType(obj->sType, "sType", 1);
6668
6669       if (obj->pNext) {
6670          dumpPNextChain(obj->pNext);
6671       } else {
6672          PRINT_SPACE
6673          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
6674      }
6675
6676      print_VkInstanceCreateFlags(obj->flags, "flags", 1);
6677
6678      PRINT_SPACE
6679      _OUT << "\"pApplicationInfo\": " << std::endl;
6680      if (obj->pApplicationInfo) {
6681            print_VkApplicationInfo(obj->pApplicationInfo, "pApplicationInfo", 1);
6682      }
6683      else
6684      {
6685          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
6686      }
6687
6688      print_uint32_t(obj->enabledLayerCount, "enabledLayerCount", 1);
6689
6690      print_char(obj->ppEnabledLayerNames, "ppEnabledLayerNames", 1);
6691
6692      print_uint32_t(obj->enabledExtensionCount, "enabledExtensionCount", 1);
6693
6694      print_char(obj->ppEnabledExtensionNames, "ppEnabledExtensionNames", 0);
6695
6696      INDENT(-4);
6697      PRINT_SPACE
6698      if (commaNeeded)
6699          _OUT << "}," << std::endl;
6700      else
6701          _OUT << "}" << std::endl;
6702 }
6703
6704 static void print_VkMemoryHeap(VkMemoryHeap obj, const std::string& s, bool commaNeeded=true) {
6705      PRINT_SPACE
6706      _OUT << "{" << std::endl;
6707      INDENT(4);
6708
6709      print_VkDeviceSize(obj.size, "size", 1);
6710
6711      print_VkMemoryHeapFlags(obj.flags, "flags", 0);
6712
6713      INDENT(-4);
6714      PRINT_SPACE
6715      if (commaNeeded)
6716          _OUT << "}," << std::endl;
6717      else
6718          _OUT << "}" << std::endl;
6719 }
6720 static void print_VkMemoryHeap(const VkMemoryHeap * obj, const std::string& s, bool commaNeeded=true) {
6721      PRINT_SPACE
6722      _OUT << "{" << std::endl;
6723      INDENT(4);
6724
6725      print_VkDeviceSize(obj->size, "size", 1);
6726
6727      print_VkMemoryHeapFlags(obj->flags, "flags", 0);
6728
6729      INDENT(-4);
6730      PRINT_SPACE
6731      if (commaNeeded)
6732          _OUT << "}," << std::endl;
6733      else
6734          _OUT << "}" << std::endl;
6735 }
6736
6737 static void print_VkMemoryType(VkMemoryType obj, const std::string& s, bool commaNeeded=true) {
6738      PRINT_SPACE
6739      _OUT << "{" << std::endl;
6740      INDENT(4);
6741
6742      print_VkMemoryPropertyFlags(obj.propertyFlags, "propertyFlags", 1);
6743
6744      print_uint32_t(obj.heapIndex, "heapIndex", 0);
6745
6746      INDENT(-4);
6747      PRINT_SPACE
6748      if (commaNeeded)
6749          _OUT << "}," << std::endl;
6750      else
6751          _OUT << "}" << std::endl;
6752 }
6753 static void print_VkMemoryType(const VkMemoryType * obj, const std::string& s, bool commaNeeded=true) {
6754      PRINT_SPACE
6755      _OUT << "{" << std::endl;
6756      INDENT(4);
6757
6758      print_VkMemoryPropertyFlags(obj->propertyFlags, "propertyFlags", 1);
6759
6760      print_uint32_t(obj->heapIndex, "heapIndex", 0);
6761
6762      INDENT(-4);
6763      PRINT_SPACE
6764      if (commaNeeded)
6765          _OUT << "}," << std::endl;
6766      else
6767          _OUT << "}" << std::endl;
6768 }
6769
6770 static void print_VkPhysicalDeviceFeatures(VkPhysicalDeviceFeatures obj, const std::string& s, bool commaNeeded=true) {
6771      PRINT_SPACE
6772      _OUT << "{" << std::endl;
6773      INDENT(4);
6774
6775      print_VkBool32(obj.robustBufferAccess, "robustBufferAccess", 1);
6776
6777      print_VkBool32(obj.fullDrawIndexUint32, "fullDrawIndexUint32", 1);
6778
6779      print_VkBool32(obj.imageCubeArray, "imageCubeArray", 1);
6780
6781      print_VkBool32(obj.independentBlend, "independentBlend", 1);
6782
6783      print_VkBool32(obj.geometryShader, "geometryShader", 1);
6784
6785      print_VkBool32(obj.tessellationShader, "tessellationShader", 1);
6786
6787      print_VkBool32(obj.sampleRateShading, "sampleRateShading", 1);
6788
6789      print_VkBool32(obj.dualSrcBlend, "dualSrcBlend", 1);
6790
6791      print_VkBool32(obj.logicOp, "logicOp", 1);
6792
6793      print_VkBool32(obj.multiDrawIndirect, "multiDrawIndirect", 1);
6794
6795      print_VkBool32(obj.drawIndirectFirstInstance, "drawIndirectFirstInstance", 1);
6796
6797      print_VkBool32(obj.depthClamp, "depthClamp", 1);
6798
6799      print_VkBool32(obj.depthBiasClamp, "depthBiasClamp", 1);
6800
6801      print_VkBool32(obj.fillModeNonSolid, "fillModeNonSolid", 1);
6802
6803      print_VkBool32(obj.depthBounds, "depthBounds", 1);
6804
6805      print_VkBool32(obj.wideLines, "wideLines", 1);
6806
6807      print_VkBool32(obj.largePoints, "largePoints", 1);
6808
6809      print_VkBool32(obj.alphaToOne, "alphaToOne", 1);
6810
6811      print_VkBool32(obj.multiViewport, "multiViewport", 1);
6812
6813      print_VkBool32(obj.samplerAnisotropy, "samplerAnisotropy", 1);
6814
6815      print_VkBool32(obj.textureCompressionETC2, "textureCompressionETC2", 1);
6816
6817      print_VkBool32(obj.textureCompressionASTC_LDR, "textureCompressionASTC_LDR", 1);
6818
6819      print_VkBool32(obj.textureCompressionBC, "textureCompressionBC", 1);
6820
6821      print_VkBool32(obj.occlusionQueryPrecise, "occlusionQueryPrecise", 1);
6822
6823      print_VkBool32(obj.pipelineStatisticsQuery, "pipelineStatisticsQuery", 1);
6824
6825      print_VkBool32(obj.vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics", 1);
6826
6827      print_VkBool32(obj.fragmentStoresAndAtomics, "fragmentStoresAndAtomics", 1);
6828
6829      print_VkBool32(obj.shaderTessellationAndGeometryPointSize, "shaderTessellationAndGeometryPointSize", 1);
6830
6831      print_VkBool32(obj.shaderImageGatherExtended, "shaderImageGatherExtended", 1);
6832
6833      print_VkBool32(obj.shaderStorageImageExtendedFormats, "shaderStorageImageExtendedFormats", 1);
6834
6835      print_VkBool32(obj.shaderStorageImageMultisample, "shaderStorageImageMultisample", 1);
6836
6837      print_VkBool32(obj.shaderStorageImageReadWithoutFormat, "shaderStorageImageReadWithoutFormat", 1);
6838
6839      print_VkBool32(obj.shaderStorageImageWriteWithoutFormat, "shaderStorageImageWriteWithoutFormat", 1);
6840
6841      print_VkBool32(obj.shaderUniformBufferArrayDynamicIndexing, "shaderUniformBufferArrayDynamicIndexing", 1);
6842
6843      print_VkBool32(obj.shaderSampledImageArrayDynamicIndexing, "shaderSampledImageArrayDynamicIndexing", 1);
6844
6845      print_VkBool32(obj.shaderStorageBufferArrayDynamicIndexing, "shaderStorageBufferArrayDynamicIndexing", 1);
6846
6847      print_VkBool32(obj.shaderStorageImageArrayDynamicIndexing, "shaderStorageImageArrayDynamicIndexing", 1);
6848
6849      print_VkBool32(obj.shaderClipDistance, "shaderClipDistance", 1);
6850
6851      print_VkBool32(obj.shaderCullDistance, "shaderCullDistance", 1);
6852
6853      print_VkBool32(obj.shaderFloat64, "shaderFloat64", 1);
6854
6855      print_VkBool32(obj.shaderInt64, "shaderInt64", 1);
6856
6857      print_VkBool32(obj.shaderInt16, "shaderInt16", 1);
6858
6859      print_VkBool32(obj.shaderResourceResidency, "shaderResourceResidency", 1);
6860
6861      print_VkBool32(obj.shaderResourceMinLod, "shaderResourceMinLod", 1);
6862
6863      print_VkBool32(obj.sparseBinding, "sparseBinding", 1);
6864
6865      print_VkBool32(obj.sparseResidencyBuffer, "sparseResidencyBuffer", 1);
6866
6867      print_VkBool32(obj.sparseResidencyImage2D, "sparseResidencyImage2D", 1);
6868
6869      print_VkBool32(obj.sparseResidencyImage3D, "sparseResidencyImage3D", 1);
6870
6871      print_VkBool32(obj.sparseResidency2Samples, "sparseResidency2Samples", 1);
6872
6873      print_VkBool32(obj.sparseResidency4Samples, "sparseResidency4Samples", 1);
6874
6875      print_VkBool32(obj.sparseResidency8Samples, "sparseResidency8Samples", 1);
6876
6877      print_VkBool32(obj.sparseResidency16Samples, "sparseResidency16Samples", 1);
6878
6879      print_VkBool32(obj.sparseResidencyAliased, "sparseResidencyAliased", 1);
6880
6881      print_VkBool32(obj.variableMultisampleRate, "variableMultisampleRate", 1);
6882
6883      print_VkBool32(obj.inheritedQueries, "inheritedQueries", 0);
6884
6885      INDENT(-4);
6886      PRINT_SPACE
6887      if (commaNeeded)
6888          _OUT << "}," << std::endl;
6889      else
6890          _OUT << "}" << std::endl;
6891 }
6892 static void print_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures * obj, const std::string& s, bool commaNeeded=true) {
6893      PRINT_SPACE
6894      _OUT << "{" << std::endl;
6895      INDENT(4);
6896
6897      print_VkBool32(obj->robustBufferAccess, "robustBufferAccess", 1);
6898
6899      print_VkBool32(obj->fullDrawIndexUint32, "fullDrawIndexUint32", 1);
6900
6901      print_VkBool32(obj->imageCubeArray, "imageCubeArray", 1);
6902
6903      print_VkBool32(obj->independentBlend, "independentBlend", 1);
6904
6905      print_VkBool32(obj->geometryShader, "geometryShader", 1);
6906
6907      print_VkBool32(obj->tessellationShader, "tessellationShader", 1);
6908
6909      print_VkBool32(obj->sampleRateShading, "sampleRateShading", 1);
6910
6911      print_VkBool32(obj->dualSrcBlend, "dualSrcBlend", 1);
6912
6913      print_VkBool32(obj->logicOp, "logicOp", 1);
6914
6915      print_VkBool32(obj->multiDrawIndirect, "multiDrawIndirect", 1);
6916
6917      print_VkBool32(obj->drawIndirectFirstInstance, "drawIndirectFirstInstance", 1);
6918
6919      print_VkBool32(obj->depthClamp, "depthClamp", 1);
6920
6921      print_VkBool32(obj->depthBiasClamp, "depthBiasClamp", 1);
6922
6923      print_VkBool32(obj->fillModeNonSolid, "fillModeNonSolid", 1);
6924
6925      print_VkBool32(obj->depthBounds, "depthBounds", 1);
6926
6927      print_VkBool32(obj->wideLines, "wideLines", 1);
6928
6929      print_VkBool32(obj->largePoints, "largePoints", 1);
6930
6931      print_VkBool32(obj->alphaToOne, "alphaToOne", 1);
6932
6933      print_VkBool32(obj->multiViewport, "multiViewport", 1);
6934
6935      print_VkBool32(obj->samplerAnisotropy, "samplerAnisotropy", 1);
6936
6937      print_VkBool32(obj->textureCompressionETC2, "textureCompressionETC2", 1);
6938
6939      print_VkBool32(obj->textureCompressionASTC_LDR, "textureCompressionASTC_LDR", 1);
6940
6941      print_VkBool32(obj->textureCompressionBC, "textureCompressionBC", 1);
6942
6943      print_VkBool32(obj->occlusionQueryPrecise, "occlusionQueryPrecise", 1);
6944
6945      print_VkBool32(obj->pipelineStatisticsQuery, "pipelineStatisticsQuery", 1);
6946
6947      print_VkBool32(obj->vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics", 1);
6948
6949      print_VkBool32(obj->fragmentStoresAndAtomics, "fragmentStoresAndAtomics", 1);
6950
6951      print_VkBool32(obj->shaderTessellationAndGeometryPointSize, "shaderTessellationAndGeometryPointSize", 1);
6952
6953      print_VkBool32(obj->shaderImageGatherExtended, "shaderImageGatherExtended", 1);
6954
6955      print_VkBool32(obj->shaderStorageImageExtendedFormats, "shaderStorageImageExtendedFormats", 1);
6956
6957      print_VkBool32(obj->shaderStorageImageMultisample, "shaderStorageImageMultisample", 1);
6958
6959      print_VkBool32(obj->shaderStorageImageReadWithoutFormat, "shaderStorageImageReadWithoutFormat", 1);
6960
6961      print_VkBool32(obj->shaderStorageImageWriteWithoutFormat, "shaderStorageImageWriteWithoutFormat", 1);
6962
6963      print_VkBool32(obj->shaderUniformBufferArrayDynamicIndexing, "shaderUniformBufferArrayDynamicIndexing", 1);
6964
6965      print_VkBool32(obj->shaderSampledImageArrayDynamicIndexing, "shaderSampledImageArrayDynamicIndexing", 1);
6966
6967      print_VkBool32(obj->shaderStorageBufferArrayDynamicIndexing, "shaderStorageBufferArrayDynamicIndexing", 1);
6968
6969      print_VkBool32(obj->shaderStorageImageArrayDynamicIndexing, "shaderStorageImageArrayDynamicIndexing", 1);
6970
6971      print_VkBool32(obj->shaderClipDistance, "shaderClipDistance", 1);
6972
6973      print_VkBool32(obj->shaderCullDistance, "shaderCullDistance", 1);
6974
6975      print_VkBool32(obj->shaderFloat64, "shaderFloat64", 1);
6976
6977      print_VkBool32(obj->shaderInt64, "shaderInt64", 1);
6978
6979      print_VkBool32(obj->shaderInt16, "shaderInt16", 1);
6980
6981      print_VkBool32(obj->shaderResourceResidency, "shaderResourceResidency", 1);
6982
6983      print_VkBool32(obj->shaderResourceMinLod, "shaderResourceMinLod", 1);
6984
6985      print_VkBool32(obj->sparseBinding, "sparseBinding", 1);
6986
6987      print_VkBool32(obj->sparseResidencyBuffer, "sparseResidencyBuffer", 1);
6988
6989      print_VkBool32(obj->sparseResidencyImage2D, "sparseResidencyImage2D", 1);
6990
6991      print_VkBool32(obj->sparseResidencyImage3D, "sparseResidencyImage3D", 1);
6992
6993      print_VkBool32(obj->sparseResidency2Samples, "sparseResidency2Samples", 1);
6994
6995      print_VkBool32(obj->sparseResidency4Samples, "sparseResidency4Samples", 1);
6996
6997      print_VkBool32(obj->sparseResidency8Samples, "sparseResidency8Samples", 1);
6998
6999      print_VkBool32(obj->sparseResidency16Samples, "sparseResidency16Samples", 1);
7000
7001      print_VkBool32(obj->sparseResidencyAliased, "sparseResidencyAliased", 1);
7002
7003      print_VkBool32(obj->variableMultisampleRate, "variableMultisampleRate", 1);
7004
7005      print_VkBool32(obj->inheritedQueries, "inheritedQueries", 0);
7006
7007      INDENT(-4);
7008      PRINT_SPACE
7009      if (commaNeeded)
7010          _OUT << "}," << std::endl;
7011      else
7012          _OUT << "}" << std::endl;
7013 }
7014
7015 static void print_VkPhysicalDeviceLimits(VkPhysicalDeviceLimits obj, const std::string& s, bool commaNeeded=true) {
7016      PRINT_SPACE
7017      _OUT << "{" << std::endl;
7018      INDENT(4);
7019
7020      print_uint32_t(obj.maxImageDimension1D, "maxImageDimension1D", 1);
7021
7022      print_uint32_t(obj.maxImageDimension2D, "maxImageDimension2D", 1);
7023
7024      print_uint32_t(obj.maxImageDimension3D, "maxImageDimension3D", 1);
7025
7026      print_uint32_t(obj.maxImageDimensionCube, "maxImageDimensionCube", 1);
7027
7028      print_uint32_t(obj.maxImageArrayLayers, "maxImageArrayLayers", 1);
7029
7030      print_uint32_t(obj.maxTexelBufferElements, "maxTexelBufferElements", 1);
7031
7032      print_uint32_t(obj.maxUniformBufferRange, "maxUniformBufferRange", 1);
7033
7034      print_uint32_t(obj.maxStorageBufferRange, "maxStorageBufferRange", 1);
7035
7036      print_uint32_t(obj.maxPushConstantsSize, "maxPushConstantsSize", 1);
7037
7038      print_uint32_t(obj.maxMemoryAllocationCount, "maxMemoryAllocationCount", 1);
7039
7040      print_uint32_t(obj.maxSamplerAllocationCount, "maxSamplerAllocationCount", 1);
7041
7042      print_VkDeviceSize(obj.bufferImageGranularity, "bufferImageGranularity", 1);
7043
7044      print_VkDeviceSize(obj.sparseAddressSpaceSize, "sparseAddressSpaceSize", 1);
7045
7046      print_uint32_t(obj.maxBoundDescriptorSets, "maxBoundDescriptorSets", 1);
7047
7048      print_uint32_t(obj.maxPerStageDescriptorSamplers, "maxPerStageDescriptorSamplers", 1);
7049
7050      print_uint32_t(obj.maxPerStageDescriptorUniformBuffers, "maxPerStageDescriptorUniformBuffers", 1);
7051
7052      print_uint32_t(obj.maxPerStageDescriptorStorageBuffers, "maxPerStageDescriptorStorageBuffers", 1);
7053
7054      print_uint32_t(obj.maxPerStageDescriptorSampledImages, "maxPerStageDescriptorSampledImages", 1);
7055
7056      print_uint32_t(obj.maxPerStageDescriptorStorageImages, "maxPerStageDescriptorStorageImages", 1);
7057
7058      print_uint32_t(obj.maxPerStageDescriptorInputAttachments, "maxPerStageDescriptorInputAttachments", 1);
7059
7060      print_uint32_t(obj.maxPerStageResources, "maxPerStageResources", 1);
7061
7062      print_uint32_t(obj.maxDescriptorSetSamplers, "maxDescriptorSetSamplers", 1);
7063
7064      print_uint32_t(obj.maxDescriptorSetUniformBuffers, "maxDescriptorSetUniformBuffers", 1);
7065
7066      print_uint32_t(obj.maxDescriptorSetUniformBuffersDynamic, "maxDescriptorSetUniformBuffersDynamic", 1);
7067
7068      print_uint32_t(obj.maxDescriptorSetStorageBuffers, "maxDescriptorSetStorageBuffers", 1);
7069
7070      print_uint32_t(obj.maxDescriptorSetStorageBuffersDynamic, "maxDescriptorSetStorageBuffersDynamic", 1);
7071
7072      print_uint32_t(obj.maxDescriptorSetSampledImages, "maxDescriptorSetSampledImages", 1);
7073
7074      print_uint32_t(obj.maxDescriptorSetStorageImages, "maxDescriptorSetStorageImages", 1);
7075
7076      print_uint32_t(obj.maxDescriptorSetInputAttachments, "maxDescriptorSetInputAttachments", 1);
7077
7078      print_uint32_t(obj.maxVertexInputAttributes, "maxVertexInputAttributes", 1);
7079
7080      print_uint32_t(obj.maxVertexInputBindings, "maxVertexInputBindings", 1);
7081
7082      print_uint32_t(obj.maxVertexInputAttributeOffset, "maxVertexInputAttributeOffset", 1);
7083
7084      print_uint32_t(obj.maxVertexInputBindingStride, "maxVertexInputBindingStride", 1);
7085
7086      print_uint32_t(obj.maxVertexOutputComponents, "maxVertexOutputComponents", 1);
7087
7088      print_uint32_t(obj.maxTessellationGenerationLevel, "maxTessellationGenerationLevel", 1);
7089
7090      print_uint32_t(obj.maxTessellationPatchSize, "maxTessellationPatchSize", 1);
7091
7092      print_uint32_t(obj.maxTessellationControlPerVertexInputComponents, "maxTessellationControlPerVertexInputComponents", 1);
7093
7094      print_uint32_t(obj.maxTessellationControlPerVertexOutputComponents, "maxTessellationControlPerVertexOutputComponents", 1);
7095
7096      print_uint32_t(obj.maxTessellationControlPerPatchOutputComponents, "maxTessellationControlPerPatchOutputComponents", 1);
7097
7098      print_uint32_t(obj.maxTessellationControlTotalOutputComponents, "maxTessellationControlTotalOutputComponents", 1);
7099
7100      print_uint32_t(obj.maxTessellationEvaluationInputComponents, "maxTessellationEvaluationInputComponents", 1);
7101
7102      print_uint32_t(obj.maxTessellationEvaluationOutputComponents, "maxTessellationEvaluationOutputComponents", 1);
7103
7104      print_uint32_t(obj.maxGeometryShaderInvocations, "maxGeometryShaderInvocations", 1);
7105
7106      print_uint32_t(obj.maxGeometryInputComponents, "maxGeometryInputComponents", 1);
7107
7108      print_uint32_t(obj.maxGeometryOutputComponents, "maxGeometryOutputComponents", 1);
7109
7110      print_uint32_t(obj.maxGeometryOutputVertices, "maxGeometryOutputVertices", 1);
7111
7112      print_uint32_t(obj.maxGeometryTotalOutputComponents, "maxGeometryTotalOutputComponents", 1);
7113
7114      print_uint32_t(obj.maxFragmentInputComponents, "maxFragmentInputComponents", 1);
7115
7116      print_uint32_t(obj.maxFragmentOutputAttachments, "maxFragmentOutputAttachments", 1);
7117
7118      print_uint32_t(obj.maxFragmentDualSrcAttachments, "maxFragmentDualSrcAttachments", 1);
7119
7120      print_uint32_t(obj.maxFragmentCombinedOutputResources, "maxFragmentCombinedOutputResources", 1);
7121
7122      print_uint32_t(obj.maxComputeSharedMemorySize, "maxComputeSharedMemorySize", 1);
7123
7124      PRINT_SPACE
7125      _OUT << "\"maxComputeWorkGroupCount\":" << std::endl;
7126      PRINT_SPACE
7127      if (obj.maxComputeWorkGroupCount) {
7128        _OUT << "[" << std::endl;
7129        for (unsigned int i = 0; i < 3; i++) {
7130            bool isCommaNeeded = (i+1) != 3;
7131            print_uint32_t(obj.maxComputeWorkGroupCount[i], "", isCommaNeeded);
7132        }
7133        PRINT_SPACE
7134        _OUT << "]" << "," << std::endl;
7135      } else {
7136        _OUT << "\"NULL\"" << "," << std::endl;
7137      }
7138
7139      print_uint32_t(obj.maxComputeWorkGroupInvocations, "maxComputeWorkGroupInvocations", 1);
7140
7141      PRINT_SPACE
7142      _OUT << "\"maxComputeWorkGroupSize\":" << std::endl;
7143      PRINT_SPACE
7144      if (obj.maxComputeWorkGroupSize) {
7145        _OUT << "[" << std::endl;
7146        for (unsigned int i = 0; i < 3; i++) {
7147            bool isCommaNeeded = (i+1) != 3;
7148            print_uint32_t(obj.maxComputeWorkGroupSize[i], "", isCommaNeeded);
7149        }
7150        PRINT_SPACE
7151        _OUT << "]" << "," << std::endl;
7152      } else {
7153        _OUT << "\"NULL\"" << "," << std::endl;
7154      }
7155
7156      print_uint32_t(obj.subPixelPrecisionBits, "subPixelPrecisionBits", 1);
7157
7158      print_uint32_t(obj.subTexelPrecisionBits, "subTexelPrecisionBits", 1);
7159
7160      print_uint32_t(obj.mipmapPrecisionBits, "mipmapPrecisionBits", 1);
7161
7162      print_uint32_t(obj.maxDrawIndexedIndexValue, "maxDrawIndexedIndexValue", 1);
7163
7164      print_uint32_t(obj.maxDrawIndirectCount, "maxDrawIndirectCount", 1);
7165
7166      print_float(obj.maxSamplerLodBias, "maxSamplerLodBias", 1);
7167
7168      print_float(obj.maxSamplerAnisotropy, "maxSamplerAnisotropy", 1);
7169
7170      print_uint32_t(obj.maxViewports, "maxViewports", 1);
7171
7172      PRINT_SPACE
7173      _OUT << "\"maxViewportDimensions\":" << std::endl;
7174      PRINT_SPACE
7175      if (obj.maxViewportDimensions) {
7176        _OUT << "[" << std::endl;
7177        for (unsigned int i = 0; i < 2; i++) {
7178            bool isCommaNeeded = (i+1) != 2;
7179            print_uint32_t(obj.maxViewportDimensions[i], "", isCommaNeeded);
7180        }
7181        PRINT_SPACE
7182        _OUT << "]" << "," << std::endl;
7183      } else {
7184        _OUT << "\"NULL\"" << "," << std::endl;
7185      }
7186
7187      PRINT_SPACE
7188      _OUT << "\"viewportBoundsRange\":" << std::endl;
7189      PRINT_SPACE
7190      if (obj.viewportBoundsRange) {
7191        _OUT << "[" << std::endl;
7192        for (unsigned int i = 0; i < 2; i++) {
7193            bool isCommaNeeded = (i+1) != 2;
7194            print_float(obj.viewportBoundsRange[i], "", isCommaNeeded);
7195        }
7196        PRINT_SPACE
7197        _OUT << "]" << "," << std::endl;
7198      } else {
7199        _OUT << "\"NULL\"" << "," << std::endl;
7200      }
7201
7202      print_uint32_t(obj.viewportSubPixelBits, "viewportSubPixelBits", 1);
7203
7204      print_size_t(obj.minMemoryMapAlignment, "minMemoryMapAlignment", 1);
7205
7206      print_VkDeviceSize(obj.minTexelBufferOffsetAlignment, "minTexelBufferOffsetAlignment", 1);
7207
7208      print_VkDeviceSize(obj.minUniformBufferOffsetAlignment, "minUniformBufferOffsetAlignment", 1);
7209
7210      print_VkDeviceSize(obj.minStorageBufferOffsetAlignment, "minStorageBufferOffsetAlignment", 1);
7211
7212      print_int32_t(obj.minTexelOffset, "minTexelOffset", 1);
7213
7214      print_uint32_t(obj.maxTexelOffset, "maxTexelOffset", 1);
7215
7216      print_int32_t(obj.minTexelGatherOffset, "minTexelGatherOffset", 1);
7217
7218      print_uint32_t(obj.maxTexelGatherOffset, "maxTexelGatherOffset", 1);
7219
7220      print_float(obj.minInterpolationOffset, "minInterpolationOffset", 1);
7221
7222      print_float(obj.maxInterpolationOffset, "maxInterpolationOffset", 1);
7223
7224      print_uint32_t(obj.subPixelInterpolationOffsetBits, "subPixelInterpolationOffsetBits", 1);
7225
7226      print_uint32_t(obj.maxFramebufferWidth, "maxFramebufferWidth", 1);
7227
7228      print_uint32_t(obj.maxFramebufferHeight, "maxFramebufferHeight", 1);
7229
7230      print_uint32_t(obj.maxFramebufferLayers, "maxFramebufferLayers", 1);
7231
7232      print_VkSampleCountFlags(obj.framebufferColorSampleCounts, "framebufferColorSampleCounts", 1);
7233
7234      print_VkSampleCountFlags(obj.framebufferDepthSampleCounts, "framebufferDepthSampleCounts", 1);
7235
7236      print_VkSampleCountFlags(obj.framebufferStencilSampleCounts, "framebufferStencilSampleCounts", 1);
7237
7238      print_VkSampleCountFlags(obj.framebufferNoAttachmentsSampleCounts, "framebufferNoAttachmentsSampleCounts", 1);
7239
7240      print_uint32_t(obj.maxColorAttachments, "maxColorAttachments", 1);
7241
7242      print_VkSampleCountFlags(obj.sampledImageColorSampleCounts, "sampledImageColorSampleCounts", 1);
7243
7244      print_VkSampleCountFlags(obj.sampledImageIntegerSampleCounts, "sampledImageIntegerSampleCounts", 1);
7245
7246      print_VkSampleCountFlags(obj.sampledImageDepthSampleCounts, "sampledImageDepthSampleCounts", 1);
7247
7248      print_VkSampleCountFlags(obj.sampledImageStencilSampleCounts, "sampledImageStencilSampleCounts", 1);
7249
7250      print_VkSampleCountFlags(obj.storageImageSampleCounts, "storageImageSampleCounts", 1);
7251
7252      print_uint32_t(obj.maxSampleMaskWords, "maxSampleMaskWords", 1);
7253
7254      print_VkBool32(obj.timestampComputeAndGraphics, "timestampComputeAndGraphics", 1);
7255
7256      print_float(obj.timestampPeriod, "timestampPeriod", 1);
7257
7258      print_uint32_t(obj.maxClipDistances, "maxClipDistances", 1);
7259
7260      print_uint32_t(obj.maxCullDistances, "maxCullDistances", 1);
7261
7262      print_uint32_t(obj.maxCombinedClipAndCullDistances, "maxCombinedClipAndCullDistances", 1);
7263
7264      print_uint32_t(obj.discreteQueuePriorities, "discreteQueuePriorities", 1);
7265
7266      PRINT_SPACE
7267      _OUT << "\"pointSizeRange\":" << std::endl;
7268      PRINT_SPACE
7269      if (obj.pointSizeRange) {
7270        _OUT << "[" << std::endl;
7271        for (unsigned int i = 0; i < 2; i++) {
7272            bool isCommaNeeded = (i+1) != 2;
7273            print_float(obj.pointSizeRange[i], "", isCommaNeeded);
7274        }
7275        PRINT_SPACE
7276        _OUT << "]" << "," << std::endl;
7277      } else {
7278        _OUT << "\"NULL\"" << "," << std::endl;
7279      }
7280
7281      PRINT_SPACE
7282      _OUT << "\"lineWidthRange\":" << std::endl;
7283      PRINT_SPACE
7284      if (obj.lineWidthRange) {
7285        _OUT << "[" << std::endl;
7286        for (unsigned int i = 0; i < 2; i++) {
7287            bool isCommaNeeded = (i+1) != 2;
7288            print_float(obj.lineWidthRange[i], "", isCommaNeeded);
7289        }
7290        PRINT_SPACE
7291        _OUT << "]" << "," << std::endl;
7292      } else {
7293        _OUT << "\"NULL\"" << "," << std::endl;
7294      }
7295
7296      print_float(obj.pointSizeGranularity, "pointSizeGranularity", 1);
7297
7298      print_float(obj.lineWidthGranularity, "lineWidthGranularity", 1);
7299
7300      print_VkBool32(obj.strictLines, "strictLines", 1);
7301
7302      print_VkBool32(obj.standardSampleLocations, "standardSampleLocations", 1);
7303
7304      print_VkDeviceSize(obj.optimalBufferCopyOffsetAlignment, "optimalBufferCopyOffsetAlignment", 1);
7305
7306      print_VkDeviceSize(obj.optimalBufferCopyRowPitchAlignment, "optimalBufferCopyRowPitchAlignment", 1);
7307
7308      print_VkDeviceSize(obj.nonCoherentAtomSize, "nonCoherentAtomSize", 0);
7309
7310      INDENT(-4);
7311      PRINT_SPACE
7312      if (commaNeeded)
7313          _OUT << "}," << std::endl;
7314      else
7315          _OUT << "}" << std::endl;
7316 }
7317 static void print_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits * obj, const std::string& s, bool commaNeeded=true) {
7318      PRINT_SPACE
7319      _OUT << "{" << std::endl;
7320      INDENT(4);
7321
7322      print_uint32_t(obj->maxImageDimension1D, "maxImageDimension1D", 1);
7323
7324      print_uint32_t(obj->maxImageDimension2D, "maxImageDimension2D", 1);
7325
7326      print_uint32_t(obj->maxImageDimension3D, "maxImageDimension3D", 1);
7327
7328      print_uint32_t(obj->maxImageDimensionCube, "maxImageDimensionCube", 1);
7329
7330      print_uint32_t(obj->maxImageArrayLayers, "maxImageArrayLayers", 1);
7331
7332      print_uint32_t(obj->maxTexelBufferElements, "maxTexelBufferElements", 1);
7333
7334      print_uint32_t(obj->maxUniformBufferRange, "maxUniformBufferRange", 1);
7335
7336      print_uint32_t(obj->maxStorageBufferRange, "maxStorageBufferRange", 1);
7337
7338      print_uint32_t(obj->maxPushConstantsSize, "maxPushConstantsSize", 1);
7339
7340      print_uint32_t(obj->maxMemoryAllocationCount, "maxMemoryAllocationCount", 1);
7341
7342      print_uint32_t(obj->maxSamplerAllocationCount, "maxSamplerAllocationCount", 1);
7343
7344      print_VkDeviceSize(obj->bufferImageGranularity, "bufferImageGranularity", 1);
7345
7346      print_VkDeviceSize(obj->sparseAddressSpaceSize, "sparseAddressSpaceSize", 1);
7347
7348      print_uint32_t(obj->maxBoundDescriptorSets, "maxBoundDescriptorSets", 1);
7349
7350      print_uint32_t(obj->maxPerStageDescriptorSamplers, "maxPerStageDescriptorSamplers", 1);
7351
7352      print_uint32_t(obj->maxPerStageDescriptorUniformBuffers, "maxPerStageDescriptorUniformBuffers", 1);
7353
7354      print_uint32_t(obj->maxPerStageDescriptorStorageBuffers, "maxPerStageDescriptorStorageBuffers", 1);
7355
7356      print_uint32_t(obj->maxPerStageDescriptorSampledImages, "maxPerStageDescriptorSampledImages", 1);
7357
7358      print_uint32_t(obj->maxPerStageDescriptorStorageImages, "maxPerStageDescriptorStorageImages", 1);
7359
7360      print_uint32_t(obj->maxPerStageDescriptorInputAttachments, "maxPerStageDescriptorInputAttachments", 1);
7361
7362      print_uint32_t(obj->maxPerStageResources, "maxPerStageResources", 1);
7363
7364      print_uint32_t(obj->maxDescriptorSetSamplers, "maxDescriptorSetSamplers", 1);
7365
7366      print_uint32_t(obj->maxDescriptorSetUniformBuffers, "maxDescriptorSetUniformBuffers", 1);
7367
7368      print_uint32_t(obj->maxDescriptorSetUniformBuffersDynamic, "maxDescriptorSetUniformBuffersDynamic", 1);
7369
7370      print_uint32_t(obj->maxDescriptorSetStorageBuffers, "maxDescriptorSetStorageBuffers", 1);
7371
7372      print_uint32_t(obj->maxDescriptorSetStorageBuffersDynamic, "maxDescriptorSetStorageBuffersDynamic", 1);
7373
7374      print_uint32_t(obj->maxDescriptorSetSampledImages, "maxDescriptorSetSampledImages", 1);
7375
7376      print_uint32_t(obj->maxDescriptorSetStorageImages, "maxDescriptorSetStorageImages", 1);
7377
7378      print_uint32_t(obj->maxDescriptorSetInputAttachments, "maxDescriptorSetInputAttachments", 1);
7379
7380      print_uint32_t(obj->maxVertexInputAttributes, "maxVertexInputAttributes", 1);
7381
7382      print_uint32_t(obj->maxVertexInputBindings, "maxVertexInputBindings", 1);
7383
7384      print_uint32_t(obj->maxVertexInputAttributeOffset, "maxVertexInputAttributeOffset", 1);
7385
7386      print_uint32_t(obj->maxVertexInputBindingStride, "maxVertexInputBindingStride", 1);
7387
7388      print_uint32_t(obj->maxVertexOutputComponents, "maxVertexOutputComponents", 1);
7389
7390      print_uint32_t(obj->maxTessellationGenerationLevel, "maxTessellationGenerationLevel", 1);
7391
7392      print_uint32_t(obj->maxTessellationPatchSize, "maxTessellationPatchSize", 1);
7393
7394      print_uint32_t(obj->maxTessellationControlPerVertexInputComponents, "maxTessellationControlPerVertexInputComponents", 1);
7395
7396      print_uint32_t(obj->maxTessellationControlPerVertexOutputComponents, "maxTessellationControlPerVertexOutputComponents", 1);
7397
7398      print_uint32_t(obj->maxTessellationControlPerPatchOutputComponents, "maxTessellationControlPerPatchOutputComponents", 1);
7399
7400      print_uint32_t(obj->maxTessellationControlTotalOutputComponents, "maxTessellationControlTotalOutputComponents", 1);
7401
7402      print_uint32_t(obj->maxTessellationEvaluationInputComponents, "maxTessellationEvaluationInputComponents", 1);
7403
7404      print_uint32_t(obj->maxTessellationEvaluationOutputComponents, "maxTessellationEvaluationOutputComponents", 1);
7405
7406      print_uint32_t(obj->maxGeometryShaderInvocations, "maxGeometryShaderInvocations", 1);
7407
7408      print_uint32_t(obj->maxGeometryInputComponents, "maxGeometryInputComponents", 1);
7409
7410      print_uint32_t(obj->maxGeometryOutputComponents, "maxGeometryOutputComponents", 1);
7411
7412      print_uint32_t(obj->maxGeometryOutputVertices, "maxGeometryOutputVertices", 1);
7413
7414      print_uint32_t(obj->maxGeometryTotalOutputComponents, "maxGeometryTotalOutputComponents", 1);
7415
7416      print_uint32_t(obj->maxFragmentInputComponents, "maxFragmentInputComponents", 1);
7417
7418      print_uint32_t(obj->maxFragmentOutputAttachments, "maxFragmentOutputAttachments", 1);
7419
7420      print_uint32_t(obj->maxFragmentDualSrcAttachments, "maxFragmentDualSrcAttachments", 1);
7421
7422      print_uint32_t(obj->maxFragmentCombinedOutputResources, "maxFragmentCombinedOutputResources", 1);
7423
7424      print_uint32_t(obj->maxComputeSharedMemorySize, "maxComputeSharedMemorySize", 1);
7425
7426      PRINT_SPACE
7427      _OUT << "\"maxComputeWorkGroupCount\":" << std::endl;
7428      PRINT_SPACE
7429      if (obj->maxComputeWorkGroupCount) {
7430        _OUT << "[" << std::endl;
7431        for (unsigned int i = 0; i < 3; i++) {
7432            bool isCommaNeeded = (i+1) != 3;
7433            print_uint32_t(obj->maxComputeWorkGroupCount[i], "", isCommaNeeded);
7434        }
7435        PRINT_SPACE
7436        _OUT << "]" << "," << std::endl;
7437      } else {
7438        _OUT << "\"NULL\"" << "," << std::endl;
7439      }
7440
7441      print_uint32_t(obj->maxComputeWorkGroupInvocations, "maxComputeWorkGroupInvocations", 1);
7442
7443      PRINT_SPACE
7444      _OUT << "\"maxComputeWorkGroupSize\":" << std::endl;
7445      PRINT_SPACE
7446      if (obj->maxComputeWorkGroupSize) {
7447        _OUT << "[" << std::endl;
7448        for (unsigned int i = 0; i < 3; i++) {
7449            bool isCommaNeeded = (i+1) != 3;
7450            print_uint32_t(obj->maxComputeWorkGroupSize[i], "", isCommaNeeded);
7451        }
7452        PRINT_SPACE
7453        _OUT << "]" << "," << std::endl;
7454      } else {
7455        _OUT << "\"NULL\"" << "," << std::endl;
7456      }
7457
7458      print_uint32_t(obj->subPixelPrecisionBits, "subPixelPrecisionBits", 1);
7459
7460      print_uint32_t(obj->subTexelPrecisionBits, "subTexelPrecisionBits", 1);
7461
7462      print_uint32_t(obj->mipmapPrecisionBits, "mipmapPrecisionBits", 1);
7463
7464      print_uint32_t(obj->maxDrawIndexedIndexValue, "maxDrawIndexedIndexValue", 1);
7465
7466      print_uint32_t(obj->maxDrawIndirectCount, "maxDrawIndirectCount", 1);
7467
7468      print_float(obj->maxSamplerLodBias, "maxSamplerLodBias", 1);
7469
7470      print_float(obj->maxSamplerAnisotropy, "maxSamplerAnisotropy", 1);
7471
7472      print_uint32_t(obj->maxViewports, "maxViewports", 1);
7473
7474      PRINT_SPACE
7475      _OUT << "\"maxViewportDimensions\":" << std::endl;
7476      PRINT_SPACE
7477      if (obj->maxViewportDimensions) {
7478        _OUT << "[" << std::endl;
7479        for (unsigned int i = 0; i < 2; i++) {
7480            bool isCommaNeeded = (i+1) != 2;
7481            print_uint32_t(obj->maxViewportDimensions[i], "", isCommaNeeded);
7482        }
7483        PRINT_SPACE
7484        _OUT << "]" << "," << std::endl;
7485      } else {
7486        _OUT << "\"NULL\"" << "," << std::endl;
7487      }
7488
7489      PRINT_SPACE
7490      _OUT << "\"viewportBoundsRange\":" << std::endl;
7491      PRINT_SPACE
7492      if (obj->viewportBoundsRange) {
7493        _OUT << "[" << std::endl;
7494        for (unsigned int i = 0; i < 2; i++) {
7495            bool isCommaNeeded = (i+1) != 2;
7496            print_float(obj->viewportBoundsRange[i], "", isCommaNeeded);
7497        }
7498        PRINT_SPACE
7499        _OUT << "]" << "," << std::endl;
7500      } else {
7501        _OUT << "\"NULL\"" << "," << std::endl;
7502      }
7503
7504      print_uint32_t(obj->viewportSubPixelBits, "viewportSubPixelBits", 1);
7505
7506      print_size_t(obj->minMemoryMapAlignment, "minMemoryMapAlignment", 1);
7507
7508      print_VkDeviceSize(obj->minTexelBufferOffsetAlignment, "minTexelBufferOffsetAlignment", 1);
7509
7510      print_VkDeviceSize(obj->minUniformBufferOffsetAlignment, "minUniformBufferOffsetAlignment", 1);
7511
7512      print_VkDeviceSize(obj->minStorageBufferOffsetAlignment, "minStorageBufferOffsetAlignment", 1);
7513
7514      print_int32_t(obj->minTexelOffset, "minTexelOffset", 1);
7515
7516      print_uint32_t(obj->maxTexelOffset, "maxTexelOffset", 1);
7517
7518      print_int32_t(obj->minTexelGatherOffset, "minTexelGatherOffset", 1);
7519
7520      print_uint32_t(obj->maxTexelGatherOffset, "maxTexelGatherOffset", 1);
7521
7522      print_float(obj->minInterpolationOffset, "minInterpolationOffset", 1);
7523
7524      print_float(obj->maxInterpolationOffset, "maxInterpolationOffset", 1);
7525
7526      print_uint32_t(obj->subPixelInterpolationOffsetBits, "subPixelInterpolationOffsetBits", 1);
7527
7528      print_uint32_t(obj->maxFramebufferWidth, "maxFramebufferWidth", 1);
7529
7530      print_uint32_t(obj->maxFramebufferHeight, "maxFramebufferHeight", 1);
7531
7532      print_uint32_t(obj->maxFramebufferLayers, "maxFramebufferLayers", 1);
7533
7534      print_VkSampleCountFlags(obj->framebufferColorSampleCounts, "framebufferColorSampleCounts", 1);
7535
7536      print_VkSampleCountFlags(obj->framebufferDepthSampleCounts, "framebufferDepthSampleCounts", 1);
7537
7538      print_VkSampleCountFlags(obj->framebufferStencilSampleCounts, "framebufferStencilSampleCounts", 1);
7539
7540      print_VkSampleCountFlags(obj->framebufferNoAttachmentsSampleCounts, "framebufferNoAttachmentsSampleCounts", 1);
7541
7542      print_uint32_t(obj->maxColorAttachments, "maxColorAttachments", 1);
7543
7544      print_VkSampleCountFlags(obj->sampledImageColorSampleCounts, "sampledImageColorSampleCounts", 1);
7545
7546      print_VkSampleCountFlags(obj->sampledImageIntegerSampleCounts, "sampledImageIntegerSampleCounts", 1);
7547
7548      print_VkSampleCountFlags(obj->sampledImageDepthSampleCounts, "sampledImageDepthSampleCounts", 1);
7549
7550      print_VkSampleCountFlags(obj->sampledImageStencilSampleCounts, "sampledImageStencilSampleCounts", 1);
7551
7552      print_VkSampleCountFlags(obj->storageImageSampleCounts, "storageImageSampleCounts", 1);
7553
7554      print_uint32_t(obj->maxSampleMaskWords, "maxSampleMaskWords", 1);
7555
7556      print_VkBool32(obj->timestampComputeAndGraphics, "timestampComputeAndGraphics", 1);
7557
7558      print_float(obj->timestampPeriod, "timestampPeriod", 1);
7559
7560      print_uint32_t(obj->maxClipDistances, "maxClipDistances", 1);
7561
7562      print_uint32_t(obj->maxCullDistances, "maxCullDistances", 1);
7563
7564      print_uint32_t(obj->maxCombinedClipAndCullDistances, "maxCombinedClipAndCullDistances", 1);
7565
7566      print_uint32_t(obj->discreteQueuePriorities, "discreteQueuePriorities", 1);
7567
7568      PRINT_SPACE
7569      _OUT << "\"pointSizeRange\":" << std::endl;
7570      PRINT_SPACE
7571      if (obj->pointSizeRange) {
7572        _OUT << "[" << std::endl;
7573        for (unsigned int i = 0; i < 2; i++) {
7574            bool isCommaNeeded = (i+1) != 2;
7575            print_float(obj->pointSizeRange[i], "", isCommaNeeded);
7576        }
7577        PRINT_SPACE
7578        _OUT << "]" << "," << std::endl;
7579      } else {
7580        _OUT << "\"NULL\"" << "," << std::endl;
7581      }
7582
7583      PRINT_SPACE
7584      _OUT << "\"lineWidthRange\":" << std::endl;
7585      PRINT_SPACE
7586      if (obj->lineWidthRange) {
7587        _OUT << "[" << std::endl;
7588        for (unsigned int i = 0; i < 2; i++) {
7589            bool isCommaNeeded = (i+1) != 2;
7590            print_float(obj->lineWidthRange[i], "", isCommaNeeded);
7591        }
7592        PRINT_SPACE
7593        _OUT << "]" << "," << std::endl;
7594      } else {
7595        _OUT << "\"NULL\"" << "," << std::endl;
7596      }
7597
7598      print_float(obj->pointSizeGranularity, "pointSizeGranularity", 1);
7599
7600      print_float(obj->lineWidthGranularity, "lineWidthGranularity", 1);
7601
7602      print_VkBool32(obj->strictLines, "strictLines", 1);
7603
7604      print_VkBool32(obj->standardSampleLocations, "standardSampleLocations", 1);
7605
7606      print_VkDeviceSize(obj->optimalBufferCopyOffsetAlignment, "optimalBufferCopyOffsetAlignment", 1);
7607
7608      print_VkDeviceSize(obj->optimalBufferCopyRowPitchAlignment, "optimalBufferCopyRowPitchAlignment", 1);
7609
7610      print_VkDeviceSize(obj->nonCoherentAtomSize, "nonCoherentAtomSize", 0);
7611
7612      INDENT(-4);
7613      PRINT_SPACE
7614      if (commaNeeded)
7615          _OUT << "}," << std::endl;
7616      else
7617          _OUT << "}" << std::endl;
7618 }
7619
7620 static void print_VkPhysicalDeviceMemoryProperties(VkPhysicalDeviceMemoryProperties obj, const std::string& s, bool commaNeeded=true) {
7621      PRINT_SPACE
7622      _OUT << "{" << std::endl;
7623      INDENT(4);
7624
7625      print_uint32_t(obj.memoryTypeCount, "memoryTypeCount", 1);
7626
7627      PRINT_SPACE
7628      _OUT << "\"memoryTypes\":" << std::endl;
7629      PRINT_SPACE
7630      if (obj.memoryTypes) {
7631        _OUT << "[" << std::endl;
7632        for (unsigned int i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
7633            bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_TYPES;
7634            print_VkMemoryType(obj.memoryTypes[i], "", isCommaNeeded);
7635        }
7636        PRINT_SPACE
7637        _OUT << "]" << "," << std::endl;
7638      } else {
7639        _OUT << "\"NULL\"" << "," << std::endl;
7640      }
7641
7642      print_uint32_t(obj.memoryHeapCount, "memoryHeapCount", 1);
7643
7644      PRINT_SPACE
7645      _OUT << "\"memoryHeaps\":" << std::endl;
7646      PRINT_SPACE
7647      if (obj.memoryHeaps) {
7648        _OUT << "[" << std::endl;
7649        for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++) {
7650            bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_HEAPS;
7651            print_VkMemoryHeap(obj.memoryHeaps[i], "", isCommaNeeded);
7652        }
7653        PRINT_SPACE
7654        _OUT << "]" << "" << std::endl;
7655      } else {
7656        _OUT << "\"NULL\"" << "" << std::endl;
7657      }
7658
7659      INDENT(-4);
7660      PRINT_SPACE
7661      if (commaNeeded)
7662          _OUT << "}," << std::endl;
7663      else
7664          _OUT << "}" << std::endl;
7665 }
7666 static void print_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties * obj, const std::string& s, bool commaNeeded=true) {
7667      PRINT_SPACE
7668      _OUT << "{" << std::endl;
7669      INDENT(4);
7670
7671      print_uint32_t(obj->memoryTypeCount, "memoryTypeCount", 1);
7672
7673      PRINT_SPACE
7674      _OUT << "\"memoryTypes\":" << std::endl;
7675      PRINT_SPACE
7676      if (obj->memoryTypes) {
7677        _OUT << "[" << std::endl;
7678        for (unsigned int i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
7679            bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_TYPES;
7680            print_VkMemoryType(obj->memoryTypes[i], "", isCommaNeeded);
7681        }
7682        PRINT_SPACE
7683        _OUT << "]" << "," << std::endl;
7684      } else {
7685        _OUT << "\"NULL\"" << "," << std::endl;
7686      }
7687
7688      print_uint32_t(obj->memoryHeapCount, "memoryHeapCount", 1);
7689
7690      PRINT_SPACE
7691      _OUT << "\"memoryHeaps\":" << std::endl;
7692      PRINT_SPACE
7693      if (obj->memoryHeaps) {
7694        _OUT << "[" << std::endl;
7695        for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++) {
7696            bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_HEAPS;
7697            print_VkMemoryHeap(obj->memoryHeaps[i], "", isCommaNeeded);
7698        }
7699        PRINT_SPACE
7700        _OUT << "]" << "" << std::endl;
7701      } else {
7702        _OUT << "\"NULL\"" << "" << std::endl;
7703      }
7704
7705      INDENT(-4);
7706      PRINT_SPACE
7707      if (commaNeeded)
7708          _OUT << "}," << std::endl;
7709      else
7710          _OUT << "}" << std::endl;
7711 }
7712
7713 static void print_VkPhysicalDeviceSparseProperties(VkPhysicalDeviceSparseProperties obj, const std::string& s, bool commaNeeded=true) {
7714      PRINT_SPACE
7715      _OUT << "{" << std::endl;
7716      INDENT(4);
7717
7718      print_VkBool32(obj.residencyStandard2DBlockShape, "residencyStandard2DBlockShape", 1);
7719
7720      print_VkBool32(obj.residencyStandard2DMultisampleBlockShape, "residencyStandard2DMultisampleBlockShape", 1);
7721
7722      print_VkBool32(obj.residencyStandard3DBlockShape, "residencyStandard3DBlockShape", 1);
7723
7724      print_VkBool32(obj.residencyAlignedMipSize, "residencyAlignedMipSize", 1);
7725
7726      print_VkBool32(obj.residencyNonResidentStrict, "residencyNonResidentStrict", 0);
7727
7728      INDENT(-4);
7729      PRINT_SPACE
7730      if (commaNeeded)
7731          _OUT << "}," << std::endl;
7732      else
7733          _OUT << "}" << std::endl;
7734 }
7735 static void print_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties * obj, const std::string& s, bool commaNeeded=true) {
7736      PRINT_SPACE
7737      _OUT << "{" << std::endl;
7738      INDENT(4);
7739
7740      print_VkBool32(obj->residencyStandard2DBlockShape, "residencyStandard2DBlockShape", 1);
7741
7742      print_VkBool32(obj->residencyStandard2DMultisampleBlockShape, "residencyStandard2DMultisampleBlockShape", 1);
7743
7744      print_VkBool32(obj->residencyStandard3DBlockShape, "residencyStandard3DBlockShape", 1);
7745
7746      print_VkBool32(obj->residencyAlignedMipSize, "residencyAlignedMipSize", 1);
7747
7748      print_VkBool32(obj->residencyNonResidentStrict, "residencyNonResidentStrict", 0);
7749
7750      INDENT(-4);
7751      PRINT_SPACE
7752      if (commaNeeded)
7753          _OUT << "}," << std::endl;
7754      else
7755          _OUT << "}" << std::endl;
7756 }
7757
7758 static void print_VkPhysicalDeviceProperties(VkPhysicalDeviceProperties obj, const std::string& s, bool commaNeeded=true) {
7759      PRINT_SPACE
7760      _OUT << "{" << std::endl;
7761      INDENT(4);
7762
7763      print_uint32_t(obj.apiVersion, "apiVersion", 1);
7764
7765      print_uint32_t(obj.driverVersion, "driverVersion", 1);
7766
7767      print_uint32_t(obj.vendorID, "vendorID", 1);
7768
7769      print_uint32_t(obj.deviceID, "deviceID", 1);
7770
7771      print_VkPhysicalDeviceType(obj.deviceType, "deviceType", 1);
7772
7773      PRINT_SPACE
7774      _OUT << "\"deviceName\":" << std::endl;
7775      PRINT_SPACE
7776      if (obj.deviceName) {
7777        _OUT << "[" << std::endl;
7778        for (unsigned int i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; i++) {
7779            bool isCommaNeeded = (i+1) != VK_MAX_PHYSICAL_DEVICE_NAME_SIZE;
7780            print_char(obj.deviceName[i], "", isCommaNeeded);
7781        }
7782        PRINT_SPACE
7783        _OUT << "]" << "," << std::endl;
7784      } else {
7785        _OUT << "\"NULL\"" << "," << std::endl;
7786      }
7787
7788      PRINT_SPACE
7789      _OUT << "\"pipelineCacheUUID\":" << std::endl;
7790      PRINT_SPACE
7791      if (obj.pipelineCacheUUID) {
7792        _OUT << "[" << std::endl;
7793        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
7794            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
7795            print_uint8_t(obj.pipelineCacheUUID[i], "", isCommaNeeded);
7796        }
7797        PRINT_SPACE
7798        _OUT << "]" << "," << std::endl;
7799      } else {
7800        _OUT << "\"NULL\"" << "," << std::endl;
7801      }
7802
7803      PRINT_SPACE
7804      _OUT << "\"limits\": " << std::endl;
7805      {
7806            print_VkPhysicalDeviceLimits(obj.limits, "limits", 1);
7807      }
7808
7809      PRINT_SPACE
7810      _OUT << "\"sparseProperties\": " << std::endl;
7811      {
7812            print_VkPhysicalDeviceSparseProperties(obj.sparseProperties, "sparseProperties", 0);
7813      }
7814
7815      INDENT(-4);
7816      PRINT_SPACE
7817      if (commaNeeded)
7818          _OUT << "}," << std::endl;
7819      else
7820          _OUT << "}" << std::endl;
7821 }
7822 static void print_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties * obj, const std::string& s, bool commaNeeded=true) {
7823      PRINT_SPACE
7824      _OUT << "{" << std::endl;
7825      INDENT(4);
7826
7827      print_uint32_t(obj->apiVersion, "apiVersion", 1);
7828
7829      print_uint32_t(obj->driverVersion, "driverVersion", 1);
7830
7831      print_uint32_t(obj->vendorID, "vendorID", 1);
7832
7833      print_uint32_t(obj->deviceID, "deviceID", 1);
7834
7835      print_VkPhysicalDeviceType(obj->deviceType, "deviceType", 1);
7836
7837      PRINT_SPACE
7838      _OUT << "\"deviceName\":" << std::endl;
7839      PRINT_SPACE
7840      if (obj->deviceName) {
7841        _OUT << "[" << std::endl;
7842        for (unsigned int i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; i++) {
7843            bool isCommaNeeded = (i+1) != VK_MAX_PHYSICAL_DEVICE_NAME_SIZE;
7844            print_char(obj->deviceName[i], "", isCommaNeeded);
7845        }
7846        PRINT_SPACE
7847        _OUT << "]" << "," << std::endl;
7848      } else {
7849        _OUT << "\"NULL\"" << "," << std::endl;
7850      }
7851
7852      PRINT_SPACE
7853      _OUT << "\"pipelineCacheUUID\":" << std::endl;
7854      PRINT_SPACE
7855      if (obj->pipelineCacheUUID) {
7856        _OUT << "[" << std::endl;
7857        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
7858            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
7859            print_uint8_t(obj->pipelineCacheUUID[i], "", isCommaNeeded);
7860        }
7861        PRINT_SPACE
7862        _OUT << "]" << "," << std::endl;
7863      } else {
7864        _OUT << "\"NULL\"" << "," << std::endl;
7865      }
7866
7867      PRINT_SPACE
7868      _OUT << "\"limits\": " << std::endl;
7869      {
7870            print_VkPhysicalDeviceLimits(obj->limits, "limits", 1);
7871      }
7872
7873      PRINT_SPACE
7874      _OUT << "\"sparseProperties\": " << std::endl;
7875      {
7876            print_VkPhysicalDeviceSparseProperties(obj->sparseProperties, "sparseProperties", 0);
7877      }
7878
7879      INDENT(-4);
7880      PRINT_SPACE
7881      if (commaNeeded)
7882          _OUT << "}," << std::endl;
7883      else
7884          _OUT << "}" << std::endl;
7885 }
7886
7887 static void print_VkQueueFamilyProperties(VkQueueFamilyProperties obj, const std::string& s, bool commaNeeded=true) {
7888      PRINT_SPACE
7889      _OUT << "{" << std::endl;
7890      INDENT(4);
7891
7892      print_VkQueueFlags(obj.queueFlags, "queueFlags", 1);
7893
7894      print_uint32_t(obj.queueCount, "queueCount", 1);
7895
7896      print_uint32_t(obj.timestampValidBits, "timestampValidBits", 1);
7897
7898      PRINT_SPACE
7899      _OUT << "\"minImageTransferGranularity\": " << std::endl;
7900      {
7901            print_VkExtent3D(obj.minImageTransferGranularity, "minImageTransferGranularity", 0);
7902      }
7903
7904      INDENT(-4);
7905      PRINT_SPACE
7906      if (commaNeeded)
7907          _OUT << "}," << std::endl;
7908      else
7909          _OUT << "}" << std::endl;
7910 }
7911 static void print_VkQueueFamilyProperties(const VkQueueFamilyProperties * obj, const std::string& s, bool commaNeeded=true) {
7912      PRINT_SPACE
7913      _OUT << "{" << std::endl;
7914      INDENT(4);
7915
7916      print_VkQueueFlags(obj->queueFlags, "queueFlags", 1);
7917
7918      print_uint32_t(obj->queueCount, "queueCount", 1);
7919
7920      print_uint32_t(obj->timestampValidBits, "timestampValidBits", 1);
7921
7922      PRINT_SPACE
7923      _OUT << "\"minImageTransferGranularity\": " << std::endl;
7924      {
7925            print_VkExtent3D(obj->minImageTransferGranularity, "minImageTransferGranularity", 0);
7926      }
7927
7928      INDENT(-4);
7929      PRINT_SPACE
7930      if (commaNeeded)
7931          _OUT << "}," << std::endl;
7932      else
7933          _OUT << "}" << std::endl;
7934 }
7935
7936 static void print_VkDeviceQueueCreateInfo(VkDeviceQueueCreateInfo obj, const std::string& s, bool commaNeeded=true) {
7937      PRINT_SPACE
7938      _OUT << "{" << std::endl;
7939      INDENT(4);
7940
7941      print_VkStructureType(obj.sType, "sType", 1);
7942
7943       if (obj.pNext) {
7944          dumpPNextChain(obj.pNext);
7945       } else {
7946          PRINT_SPACE
7947          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
7948      }
7949
7950      print_VkDeviceQueueCreateFlags(obj.flags, "flags", 1);
7951
7952      print_uint32_t(obj.queueFamilyIndex, "queueFamilyIndex", 1);
7953
7954      print_uint32_t(obj.queueCount, "queueCount", 1);
7955
7956      PRINT_SPACE
7957      _OUT << "\"pQueuePriorities\":" << std::endl;
7958      PRINT_SPACE
7959      if (obj.pQueuePriorities) {
7960        _OUT << "[" << std::endl;
7961        for (unsigned int i = 0; i < obj.queueCount; i++) {
7962            bool isCommaNeeded = (i+1) != obj.queueCount;
7963            print_float(obj.pQueuePriorities[i], "", isCommaNeeded);
7964        }
7965        PRINT_SPACE
7966        _OUT << "]" << "" << std::endl;
7967      } else {
7968        _OUT << "\"NULL\"" << "" << std::endl;
7969      }
7970
7971      INDENT(-4);
7972      PRINT_SPACE
7973      if (commaNeeded)
7974          _OUT << "}," << std::endl;
7975      else
7976          _OUT << "}" << std::endl;
7977 }
7978 static void print_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
7979      PRINT_SPACE
7980      _OUT << "{" << std::endl;
7981      INDENT(4);
7982
7983      print_VkStructureType(obj->sType, "sType", 1);
7984
7985       if (obj->pNext) {
7986          dumpPNextChain(obj->pNext);
7987       } else {
7988          PRINT_SPACE
7989          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
7990      }
7991
7992      print_VkDeviceQueueCreateFlags(obj->flags, "flags", 1);
7993
7994      print_uint32_t(obj->queueFamilyIndex, "queueFamilyIndex", 1);
7995
7996      print_uint32_t(obj->queueCount, "queueCount", 1);
7997
7998      PRINT_SPACE
7999      _OUT << "\"pQueuePriorities\":" << std::endl;
8000      PRINT_SPACE
8001      if (obj->pQueuePriorities) {
8002        _OUT << "[" << std::endl;
8003        for (unsigned int i = 0; i < obj->queueCount; i++) {
8004            bool isCommaNeeded = (i+1) != obj->queueCount;
8005            print_float(obj->pQueuePriorities[i], "", isCommaNeeded);
8006        }
8007        PRINT_SPACE
8008        _OUT << "]" << "" << std::endl;
8009      } else {
8010        _OUT << "\"NULL\"" << "" << std::endl;
8011      }
8012
8013      INDENT(-4);
8014      PRINT_SPACE
8015      if (commaNeeded)
8016          _OUT << "}," << std::endl;
8017      else
8018          _OUT << "}" << std::endl;
8019 }
8020
8021 static void print_VkDeviceCreateInfo(VkDeviceCreateInfo obj, const std::string& s, bool commaNeeded=true) {
8022      PRINT_SPACE
8023      _OUT << "{" << std::endl;
8024      INDENT(4);
8025
8026      print_VkStructureType(obj.sType, "sType", 1);
8027
8028       if (obj.pNext) {
8029          dumpPNextChain(obj.pNext);
8030       } else {
8031          PRINT_SPACE
8032          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8033      }
8034
8035      print_VkDeviceCreateFlags(obj.flags, "flags", 1);
8036
8037      print_uint32_t(obj.queueCreateInfoCount, "queueCreateInfoCount", 1);
8038
8039      PRINT_SPACE
8040      _OUT << "\"pQueueCreateInfos\": " << std::endl;
8041      if (obj.pQueueCreateInfos) {
8042          PRINT_SPACE
8043          _OUT << "[" << std::endl;
8044          for (unsigned int i = 0; i < obj.queueCreateInfoCount; i++) {
8045            if (i+1 == obj.queueCreateInfoCount)
8046                print_VkDeviceQueueCreateInfo(obj.pQueueCreateInfos[i], "pQueueCreateInfos", 0);
8047            else
8048                print_VkDeviceQueueCreateInfo(obj.pQueueCreateInfos[i], "pQueueCreateInfos", 1);
8049          }
8050          PRINT_SPACE
8051          _OUT << "]," << std::endl;
8052     }
8053      else
8054      {
8055          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
8056      }
8057
8058      print_uint32_t(obj.enabledLayerCount, "enabledLayerCount", 1);
8059
8060      print_char(obj.ppEnabledLayerNames, "ppEnabledLayerNames", 1);
8061
8062      print_uint32_t(obj.enabledExtensionCount, "enabledExtensionCount", 1);
8063
8064      print_char(obj.ppEnabledExtensionNames, "ppEnabledExtensionNames", 1);
8065
8066      PRINT_SPACE
8067      _OUT << "\"pEnabledFeatures\": " << std::endl;
8068      if (obj.pEnabledFeatures) {
8069            print_VkPhysicalDeviceFeatures(obj.pEnabledFeatures, "pEnabledFeatures", 0);
8070      }
8071      else
8072      {
8073          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
8074      }
8075
8076      INDENT(-4);
8077      PRINT_SPACE
8078      if (commaNeeded)
8079          _OUT << "}," << std::endl;
8080      else
8081          _OUT << "}" << std::endl;
8082 }
8083 static void print_VkDeviceCreateInfo(const VkDeviceCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
8084      PRINT_SPACE
8085      _OUT << "{" << std::endl;
8086      INDENT(4);
8087
8088      print_VkStructureType(obj->sType, "sType", 1);
8089
8090       if (obj->pNext) {
8091          dumpPNextChain(obj->pNext);
8092       } else {
8093          PRINT_SPACE
8094          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8095      }
8096
8097      print_VkDeviceCreateFlags(obj->flags, "flags", 1);
8098
8099      print_uint32_t(obj->queueCreateInfoCount, "queueCreateInfoCount", 1);
8100
8101      PRINT_SPACE
8102      _OUT << "\"pQueueCreateInfos\": " << std::endl;
8103      if (obj->pQueueCreateInfos) {
8104          PRINT_SPACE
8105          _OUT << "[" << std::endl;
8106          for (unsigned int i = 0; i < obj->queueCreateInfoCount; i++) {
8107            if (i+1 == obj->queueCreateInfoCount)
8108                print_VkDeviceQueueCreateInfo(obj->pQueueCreateInfos[i], "pQueueCreateInfos", 0);
8109            else
8110                print_VkDeviceQueueCreateInfo(obj->pQueueCreateInfos[i], "pQueueCreateInfos", 1);
8111          }
8112          PRINT_SPACE
8113          _OUT << "]," << std::endl;
8114     }
8115      else
8116      {
8117          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
8118      }
8119
8120      print_uint32_t(obj->enabledLayerCount, "enabledLayerCount", 1);
8121
8122      print_char(obj->ppEnabledLayerNames, "ppEnabledLayerNames", 1);
8123
8124      print_uint32_t(obj->enabledExtensionCount, "enabledExtensionCount", 1);
8125
8126      print_char(obj->ppEnabledExtensionNames, "ppEnabledExtensionNames", 1);
8127
8128      PRINT_SPACE
8129      _OUT << "\"pEnabledFeatures\": " << std::endl;
8130      if (obj->pEnabledFeatures) {
8131            print_VkPhysicalDeviceFeatures(obj->pEnabledFeatures, "pEnabledFeatures", 0);
8132      }
8133      else
8134      {
8135          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
8136      }
8137
8138      INDENT(-4);
8139      PRINT_SPACE
8140      if (commaNeeded)
8141          _OUT << "}," << std::endl;
8142      else
8143          _OUT << "}" << std::endl;
8144 }
8145
8146 static void print_VkExtensionProperties(VkExtensionProperties obj, const std::string& s, bool commaNeeded=true) {
8147      PRINT_SPACE
8148      _OUT << "{" << std::endl;
8149      INDENT(4);
8150
8151      PRINT_SPACE
8152      _OUT << "\"extensionName\":" << std::endl;
8153      PRINT_SPACE
8154      if (obj.extensionName) {
8155        _OUT << "[" << std::endl;
8156        for (unsigned int i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++) {
8157            bool isCommaNeeded = (i+1) != VK_MAX_EXTENSION_NAME_SIZE;
8158            print_char(obj.extensionName[i], "", isCommaNeeded);
8159        }
8160        PRINT_SPACE
8161        _OUT << "]" << "," << std::endl;
8162      } else {
8163        _OUT << "\"NULL\"" << "," << std::endl;
8164      }
8165
8166      print_uint32_t(obj.specVersion, "specVersion", 0);
8167
8168      INDENT(-4);
8169      PRINT_SPACE
8170      if (commaNeeded)
8171          _OUT << "}," << std::endl;
8172      else
8173          _OUT << "}" << std::endl;
8174 }
8175 static void print_VkExtensionProperties(const VkExtensionProperties * obj, const std::string& s, bool commaNeeded=true) {
8176      PRINT_SPACE
8177      _OUT << "{" << std::endl;
8178      INDENT(4);
8179
8180      PRINT_SPACE
8181      _OUT << "\"extensionName\":" << std::endl;
8182      PRINT_SPACE
8183      if (obj->extensionName) {
8184        _OUT << "[" << std::endl;
8185        for (unsigned int i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++) {
8186            bool isCommaNeeded = (i+1) != VK_MAX_EXTENSION_NAME_SIZE;
8187            print_char(obj->extensionName[i], "", isCommaNeeded);
8188        }
8189        PRINT_SPACE
8190        _OUT << "]" << "," << std::endl;
8191      } else {
8192        _OUT << "\"NULL\"" << "," << std::endl;
8193      }
8194
8195      print_uint32_t(obj->specVersion, "specVersion", 0);
8196
8197      INDENT(-4);
8198      PRINT_SPACE
8199      if (commaNeeded)
8200          _OUT << "}," << std::endl;
8201      else
8202          _OUT << "}" << std::endl;
8203 }
8204
8205 static void print_VkLayerProperties(VkLayerProperties obj, const std::string& s, bool commaNeeded=true) {
8206      PRINT_SPACE
8207      _OUT << "{" << std::endl;
8208      INDENT(4);
8209
8210      PRINT_SPACE
8211      _OUT << "\"layerName\":" << std::endl;
8212      PRINT_SPACE
8213      if (obj.layerName) {
8214        _OUT << "[" << std::endl;
8215        for (unsigned int i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++) {
8216            bool isCommaNeeded = (i+1) != VK_MAX_EXTENSION_NAME_SIZE;
8217            print_char(obj.layerName[i], "", isCommaNeeded);
8218        }
8219        PRINT_SPACE
8220        _OUT << "]" << "," << std::endl;
8221      } else {
8222        _OUT << "\"NULL\"" << "," << std::endl;
8223      }
8224
8225      print_uint32_t(obj.specVersion, "specVersion", 1);
8226
8227      print_uint32_t(obj.implementationVersion, "implementationVersion", 1);
8228
8229      PRINT_SPACE
8230      _OUT << "\"description\":" << std::endl;
8231      PRINT_SPACE
8232      if (obj.description) {
8233        _OUT << "[" << std::endl;
8234        for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) {
8235            bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE;
8236            print_char(obj.description[i], "", isCommaNeeded);
8237        }
8238        PRINT_SPACE
8239        _OUT << "]" << "" << std::endl;
8240      } else {
8241        _OUT << "\"NULL\"" << "" << std::endl;
8242      }
8243
8244      INDENT(-4);
8245      PRINT_SPACE
8246      if (commaNeeded)
8247          _OUT << "}," << std::endl;
8248      else
8249          _OUT << "}" << std::endl;
8250 }
8251 static void print_VkLayerProperties(const VkLayerProperties * obj, const std::string& s, bool commaNeeded=true) {
8252      PRINT_SPACE
8253      _OUT << "{" << std::endl;
8254      INDENT(4);
8255
8256      PRINT_SPACE
8257      _OUT << "\"layerName\":" << std::endl;
8258      PRINT_SPACE
8259      if (obj->layerName) {
8260        _OUT << "[" << std::endl;
8261        for (unsigned int i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++) {
8262            bool isCommaNeeded = (i+1) != VK_MAX_EXTENSION_NAME_SIZE;
8263            print_char(obj->layerName[i], "", isCommaNeeded);
8264        }
8265        PRINT_SPACE
8266        _OUT << "]" << "," << std::endl;
8267      } else {
8268        _OUT << "\"NULL\"" << "," << std::endl;
8269      }
8270
8271      print_uint32_t(obj->specVersion, "specVersion", 1);
8272
8273      print_uint32_t(obj->implementationVersion, "implementationVersion", 1);
8274
8275      PRINT_SPACE
8276      _OUT << "\"description\":" << std::endl;
8277      PRINT_SPACE
8278      if (obj->description) {
8279        _OUT << "[" << std::endl;
8280        for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) {
8281            bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE;
8282            print_char(obj->description[i], "", isCommaNeeded);
8283        }
8284        PRINT_SPACE
8285        _OUT << "]" << "" << std::endl;
8286      } else {
8287        _OUT << "\"NULL\"" << "" << std::endl;
8288      }
8289
8290      INDENT(-4);
8291      PRINT_SPACE
8292      if (commaNeeded)
8293          _OUT << "}," << std::endl;
8294      else
8295          _OUT << "}" << std::endl;
8296 }
8297
8298 static void print_VkSubmitInfo(VkSubmitInfo obj, const std::string& s, bool commaNeeded=true) {
8299      PRINT_SPACE
8300      _OUT << "{" << std::endl;
8301      INDENT(4);
8302
8303      print_VkStructureType(obj.sType, "sType", 1);
8304
8305       if (obj.pNext) {
8306          dumpPNextChain(obj.pNext);
8307       } else {
8308          PRINT_SPACE
8309          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8310      }
8311
8312      print_uint32_t(obj.waitSemaphoreCount, "waitSemaphoreCount", 1);
8313
8314      PRINT_SPACE
8315      _OUT << "\"pWaitSemaphores\":" << std::endl;
8316      PRINT_SPACE
8317      if (obj.pWaitSemaphores) {
8318        _OUT << "[" << std::endl;
8319        for (unsigned int i = 0; i < obj.waitSemaphoreCount; i++) {
8320            std:: stringstream tmp;
8321            tmp << "pWaitSemaphores" << "_" << i;
8322            bool isCommaNeeded = (i+1) != obj.waitSemaphoreCount;
8323            print_VkSemaphore(obj.pWaitSemaphores[i], tmp.str(), isCommaNeeded);
8324        }
8325        PRINT_SPACE
8326        _OUT << "]" << "," << std::endl;
8327      } else {
8328        _OUT << "\"NULL\"" << "," << std::endl;
8329      }
8330
8331      PRINT_SPACE
8332      _OUT << "\"pWaitDstStageMask\":" << std::endl;
8333      PRINT_SPACE
8334      if (obj.pWaitDstStageMask) {
8335        _OUT << "[" << std::endl;
8336        for (unsigned int i = 0; i < obj.waitSemaphoreCount; i++) {
8337            bool isCommaNeeded = (i+1) != obj.waitSemaphoreCount;
8338            print_VkPipelineStageFlags(obj.pWaitDstStageMask[i], "", isCommaNeeded);
8339        }
8340        PRINT_SPACE
8341        _OUT << "]" << "," << std::endl;
8342      } else {
8343        _OUT << "\"NULL\"" << "," << std::endl;
8344      }
8345
8346      print_uint32_t(obj.commandBufferCount, "commandBufferCount", 1);
8347
8348      PRINT_SPACE
8349      _OUT << "\"pCommandBuffers\":" << std::endl;
8350      PRINT_SPACE
8351      if (obj.pCommandBuffers) {
8352        _OUT << "[" << std::endl;
8353        for (unsigned int i = 0; i < obj.commandBufferCount; i++) {
8354            std:: stringstream tmp;
8355            tmp << "pCommandBuffers" << "_" << i;
8356            bool isCommaNeeded = (i+1) != obj.commandBufferCount;
8357            print_VkCommandBuffer(obj.pCommandBuffers[i], tmp.str(), isCommaNeeded);
8358        }
8359        PRINT_SPACE
8360        _OUT << "]" << "," << std::endl;
8361      } else {
8362        _OUT << "\"NULL\"" << "," << std::endl;
8363      }
8364
8365      print_uint32_t(obj.signalSemaphoreCount, "signalSemaphoreCount", 1);
8366
8367      PRINT_SPACE
8368      _OUT << "\"pSignalSemaphores\":" << std::endl;
8369      PRINT_SPACE
8370      if (obj.pSignalSemaphores) {
8371        _OUT << "[" << std::endl;
8372        for (unsigned int i = 0; i < obj.signalSemaphoreCount; i++) {
8373            std:: stringstream tmp;
8374            tmp << "pSignalSemaphores" << "_" << i;
8375            bool isCommaNeeded = (i+1) != obj.signalSemaphoreCount;
8376            print_VkSemaphore(obj.pSignalSemaphores[i], tmp.str(), isCommaNeeded);
8377        }
8378        PRINT_SPACE
8379        _OUT << "]" << "" << std::endl;
8380      } else {
8381        _OUT << "\"NULL\"" << "" << std::endl;
8382      }
8383
8384      INDENT(-4);
8385      PRINT_SPACE
8386      if (commaNeeded)
8387          _OUT << "}," << std::endl;
8388      else
8389          _OUT << "}" << std::endl;
8390 }
8391 static void print_VkSubmitInfo(const VkSubmitInfo * obj, const std::string& s, bool commaNeeded=true) {
8392      PRINT_SPACE
8393      _OUT << "{" << std::endl;
8394      INDENT(4);
8395
8396      print_VkStructureType(obj->sType, "sType", 1);
8397
8398       if (obj->pNext) {
8399          dumpPNextChain(obj->pNext);
8400       } else {
8401          PRINT_SPACE
8402          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8403      }
8404
8405      print_uint32_t(obj->waitSemaphoreCount, "waitSemaphoreCount", 1);
8406
8407      PRINT_SPACE
8408      _OUT << "\"pWaitSemaphores\":" << std::endl;
8409      PRINT_SPACE
8410      if (obj->pWaitSemaphores) {
8411        _OUT << "[" << std::endl;
8412        for (unsigned int i = 0; i < obj->waitSemaphoreCount; i++) {
8413            std:: stringstream tmp;
8414            tmp << "pWaitSemaphores" << "_" << i;
8415            bool isCommaNeeded = (i+1) != obj->waitSemaphoreCount;
8416            print_VkSemaphore(obj->pWaitSemaphores[i], tmp.str(), isCommaNeeded);
8417        }
8418        PRINT_SPACE
8419        _OUT << "]" << "," << std::endl;
8420      } else {
8421        _OUT << "\"NULL\"" << "," << std::endl;
8422      }
8423
8424      PRINT_SPACE
8425      _OUT << "\"pWaitDstStageMask\":" << std::endl;
8426      PRINT_SPACE
8427      if (obj->pWaitDstStageMask) {
8428        _OUT << "[" << std::endl;
8429        for (unsigned int i = 0; i < obj->waitSemaphoreCount; i++) {
8430            bool isCommaNeeded = (i+1) != obj->waitSemaphoreCount;
8431            print_VkPipelineStageFlags(obj->pWaitDstStageMask[i], "", isCommaNeeded);
8432        }
8433        PRINT_SPACE
8434        _OUT << "]" << "," << std::endl;
8435      } else {
8436        _OUT << "\"NULL\"" << "," << std::endl;
8437      }
8438
8439      print_uint32_t(obj->commandBufferCount, "commandBufferCount", 1);
8440
8441      PRINT_SPACE
8442      _OUT << "\"pCommandBuffers\":" << std::endl;
8443      PRINT_SPACE
8444      if (obj->pCommandBuffers) {
8445        _OUT << "[" << std::endl;
8446        for (unsigned int i = 0; i < obj->commandBufferCount; i++) {
8447            std:: stringstream tmp;
8448            tmp << "pCommandBuffers" << "_" << i;
8449            bool isCommaNeeded = (i+1) != obj->commandBufferCount;
8450            print_VkCommandBuffer(obj->pCommandBuffers[i], tmp.str(), isCommaNeeded);
8451        }
8452        PRINT_SPACE
8453        _OUT << "]" << "," << std::endl;
8454      } else {
8455        _OUT << "\"NULL\"" << "," << std::endl;
8456      }
8457
8458      print_uint32_t(obj->signalSemaphoreCount, "signalSemaphoreCount", 1);
8459
8460      PRINT_SPACE
8461      _OUT << "\"pSignalSemaphores\":" << std::endl;
8462      PRINT_SPACE
8463      if (obj->pSignalSemaphores) {
8464        _OUT << "[" << std::endl;
8465        for (unsigned int i = 0; i < obj->signalSemaphoreCount; i++) {
8466            std:: stringstream tmp;
8467            tmp << "pSignalSemaphores" << "_" << i;
8468            bool isCommaNeeded = (i+1) != obj->signalSemaphoreCount;
8469            print_VkSemaphore(obj->pSignalSemaphores[i], tmp.str(), isCommaNeeded);
8470        }
8471        PRINT_SPACE
8472        _OUT << "]" << "" << std::endl;
8473      } else {
8474        _OUT << "\"NULL\"" << "" << std::endl;
8475      }
8476
8477      INDENT(-4);
8478      PRINT_SPACE
8479      if (commaNeeded)
8480          _OUT << "}," << std::endl;
8481      else
8482          _OUT << "}" << std::endl;
8483 }
8484
8485 static void print_VkMappedMemoryRange(VkMappedMemoryRange obj, const std::string& s, bool commaNeeded=true) {
8486      PRINT_SPACE
8487      _OUT << "{" << std::endl;
8488      INDENT(4);
8489
8490      print_VkStructureType(obj.sType, "sType", 1);
8491
8492       if (obj.pNext) {
8493          dumpPNextChain(obj.pNext);
8494       } else {
8495          PRINT_SPACE
8496          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8497      }
8498
8499      // CTS : required value
8500      PRINT_SPACE    _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl;
8501
8502      print_VkDeviceSize(obj.offset, "offset", 1);
8503
8504      print_VkDeviceSize(obj.size, "size", 0);
8505
8506      INDENT(-4);
8507      PRINT_SPACE
8508      if (commaNeeded)
8509          _OUT << "}," << std::endl;
8510      else
8511          _OUT << "}" << std::endl;
8512 }
8513 static void print_VkMappedMemoryRange(const VkMappedMemoryRange * obj, const std::string& s, bool commaNeeded=true) {
8514      PRINT_SPACE
8515      _OUT << "{" << std::endl;
8516      INDENT(4);
8517
8518      print_VkStructureType(obj->sType, "sType", 1);
8519
8520       if (obj->pNext) {
8521          dumpPNextChain(obj->pNext);
8522       } else {
8523          PRINT_SPACE
8524          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8525      }
8526
8527      // CTS : required value
8528      PRINT_SPACE    _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl;
8529
8530      print_VkDeviceSize(obj->offset, "offset", 1);
8531
8532      print_VkDeviceSize(obj->size, "size", 0);
8533
8534      INDENT(-4);
8535      PRINT_SPACE
8536      if (commaNeeded)
8537          _OUT << "}," << std::endl;
8538      else
8539          _OUT << "}" << std::endl;
8540 }
8541
8542 static void print_VkMemoryAllocateInfo(VkMemoryAllocateInfo obj, const std::string& s, bool commaNeeded=true) {
8543      PRINT_SPACE
8544      _OUT << "{" << std::endl;
8545      INDENT(4);
8546
8547      print_VkStructureType(obj.sType, "sType", 1);
8548
8549       if (obj.pNext) {
8550          dumpPNextChain(obj.pNext);
8551       } else {
8552          PRINT_SPACE
8553          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8554      }
8555
8556      print_VkDeviceSize(obj.allocationSize, "allocationSize", 1);
8557
8558      print_uint32_t(obj.memoryTypeIndex, "memoryTypeIndex", 0);
8559
8560      INDENT(-4);
8561      PRINT_SPACE
8562      if (commaNeeded)
8563          _OUT << "}," << std::endl;
8564      else
8565          _OUT << "}" << std::endl;
8566 }
8567 static void print_VkMemoryAllocateInfo(const VkMemoryAllocateInfo * obj, const std::string& s, bool commaNeeded=true) {
8568      PRINT_SPACE
8569      _OUT << "{" << std::endl;
8570      INDENT(4);
8571
8572      print_VkStructureType(obj->sType, "sType", 1);
8573
8574       if (obj->pNext) {
8575          dumpPNextChain(obj->pNext);
8576       } else {
8577          PRINT_SPACE
8578          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8579      }
8580
8581      print_VkDeviceSize(obj->allocationSize, "allocationSize", 1);
8582
8583      print_uint32_t(obj->memoryTypeIndex, "memoryTypeIndex", 0);
8584
8585      INDENT(-4);
8586      PRINT_SPACE
8587      if (commaNeeded)
8588          _OUT << "}," << std::endl;
8589      else
8590          _OUT << "}" << std::endl;
8591 }
8592
8593 static void print_VkMemoryRequirements(VkMemoryRequirements obj, const std::string& s, bool commaNeeded=true) {
8594      PRINT_SPACE
8595      _OUT << "{" << std::endl;
8596      INDENT(4);
8597
8598      print_VkDeviceSize(obj.size, "size", 1);
8599
8600      print_VkDeviceSize(obj.alignment, "alignment", 1);
8601
8602      print_uint32_t(obj.memoryTypeBits, "memoryTypeBits", 0);
8603
8604      INDENT(-4);
8605      PRINT_SPACE
8606      if (commaNeeded)
8607          _OUT << "}," << std::endl;
8608      else
8609          _OUT << "}" << std::endl;
8610 }
8611 static void print_VkMemoryRequirements(const VkMemoryRequirements * obj, const std::string& s, bool commaNeeded=true) {
8612      PRINT_SPACE
8613      _OUT << "{" << std::endl;
8614      INDENT(4);
8615
8616      print_VkDeviceSize(obj->size, "size", 1);
8617
8618      print_VkDeviceSize(obj->alignment, "alignment", 1);
8619
8620      print_uint32_t(obj->memoryTypeBits, "memoryTypeBits", 0);
8621
8622      INDENT(-4);
8623      PRINT_SPACE
8624      if (commaNeeded)
8625          _OUT << "}," << std::endl;
8626      else
8627          _OUT << "}" << std::endl;
8628 }
8629
8630 static void print_VkImageSubresource(VkImageSubresource obj, const std::string& s, bool commaNeeded=true) {
8631      PRINT_SPACE
8632      _OUT << "{" << std::endl;
8633      INDENT(4);
8634
8635      print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 1);
8636
8637      print_uint32_t(obj.mipLevel, "mipLevel", 1);
8638
8639      print_uint32_t(obj.arrayLayer, "arrayLayer", 0);
8640
8641      INDENT(-4);
8642      PRINT_SPACE
8643      if (commaNeeded)
8644          _OUT << "}," << std::endl;
8645      else
8646          _OUT << "}" << std::endl;
8647 }
8648 static void print_VkImageSubresource(const VkImageSubresource * obj, const std::string& s, bool commaNeeded=true) {
8649      PRINT_SPACE
8650      _OUT << "{" << std::endl;
8651      INDENT(4);
8652
8653      print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 1);
8654
8655      print_uint32_t(obj->mipLevel, "mipLevel", 1);
8656
8657      print_uint32_t(obj->arrayLayer, "arrayLayer", 0);
8658
8659      INDENT(-4);
8660      PRINT_SPACE
8661      if (commaNeeded)
8662          _OUT << "}," << std::endl;
8663      else
8664          _OUT << "}" << std::endl;
8665 }
8666
8667 static void print_VkFenceCreateInfo(VkFenceCreateInfo obj, const std::string& s, bool commaNeeded=true) {
8668      PRINT_SPACE
8669      _OUT << "{" << std::endl;
8670      INDENT(4);
8671
8672      print_VkStructureType(obj.sType, "sType", 1);
8673
8674       if (obj.pNext) {
8675          dumpPNextChain(obj.pNext);
8676       } else {
8677          PRINT_SPACE
8678          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8679      }
8680
8681      print_VkFenceCreateFlags(obj.flags, "flags", 0);
8682
8683      INDENT(-4);
8684      PRINT_SPACE
8685      if (commaNeeded)
8686          _OUT << "}," << std::endl;
8687      else
8688          _OUT << "}" << std::endl;
8689 }
8690 static void print_VkFenceCreateInfo(const VkFenceCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
8691      PRINT_SPACE
8692      _OUT << "{" << std::endl;
8693      INDENT(4);
8694
8695      print_VkStructureType(obj->sType, "sType", 1);
8696
8697       if (obj->pNext) {
8698          dumpPNextChain(obj->pNext);
8699       } else {
8700          PRINT_SPACE
8701          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8702      }
8703
8704      print_VkFenceCreateFlags(obj->flags, "flags", 0);
8705
8706      INDENT(-4);
8707      PRINT_SPACE
8708      if (commaNeeded)
8709          _OUT << "}," << std::endl;
8710      else
8711          _OUT << "}" << std::endl;
8712 }
8713
8714 static void print_VkSemaphoreCreateInfo(VkSemaphoreCreateInfo obj, const std::string& s, bool commaNeeded=true) {
8715      PRINT_SPACE
8716      _OUT << "{" << std::endl;
8717      INDENT(4);
8718
8719      print_VkStructureType(obj.sType, "sType", 1);
8720
8721       if (obj.pNext) {
8722          dumpPNextChain(obj.pNext);
8723       } else {
8724          PRINT_SPACE
8725          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8726      }
8727
8728      print_VkSemaphoreCreateFlags(obj.flags, "flags", 0);
8729
8730      INDENT(-4);
8731      PRINT_SPACE
8732      if (commaNeeded)
8733          _OUT << "}," << std::endl;
8734      else
8735          _OUT << "}" << std::endl;
8736 }
8737 static void print_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
8738      PRINT_SPACE
8739      _OUT << "{" << std::endl;
8740      INDENT(4);
8741
8742      print_VkStructureType(obj->sType, "sType", 1);
8743
8744       if (obj->pNext) {
8745          dumpPNextChain(obj->pNext);
8746       } else {
8747          PRINT_SPACE
8748          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8749      }
8750
8751      print_VkSemaphoreCreateFlags(obj->flags, "flags", 0);
8752
8753      INDENT(-4);
8754      PRINT_SPACE
8755      if (commaNeeded)
8756          _OUT << "}," << std::endl;
8757      else
8758          _OUT << "}" << std::endl;
8759 }
8760
8761 static void print_VkEventCreateInfo(VkEventCreateInfo obj, const std::string& s, bool commaNeeded=true) {
8762      PRINT_SPACE
8763      _OUT << "{" << std::endl;
8764      INDENT(4);
8765
8766      print_VkStructureType(obj.sType, "sType", 1);
8767
8768       if (obj.pNext) {
8769          dumpPNextChain(obj.pNext);
8770       } else {
8771          PRINT_SPACE
8772          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8773      }
8774
8775      print_VkEventCreateFlags(obj.flags, "flags", 0);
8776
8777      INDENT(-4);
8778      PRINT_SPACE
8779      if (commaNeeded)
8780          _OUT << "}," << std::endl;
8781      else
8782          _OUT << "}" << std::endl;
8783 }
8784 static void print_VkEventCreateInfo(const VkEventCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
8785      PRINT_SPACE
8786      _OUT << "{" << std::endl;
8787      INDENT(4);
8788
8789      print_VkStructureType(obj->sType, "sType", 1);
8790
8791       if (obj->pNext) {
8792          dumpPNextChain(obj->pNext);
8793       } else {
8794          PRINT_SPACE
8795          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8796      }
8797
8798      print_VkEventCreateFlags(obj->flags, "flags", 0);
8799
8800      INDENT(-4);
8801      PRINT_SPACE
8802      if (commaNeeded)
8803          _OUT << "}," << std::endl;
8804      else
8805          _OUT << "}" << std::endl;
8806 }
8807
8808 static void print_VkQueryPoolCreateInfo(VkQueryPoolCreateInfo obj, const std::string& s, bool commaNeeded=true) {
8809      PRINT_SPACE
8810      _OUT << "{" << std::endl;
8811      INDENT(4);
8812
8813      print_VkStructureType(obj.sType, "sType", 1);
8814
8815       if (obj.pNext) {
8816          dumpPNextChain(obj.pNext);
8817       } else {
8818          PRINT_SPACE
8819          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8820      }
8821
8822      print_VkQueryPoolCreateFlags(obj.flags, "flags", 1);
8823
8824      print_VkQueryType(obj.queryType, "queryType", 1);
8825
8826      print_uint32_t(obj.queryCount, "queryCount", 1);
8827
8828      print_VkQueryPipelineStatisticFlags(obj.pipelineStatistics, "pipelineStatistics", 0);
8829
8830      INDENT(-4);
8831      PRINT_SPACE
8832      if (commaNeeded)
8833          _OUT << "}," << std::endl;
8834      else
8835          _OUT << "}" << std::endl;
8836 }
8837 static void print_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
8838      PRINT_SPACE
8839      _OUT << "{" << std::endl;
8840      INDENT(4);
8841
8842      print_VkStructureType(obj->sType, "sType", 1);
8843
8844       if (obj->pNext) {
8845          dumpPNextChain(obj->pNext);
8846       } else {
8847          PRINT_SPACE
8848          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8849      }
8850
8851      print_VkQueryPoolCreateFlags(obj->flags, "flags", 1);
8852
8853      print_VkQueryType(obj->queryType, "queryType", 1);
8854
8855      print_uint32_t(obj->queryCount, "queryCount", 1);
8856
8857      print_VkQueryPipelineStatisticFlags(obj->pipelineStatistics, "pipelineStatistics", 0);
8858
8859      INDENT(-4);
8860      PRINT_SPACE
8861      if (commaNeeded)
8862          _OUT << "}," << std::endl;
8863      else
8864          _OUT << "}" << std::endl;
8865 }
8866
8867 static void print_VkBufferCreateInfo(VkBufferCreateInfo obj, const std::string& s, bool commaNeeded=true) {
8868      PRINT_SPACE
8869      _OUT << "{" << std::endl;
8870      INDENT(4);
8871
8872      print_VkStructureType(obj.sType, "sType", 1);
8873
8874       if (obj.pNext) {
8875          dumpPNextChain(obj.pNext);
8876       } else {
8877          PRINT_SPACE
8878          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8879      }
8880
8881      print_VkBufferCreateFlags(obj.flags, "flags", 1);
8882
8883      print_VkDeviceSize(obj.size, "size", 1);
8884
8885      print_VkBufferUsageFlags(obj.usage, "usage", 1);
8886
8887      print_VkSharingMode(obj.sharingMode, "sharingMode", 1);
8888
8889      print_uint32_t(obj.queueFamilyIndexCount, "queueFamilyIndexCount", 1);
8890
8891      PRINT_SPACE
8892      _OUT << "\"pQueueFamilyIndices\":" << std::endl;
8893      PRINT_SPACE
8894      if (obj.pQueueFamilyIndices) {
8895        _OUT << "[" << std::endl;
8896        for (unsigned int i = 0; i < obj.queueFamilyIndexCount; i++) {
8897            bool isCommaNeeded = (i+1) != obj.queueFamilyIndexCount;
8898            print_uint32_t(obj.pQueueFamilyIndices[i], "", isCommaNeeded);
8899        }
8900        PRINT_SPACE
8901        _OUT << "]" << "" << std::endl;
8902      } else {
8903        _OUT << "\"NULL\"" << "" << std::endl;
8904      }
8905
8906      INDENT(-4);
8907      PRINT_SPACE
8908      if (commaNeeded)
8909          _OUT << "}," << std::endl;
8910      else
8911          _OUT << "}" << std::endl;
8912 }
8913 static void print_VkBufferCreateInfo(const VkBufferCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
8914      PRINT_SPACE
8915      _OUT << "{" << std::endl;
8916      INDENT(4);
8917
8918      print_VkStructureType(obj->sType, "sType", 1);
8919
8920       if (obj->pNext) {
8921          dumpPNextChain(obj->pNext);
8922       } else {
8923          PRINT_SPACE
8924          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8925      }
8926
8927      print_VkBufferCreateFlags(obj->flags, "flags", 1);
8928
8929      print_VkDeviceSize(obj->size, "size", 1);
8930
8931      print_VkBufferUsageFlags(obj->usage, "usage", 1);
8932
8933      print_VkSharingMode(obj->sharingMode, "sharingMode", 1);
8934
8935      print_uint32_t(obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1);
8936
8937      PRINT_SPACE
8938      _OUT << "\"pQueueFamilyIndices\":" << std::endl;
8939      PRINT_SPACE
8940      if (obj->pQueueFamilyIndices) {
8941        _OUT << "[" << std::endl;
8942        for (unsigned int i = 0; i < obj->queueFamilyIndexCount; i++) {
8943            bool isCommaNeeded = (i+1) != obj->queueFamilyIndexCount;
8944            print_uint32_t(obj->pQueueFamilyIndices[i], "", isCommaNeeded);
8945        }
8946        PRINT_SPACE
8947        _OUT << "]" << "" << std::endl;
8948      } else {
8949        _OUT << "\"NULL\"" << "" << std::endl;
8950      }
8951
8952      INDENT(-4);
8953      PRINT_SPACE
8954      if (commaNeeded)
8955          _OUT << "}," << std::endl;
8956      else
8957          _OUT << "}" << std::endl;
8958 }
8959
8960 static void print_VkBufferViewCreateInfo(VkBufferViewCreateInfo obj, const std::string& s, bool commaNeeded=true) {
8961      PRINT_SPACE
8962      _OUT << "{" << std::endl;
8963      INDENT(4);
8964
8965      print_VkStructureType(obj.sType, "sType", 1);
8966
8967       if (obj.pNext) {
8968          dumpPNextChain(obj.pNext);
8969       } else {
8970          PRINT_SPACE
8971          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
8972      }
8973
8974      print_VkBufferViewCreateFlags(obj.flags, "flags", 1);
8975
8976      // CTS : required value
8977      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl;
8978
8979      print_VkFormat(obj.format, "format", 1);
8980
8981      print_VkDeviceSize(obj.offset, "offset", 1);
8982
8983      print_VkDeviceSize(obj.range, "range", 0);
8984
8985      INDENT(-4);
8986      PRINT_SPACE
8987      if (commaNeeded)
8988          _OUT << "}," << std::endl;
8989      else
8990          _OUT << "}" << std::endl;
8991 }
8992 static void print_VkBufferViewCreateInfo(const VkBufferViewCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
8993      PRINT_SPACE
8994      _OUT << "{" << std::endl;
8995      INDENT(4);
8996
8997      print_VkStructureType(obj->sType, "sType", 1);
8998
8999       if (obj->pNext) {
9000          dumpPNextChain(obj->pNext);
9001       } else {
9002          PRINT_SPACE
9003          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9004      }
9005
9006      print_VkBufferViewCreateFlags(obj->flags, "flags", 1);
9007
9008      // CTS : required value
9009      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl;
9010
9011      print_VkFormat(obj->format, "format", 1);
9012
9013      print_VkDeviceSize(obj->offset, "offset", 1);
9014
9015      print_VkDeviceSize(obj->range, "range", 0);
9016
9017      INDENT(-4);
9018      PRINT_SPACE
9019      if (commaNeeded)
9020          _OUT << "}," << std::endl;
9021      else
9022          _OUT << "}" << std::endl;
9023 }
9024
9025 static void print_VkImageCreateInfo(VkImageCreateInfo obj, const std::string& s, bool commaNeeded=true) {
9026      PRINT_SPACE
9027      _OUT << "{" << std::endl;
9028      INDENT(4);
9029
9030      print_VkStructureType(obj.sType, "sType", 1);
9031
9032       if (obj.pNext) {
9033          dumpPNextChain(obj.pNext);
9034       } else {
9035          PRINT_SPACE
9036          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9037      }
9038
9039      print_VkImageCreateFlags(obj.flags, "flags", 1);
9040
9041      print_VkImageType(obj.imageType, "imageType", 1);
9042
9043      print_VkFormat(obj.format, "format", 1);
9044
9045      PRINT_SPACE
9046      _OUT << "\"extent\": " << std::endl;
9047      {
9048            print_VkExtent3D(obj.extent, "extent", 1);
9049      }
9050
9051      print_uint32_t(obj.mipLevels, "mipLevels", 1);
9052
9053      print_uint32_t(obj.arrayLayers, "arrayLayers", 1);
9054
9055      print_VkSampleCountFlagBits(obj.samples, "samples", 1);
9056
9057      print_VkImageTiling(obj.tiling, "tiling", 1);
9058
9059      print_VkImageUsageFlags(obj.usage, "usage", 1);
9060
9061      print_VkSharingMode(obj.sharingMode, "sharingMode", 1);
9062
9063      print_uint32_t(obj.queueFamilyIndexCount, "queueFamilyIndexCount", 1);
9064
9065      PRINT_SPACE
9066      _OUT << "\"pQueueFamilyIndices\":" << std::endl;
9067      PRINT_SPACE
9068      if (obj.pQueueFamilyIndices) {
9069        _OUT << "[" << std::endl;
9070        for (unsigned int i = 0; i < obj.queueFamilyIndexCount; i++) {
9071            bool isCommaNeeded = (i+1) != obj.queueFamilyIndexCount;
9072            print_uint32_t(obj.pQueueFamilyIndices[i], "", isCommaNeeded);
9073        }
9074        PRINT_SPACE
9075        _OUT << "]" << "," << std::endl;
9076      } else {
9077        _OUT << "\"NULL\"" << "," << std::endl;
9078      }
9079
9080      print_VkImageLayout(obj.initialLayout, "initialLayout", 0);
9081
9082      INDENT(-4);
9083      PRINT_SPACE
9084      if (commaNeeded)
9085          _OUT << "}," << std::endl;
9086      else
9087          _OUT << "}" << std::endl;
9088 }
9089 static void print_VkImageCreateInfo(const VkImageCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
9090      PRINT_SPACE
9091      _OUT << "{" << std::endl;
9092      INDENT(4);
9093
9094      print_VkStructureType(obj->sType, "sType", 1);
9095
9096       if (obj->pNext) {
9097          dumpPNextChain(obj->pNext);
9098       } else {
9099          PRINT_SPACE
9100          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9101      }
9102
9103      print_VkImageCreateFlags(obj->flags, "flags", 1);
9104
9105      print_VkImageType(obj->imageType, "imageType", 1);
9106
9107      print_VkFormat(obj->format, "format", 1);
9108
9109      PRINT_SPACE
9110      _OUT << "\"extent\": " << std::endl;
9111      {
9112            print_VkExtent3D(obj->extent, "extent", 1);
9113      }
9114
9115      print_uint32_t(obj->mipLevels, "mipLevels", 1);
9116
9117      print_uint32_t(obj->arrayLayers, "arrayLayers", 1);
9118
9119      print_VkSampleCountFlagBits(obj->samples, "samples", 1);
9120
9121      print_VkImageTiling(obj->tiling, "tiling", 1);
9122
9123      print_VkImageUsageFlags(obj->usage, "usage", 1);
9124
9125      print_VkSharingMode(obj->sharingMode, "sharingMode", 1);
9126
9127      print_uint32_t(obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1);
9128
9129      PRINT_SPACE
9130      _OUT << "\"pQueueFamilyIndices\":" << std::endl;
9131      PRINT_SPACE
9132      if (obj->pQueueFamilyIndices) {
9133        _OUT << "[" << std::endl;
9134        for (unsigned int i = 0; i < obj->queueFamilyIndexCount; i++) {
9135            bool isCommaNeeded = (i+1) != obj->queueFamilyIndexCount;
9136            print_uint32_t(obj->pQueueFamilyIndices[i], "", isCommaNeeded);
9137        }
9138        PRINT_SPACE
9139        _OUT << "]" << "," << std::endl;
9140      } else {
9141        _OUT << "\"NULL\"" << "," << std::endl;
9142      }
9143
9144      print_VkImageLayout(obj->initialLayout, "initialLayout", 0);
9145
9146      INDENT(-4);
9147      PRINT_SPACE
9148      if (commaNeeded)
9149          _OUT << "}," << std::endl;
9150      else
9151          _OUT << "}" << std::endl;
9152 }
9153
9154 static void print_VkSubresourceLayout(VkSubresourceLayout obj, const std::string& s, bool commaNeeded=true) {
9155      PRINT_SPACE
9156      _OUT << "{" << std::endl;
9157      INDENT(4);
9158
9159      print_VkDeviceSize(obj.offset, "offset", 1);
9160
9161      print_VkDeviceSize(obj.size, "size", 1);
9162
9163      print_VkDeviceSize(obj.rowPitch, "rowPitch", 1);
9164
9165      print_VkDeviceSize(obj.arrayPitch, "arrayPitch", 1);
9166
9167      print_VkDeviceSize(obj.depthPitch, "depthPitch", 0);
9168
9169      INDENT(-4);
9170      PRINT_SPACE
9171      if (commaNeeded)
9172          _OUT << "}," << std::endl;
9173      else
9174          _OUT << "}" << std::endl;
9175 }
9176 static void print_VkSubresourceLayout(const VkSubresourceLayout * obj, const std::string& s, bool commaNeeded=true) {
9177      PRINT_SPACE
9178      _OUT << "{" << std::endl;
9179      INDENT(4);
9180
9181      print_VkDeviceSize(obj->offset, "offset", 1);
9182
9183      print_VkDeviceSize(obj->size, "size", 1);
9184
9185      print_VkDeviceSize(obj->rowPitch, "rowPitch", 1);
9186
9187      print_VkDeviceSize(obj->arrayPitch, "arrayPitch", 1);
9188
9189      print_VkDeviceSize(obj->depthPitch, "depthPitch", 0);
9190
9191      INDENT(-4);
9192      PRINT_SPACE
9193      if (commaNeeded)
9194          _OUT << "}," << std::endl;
9195      else
9196          _OUT << "}" << std::endl;
9197 }
9198
9199 static void print_VkComponentMapping(VkComponentMapping obj, const std::string& s, bool commaNeeded=true) {
9200      PRINT_SPACE
9201      _OUT << "{" << std::endl;
9202      INDENT(4);
9203
9204      print_VkComponentSwizzle(obj.r, "r", 1);
9205
9206      print_VkComponentSwizzle(obj.g, "g", 1);
9207
9208      print_VkComponentSwizzle(obj.b, "b", 1);
9209
9210      print_VkComponentSwizzle(obj.a, "a", 0);
9211
9212      INDENT(-4);
9213      PRINT_SPACE
9214      if (commaNeeded)
9215          _OUT << "}," << std::endl;
9216      else
9217          _OUT << "}" << std::endl;
9218 }
9219 static void print_VkComponentMapping(const VkComponentMapping * obj, const std::string& s, bool commaNeeded=true) {
9220      PRINT_SPACE
9221      _OUT << "{" << std::endl;
9222      INDENT(4);
9223
9224      print_VkComponentSwizzle(obj->r, "r", 1);
9225
9226      print_VkComponentSwizzle(obj->g, "g", 1);
9227
9228      print_VkComponentSwizzle(obj->b, "b", 1);
9229
9230      print_VkComponentSwizzle(obj->a, "a", 0);
9231
9232      INDENT(-4);
9233      PRINT_SPACE
9234      if (commaNeeded)
9235          _OUT << "}," << std::endl;
9236      else
9237          _OUT << "}" << std::endl;
9238 }
9239
9240 static void print_VkImageViewCreateInfo(VkImageViewCreateInfo obj, const std::string& s, bool commaNeeded=true) {
9241      PRINT_SPACE
9242      _OUT << "{" << std::endl;
9243      INDENT(4);
9244
9245      print_VkStructureType(obj.sType, "sType", 1);
9246
9247       if (obj.pNext) {
9248          dumpPNextChain(obj.pNext);
9249       } else {
9250          PRINT_SPACE
9251          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9252      }
9253
9254      print_VkImageViewCreateFlags(obj.flags, "flags", 1);
9255
9256      // CTS : required value
9257      PRINT_SPACE    _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl;
9258
9259      print_VkImageViewType(obj.viewType, "viewType", 1);
9260
9261      print_VkFormat(obj.format, "format", 1);
9262
9263      PRINT_SPACE
9264      _OUT << "\"components\": " << std::endl;
9265      {
9266            print_VkComponentMapping(obj.components, "components", 1);
9267      }
9268
9269      PRINT_SPACE
9270      _OUT << "\"subresourceRange\": " << std::endl;
9271      {
9272            print_VkImageSubresourceRange(obj.subresourceRange, "subresourceRange", 0);
9273      }
9274
9275      INDENT(-4);
9276      PRINT_SPACE
9277      if (commaNeeded)
9278          _OUT << "}," << std::endl;
9279      else
9280          _OUT << "}" << std::endl;
9281 }
9282 static void print_VkImageViewCreateInfo(const VkImageViewCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
9283      PRINT_SPACE
9284      _OUT << "{" << std::endl;
9285      INDENT(4);
9286
9287      print_VkStructureType(obj->sType, "sType", 1);
9288
9289       if (obj->pNext) {
9290          dumpPNextChain(obj->pNext);
9291       } else {
9292          PRINT_SPACE
9293          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9294      }
9295
9296      print_VkImageViewCreateFlags(obj->flags, "flags", 1);
9297
9298      // CTS : required value
9299      PRINT_SPACE    _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl;
9300
9301      print_VkImageViewType(obj->viewType, "viewType", 1);
9302
9303      print_VkFormat(obj->format, "format", 1);
9304
9305      PRINT_SPACE
9306      _OUT << "\"components\": " << std::endl;
9307      {
9308            print_VkComponentMapping(obj->components, "components", 1);
9309      }
9310
9311      PRINT_SPACE
9312      _OUT << "\"subresourceRange\": " << std::endl;
9313      {
9314            print_VkImageSubresourceRange(obj->subresourceRange, "subresourceRange", 0);
9315      }
9316
9317      INDENT(-4);
9318      PRINT_SPACE
9319      if (commaNeeded)
9320          _OUT << "}," << std::endl;
9321      else
9322          _OUT << "}" << std::endl;
9323 }
9324
9325 static void print_VkPipelineCacheCreateInfo(VkPipelineCacheCreateInfo obj, const std::string& s, bool commaNeeded=true) {
9326      PRINT_SPACE
9327      _OUT << "{" << std::endl;
9328      INDENT(4);
9329
9330      print_VkStructureType(obj.sType, "sType", 1);
9331
9332       if (obj.pNext) {
9333          dumpPNextChain(obj.pNext);
9334       } else {
9335          PRINT_SPACE
9336          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9337      }
9338
9339      print_VkPipelineCacheCreateFlags(obj.flags, "flags", 1);
9340
9341      print_size_t(obj.initialDataSize, "initialDataSize", 1);
9342
9343      print_void_data(obj.pInitialData, int(obj.initialDataSize), "pInitialData", 0);
9344
9345      INDENT(-4);
9346      PRINT_SPACE
9347      if (commaNeeded)
9348          _OUT << "}," << std::endl;
9349      else
9350          _OUT << "}" << std::endl;
9351 }
9352 static void print_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
9353      PRINT_SPACE
9354      _OUT << "{" << std::endl;
9355      INDENT(4);
9356
9357      print_VkStructureType(obj->sType, "sType", 1);
9358
9359       if (obj->pNext) {
9360          dumpPNextChain(obj->pNext);
9361       } else {
9362          PRINT_SPACE
9363          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9364      }
9365
9366      print_VkPipelineCacheCreateFlags(obj->flags, "flags", 1);
9367
9368      print_size_t(obj->initialDataSize, "initialDataSize", 1);
9369
9370      print_void_data(obj->pInitialData, int(obj->initialDataSize), "pInitialData", 0);
9371
9372      INDENT(-4);
9373      PRINT_SPACE
9374      if (commaNeeded)
9375          _OUT << "}," << std::endl;
9376      else
9377          _OUT << "}" << std::endl;
9378 }
9379
9380 static void print_VkSpecializationMapEntry(VkSpecializationMapEntry obj, const std::string& s, bool commaNeeded=true) {
9381      PRINT_SPACE
9382      _OUT << "{" << std::endl;
9383      INDENT(4);
9384
9385      print_uint32_t(obj.constantID, "constantID", 1);
9386
9387      print_uint32_t(obj.offset, "offset", 1);
9388
9389      print_size_t(obj.size, "size", 0);
9390
9391      INDENT(-4);
9392      PRINT_SPACE
9393      if (commaNeeded)
9394          _OUT << "}," << std::endl;
9395      else
9396          _OUT << "}" << std::endl;
9397 }
9398 static void print_VkSpecializationMapEntry(const VkSpecializationMapEntry * obj, const std::string& s, bool commaNeeded=true) {
9399      PRINT_SPACE
9400      _OUT << "{" << std::endl;
9401      INDENT(4);
9402
9403      print_uint32_t(obj->constantID, "constantID", 1);
9404
9405      print_uint32_t(obj->offset, "offset", 1);
9406
9407      print_size_t(obj->size, "size", 0);
9408
9409      INDENT(-4);
9410      PRINT_SPACE
9411      if (commaNeeded)
9412          _OUT << "}," << std::endl;
9413      else
9414          _OUT << "}" << std::endl;
9415 }
9416
9417 static void print_VkSpecializationInfo(VkSpecializationInfo obj, const std::string& s, bool commaNeeded=true) {
9418      PRINT_SPACE
9419      _OUT << "{" << std::endl;
9420      INDENT(4);
9421
9422      print_uint32_t(obj.mapEntryCount, "mapEntryCount", 1);
9423
9424      PRINT_SPACE
9425      _OUT << "\"pMapEntries\": " << std::endl;
9426      if (obj.pMapEntries) {
9427          PRINT_SPACE
9428          _OUT << "[" << std::endl;
9429          for (unsigned int i = 0; i < obj.mapEntryCount; i++) {
9430            if (i+1 == obj.mapEntryCount)
9431                print_VkSpecializationMapEntry(obj.pMapEntries[i], "pMapEntries", 0);
9432            else
9433                print_VkSpecializationMapEntry(obj.pMapEntries[i], "pMapEntries", 1);
9434          }
9435          PRINT_SPACE
9436          _OUT << "]," << std::endl;
9437     }
9438      else
9439      {
9440          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
9441      }
9442
9443      print_size_t(obj.dataSize, "dataSize", 1);
9444
9445      print_void_data(obj.pData, int(obj.dataSize), "pData", 0);
9446
9447      INDENT(-4);
9448      PRINT_SPACE
9449      if (commaNeeded)
9450          _OUT << "}," << std::endl;
9451      else
9452          _OUT << "}" << std::endl;
9453 }
9454 static void print_VkSpecializationInfo(const VkSpecializationInfo * obj, const std::string& s, bool commaNeeded=true) {
9455      PRINT_SPACE
9456      _OUT << "{" << std::endl;
9457      INDENT(4);
9458
9459      print_uint32_t(obj->mapEntryCount, "mapEntryCount", 1);
9460
9461      PRINT_SPACE
9462      _OUT << "\"pMapEntries\": " << std::endl;
9463      if (obj->pMapEntries) {
9464          PRINT_SPACE
9465          _OUT << "[" << std::endl;
9466          for (unsigned int i = 0; i < obj->mapEntryCount; i++) {
9467            if (i+1 == obj->mapEntryCount)
9468                print_VkSpecializationMapEntry(obj->pMapEntries[i], "pMapEntries", 0);
9469            else
9470                print_VkSpecializationMapEntry(obj->pMapEntries[i], "pMapEntries", 1);
9471          }
9472          PRINT_SPACE
9473          _OUT << "]," << std::endl;
9474     }
9475      else
9476      {
9477          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
9478      }
9479
9480      print_size_t(obj->dataSize, "dataSize", 1);
9481
9482      print_void_data(obj->pData, int(obj->dataSize), "pData", 0);
9483
9484      INDENT(-4);
9485      PRINT_SPACE
9486      if (commaNeeded)
9487          _OUT << "}," << std::endl;
9488      else
9489          _OUT << "}" << std::endl;
9490 }
9491
9492 static void print_VkPipelineShaderStageCreateInfo(VkPipelineShaderStageCreateInfo obj, const std::string& s, bool commaNeeded=true) {
9493      PRINT_SPACE
9494      _OUT << "{" << std::endl;
9495      INDENT(4);
9496
9497      print_VkStructureType(obj.sType, "sType", 1);
9498
9499       if (obj.pNext) {
9500          dumpPNextChain(obj.pNext);
9501       } else {
9502          PRINT_SPACE
9503          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9504      }
9505
9506      print_VkPipelineShaderStageCreateFlags(obj.flags, "flags", 1);
9507
9508      print_VkShaderStageFlagBits(obj.stage, "stage", 1);
9509
9510      // CTS : required value
9511      PRINT_SPACE    _OUT << "\"" << "module" << "\"" << " : " << obj.module.getInternal() << "," << std::endl;
9512
9513      print_char(obj.pName, "pName", 1);
9514
9515      PRINT_SPACE
9516      _OUT << "\"pSpecializationInfo\": " << std::endl;
9517      if (obj.pSpecializationInfo) {
9518            print_VkSpecializationInfo(obj.pSpecializationInfo, "pSpecializationInfo", 0);
9519      }
9520      else
9521      {
9522          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
9523      }
9524
9525      INDENT(-4);
9526      PRINT_SPACE
9527      if (commaNeeded)
9528          _OUT << "}," << std::endl;
9529      else
9530          _OUT << "}" << std::endl;
9531 }
9532 static void print_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
9533      PRINT_SPACE
9534      _OUT << "{" << std::endl;
9535      INDENT(4);
9536
9537      print_VkStructureType(obj->sType, "sType", 1);
9538
9539       if (obj->pNext) {
9540          dumpPNextChain(obj->pNext);
9541       } else {
9542          PRINT_SPACE
9543          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9544      }
9545
9546      print_VkPipelineShaderStageCreateFlags(obj->flags, "flags", 1);
9547
9548      print_VkShaderStageFlagBits(obj->stage, "stage", 1);
9549
9550      // CTS : required value
9551      PRINT_SPACE    _OUT << "\"" << "module" << "\"" << " : " << obj->module.getInternal() << "," << std::endl;
9552
9553      print_char(obj->pName, "pName", 1);
9554
9555      PRINT_SPACE
9556      _OUT << "\"pSpecializationInfo\": " << std::endl;
9557      if (obj->pSpecializationInfo) {
9558            print_VkSpecializationInfo(obj->pSpecializationInfo, "pSpecializationInfo", 0);
9559      }
9560      else
9561      {
9562          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
9563      }
9564
9565      INDENT(-4);
9566      PRINT_SPACE
9567      if (commaNeeded)
9568          _OUT << "}," << std::endl;
9569      else
9570          _OUT << "}" << std::endl;
9571 }
9572
9573 static void print_VkComputePipelineCreateInfo(VkComputePipelineCreateInfo obj, const std::string& s, bool commaNeeded=true) {
9574      PRINT_SPACE
9575      _OUT << "{" << std::endl;
9576      INDENT(4);
9577
9578      print_VkStructureType(obj.sType, "sType", 1);
9579
9580       if (obj.pNext) {
9581          dumpPNextChain(obj.pNext);
9582       } else {
9583          PRINT_SPACE
9584          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9585      }
9586
9587      print_VkPipelineCreateFlags(obj.flags, "flags", 1);
9588
9589      PRINT_SPACE
9590      _OUT << "\"stage\": " << std::endl;
9591      {
9592            print_VkPipelineShaderStageCreateInfo(obj.stage, "stage", 1);
9593      }
9594
9595      // CTS : required value
9596      PRINT_SPACE    _OUT << "\"" << "layout" << "\"" << " : " << obj.layout.getInternal() << "," << std::endl;
9597
9598      // CTS : required value
9599      PRINT_SPACE    _OUT << "\"" << "basePipelineHandle" << "\"" << " : " << "\"" << "\"," << std::endl;
9600
9601      print_int32_t(obj.basePipelineIndex, "basePipelineIndex", 0);
9602
9603      INDENT(-4);
9604      PRINT_SPACE
9605      if (commaNeeded)
9606          _OUT << "}," << std::endl;
9607      else
9608          _OUT << "}" << std::endl;
9609 }
9610 static void print_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
9611      PRINT_SPACE
9612      _OUT << "{" << std::endl;
9613      INDENT(4);
9614
9615      print_VkStructureType(obj->sType, "sType", 1);
9616
9617       if (obj->pNext) {
9618          dumpPNextChain(obj->pNext);
9619       } else {
9620          PRINT_SPACE
9621          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9622      }
9623
9624      print_VkPipelineCreateFlags(obj->flags, "flags", 1);
9625
9626      PRINT_SPACE
9627      _OUT << "\"stage\": " << std::endl;
9628      {
9629            print_VkPipelineShaderStageCreateInfo(obj->stage, "stage", 1);
9630      }
9631
9632      // CTS : required value
9633      PRINT_SPACE    _OUT << "\"" << "layout" << "\"" << " : " << obj->layout.getInternal() << "," << std::endl;
9634
9635      // CTS : required value
9636      PRINT_SPACE    _OUT << "\"" << "basePipelineHandle" << "\"" << " : " << "\"" << "\"," << std::endl;
9637
9638      print_int32_t(obj->basePipelineIndex, "basePipelineIndex", 0);
9639
9640      INDENT(-4);
9641      PRINT_SPACE
9642      if (commaNeeded)
9643          _OUT << "}," << std::endl;
9644      else
9645          _OUT << "}" << std::endl;
9646 }
9647
9648 static void print_VkVertexInputBindingDescription(VkVertexInputBindingDescription obj, const std::string& s, bool commaNeeded=true) {
9649      PRINT_SPACE
9650      _OUT << "{" << std::endl;
9651      INDENT(4);
9652
9653      print_uint32_t(obj.binding, "binding", 1);
9654
9655      print_uint32_t(obj.stride, "stride", 1);
9656
9657      print_VkVertexInputRate(obj.inputRate, "inputRate", 0);
9658
9659      INDENT(-4);
9660      PRINT_SPACE
9661      if (commaNeeded)
9662          _OUT << "}," << std::endl;
9663      else
9664          _OUT << "}" << std::endl;
9665 }
9666 static void print_VkVertexInputBindingDescription(const VkVertexInputBindingDescription * obj, const std::string& s, bool commaNeeded=true) {
9667      PRINT_SPACE
9668      _OUT << "{" << std::endl;
9669      INDENT(4);
9670
9671      print_uint32_t(obj->binding, "binding", 1);
9672
9673      print_uint32_t(obj->stride, "stride", 1);
9674
9675      print_VkVertexInputRate(obj->inputRate, "inputRate", 0);
9676
9677      INDENT(-4);
9678      PRINT_SPACE
9679      if (commaNeeded)
9680          _OUT << "}," << std::endl;
9681      else
9682          _OUT << "}" << std::endl;
9683 }
9684
9685 static void print_VkVertexInputAttributeDescription(VkVertexInputAttributeDescription obj, const std::string& s, bool commaNeeded=true) {
9686      PRINT_SPACE
9687      _OUT << "{" << std::endl;
9688      INDENT(4);
9689
9690      print_uint32_t(obj.location, "location", 1);
9691
9692      print_uint32_t(obj.binding, "binding", 1);
9693
9694      print_VkFormat(obj.format, "format", 1);
9695
9696      print_uint32_t(obj.offset, "offset", 0);
9697
9698      INDENT(-4);
9699      PRINT_SPACE
9700      if (commaNeeded)
9701          _OUT << "}," << std::endl;
9702      else
9703          _OUT << "}" << std::endl;
9704 }
9705 static void print_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription * obj, const std::string& s, bool commaNeeded=true) {
9706      PRINT_SPACE
9707      _OUT << "{" << std::endl;
9708      INDENT(4);
9709
9710      print_uint32_t(obj->location, "location", 1);
9711
9712      print_uint32_t(obj->binding, "binding", 1);
9713
9714      print_VkFormat(obj->format, "format", 1);
9715
9716      print_uint32_t(obj->offset, "offset", 0);
9717
9718      INDENT(-4);
9719      PRINT_SPACE
9720      if (commaNeeded)
9721          _OUT << "}," << std::endl;
9722      else
9723          _OUT << "}" << std::endl;
9724 }
9725
9726 static void print_VkPipelineVertexInputStateCreateInfo(VkPipelineVertexInputStateCreateInfo obj, const std::string& s, bool commaNeeded=true) {
9727      PRINT_SPACE
9728      _OUT << "{" << std::endl;
9729      INDENT(4);
9730
9731      print_VkStructureType(obj.sType, "sType", 1);
9732
9733       if (obj.pNext) {
9734          dumpPNextChain(obj.pNext);
9735       } else {
9736          PRINT_SPACE
9737          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9738      }
9739
9740      print_VkPipelineVertexInputStateCreateFlags(obj.flags, "flags", 1);
9741
9742      print_uint32_t(obj.vertexBindingDescriptionCount, "vertexBindingDescriptionCount", 1);
9743
9744      PRINT_SPACE
9745      _OUT << "\"pVertexBindingDescriptions\": " << std::endl;
9746      if (obj.pVertexBindingDescriptions) {
9747          PRINT_SPACE
9748          _OUT << "[" << std::endl;
9749          for (unsigned int i = 0; i < obj.vertexBindingDescriptionCount; i++) {
9750            if (i+1 == obj.vertexBindingDescriptionCount)
9751                print_VkVertexInputBindingDescription(obj.pVertexBindingDescriptions[i], "pVertexBindingDescriptions", 0);
9752            else
9753                print_VkVertexInputBindingDescription(obj.pVertexBindingDescriptions[i], "pVertexBindingDescriptions", 1);
9754          }
9755          PRINT_SPACE
9756          _OUT << "]," << std::endl;
9757     }
9758      else
9759      {
9760          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
9761      }
9762
9763      print_uint32_t(obj.vertexAttributeDescriptionCount, "vertexAttributeDescriptionCount", 1);
9764
9765      PRINT_SPACE
9766      _OUT << "\"pVertexAttributeDescriptions\": " << std::endl;
9767      if (obj.pVertexAttributeDescriptions) {
9768          PRINT_SPACE
9769          _OUT << "[" << std::endl;
9770          for (unsigned int i = 0; i < obj.vertexAttributeDescriptionCount; i++) {
9771            if (i+1 == obj.vertexAttributeDescriptionCount)
9772                print_VkVertexInputAttributeDescription(obj.pVertexAttributeDescriptions[i], "pVertexAttributeDescriptions", 0);
9773            else
9774                print_VkVertexInputAttributeDescription(obj.pVertexAttributeDescriptions[i], "pVertexAttributeDescriptions", 1);
9775          }
9776          PRINT_SPACE
9777          _OUT << "]" << std::endl;
9778     }
9779      else
9780      {
9781          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
9782      }
9783
9784      INDENT(-4);
9785      PRINT_SPACE
9786      if (commaNeeded)
9787          _OUT << "}," << std::endl;
9788      else
9789          _OUT << "}" << std::endl;
9790 }
9791 static void print_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
9792      PRINT_SPACE
9793      _OUT << "{" << std::endl;
9794      INDENT(4);
9795
9796      print_VkStructureType(obj->sType, "sType", 1);
9797
9798       if (obj->pNext) {
9799          dumpPNextChain(obj->pNext);
9800       } else {
9801          PRINT_SPACE
9802          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9803      }
9804
9805      print_VkPipelineVertexInputStateCreateFlags(obj->flags, "flags", 1);
9806
9807      print_uint32_t(obj->vertexBindingDescriptionCount, "vertexBindingDescriptionCount", 1);
9808
9809      PRINT_SPACE
9810      _OUT << "\"pVertexBindingDescriptions\": " << std::endl;
9811      if (obj->pVertexBindingDescriptions) {
9812          PRINT_SPACE
9813          _OUT << "[" << std::endl;
9814          for (unsigned int i = 0; i < obj->vertexBindingDescriptionCount; i++) {
9815            if (i+1 == obj->vertexBindingDescriptionCount)
9816                print_VkVertexInputBindingDescription(obj->pVertexBindingDescriptions[i], "pVertexBindingDescriptions", 0);
9817            else
9818                print_VkVertexInputBindingDescription(obj->pVertexBindingDescriptions[i], "pVertexBindingDescriptions", 1);
9819          }
9820          PRINT_SPACE
9821          _OUT << "]," << std::endl;
9822     }
9823      else
9824      {
9825          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
9826      }
9827
9828      print_uint32_t(obj->vertexAttributeDescriptionCount, "vertexAttributeDescriptionCount", 1);
9829
9830      PRINT_SPACE
9831      _OUT << "\"pVertexAttributeDescriptions\": " << std::endl;
9832      if (obj->pVertexAttributeDescriptions) {
9833          PRINT_SPACE
9834          _OUT << "[" << std::endl;
9835          for (unsigned int i = 0; i < obj->vertexAttributeDescriptionCount; i++) {
9836            if (i+1 == obj->vertexAttributeDescriptionCount)
9837                print_VkVertexInputAttributeDescription(obj->pVertexAttributeDescriptions[i], "pVertexAttributeDescriptions", 0);
9838            else
9839                print_VkVertexInputAttributeDescription(obj->pVertexAttributeDescriptions[i], "pVertexAttributeDescriptions", 1);
9840          }
9841          PRINT_SPACE
9842          _OUT << "]" << std::endl;
9843     }
9844      else
9845      {
9846          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
9847      }
9848
9849      INDENT(-4);
9850      PRINT_SPACE
9851      if (commaNeeded)
9852          _OUT << "}," << std::endl;
9853      else
9854          _OUT << "}" << std::endl;
9855 }
9856
9857 static void print_VkPipelineInputAssemblyStateCreateInfo(VkPipelineInputAssemblyStateCreateInfo obj, const std::string& s, bool commaNeeded=true) {
9858      PRINT_SPACE
9859      _OUT << "{" << std::endl;
9860      INDENT(4);
9861
9862      print_VkStructureType(obj.sType, "sType", 1);
9863
9864       if (obj.pNext) {
9865          dumpPNextChain(obj.pNext);
9866       } else {
9867          PRINT_SPACE
9868          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9869      }
9870
9871      print_VkPipelineInputAssemblyStateCreateFlags(obj.flags, "flags", 1);
9872
9873      print_VkPrimitiveTopology(obj.topology, "topology", 1);
9874
9875      print_VkBool32(obj.primitiveRestartEnable, "primitiveRestartEnable", 0);
9876
9877      INDENT(-4);
9878      PRINT_SPACE
9879      if (commaNeeded)
9880          _OUT << "}," << std::endl;
9881      else
9882          _OUT << "}" << std::endl;
9883 }
9884 static void print_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
9885      PRINT_SPACE
9886      _OUT << "{" << std::endl;
9887      INDENT(4);
9888
9889      print_VkStructureType(obj->sType, "sType", 1);
9890
9891       if (obj->pNext) {
9892          dumpPNextChain(obj->pNext);
9893       } else {
9894          PRINT_SPACE
9895          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9896      }
9897
9898      print_VkPipelineInputAssemblyStateCreateFlags(obj->flags, "flags", 1);
9899
9900      print_VkPrimitiveTopology(obj->topology, "topology", 1);
9901
9902      print_VkBool32(obj->primitiveRestartEnable, "primitiveRestartEnable", 0);
9903
9904      INDENT(-4);
9905      PRINT_SPACE
9906      if (commaNeeded)
9907          _OUT << "}," << std::endl;
9908      else
9909          _OUT << "}" << std::endl;
9910 }
9911
9912 static void print_VkPipelineTessellationStateCreateInfo(VkPipelineTessellationStateCreateInfo obj, const std::string& s, bool commaNeeded=true) {
9913      PRINT_SPACE
9914      _OUT << "{" << std::endl;
9915      INDENT(4);
9916
9917      print_VkStructureType(obj.sType, "sType", 1);
9918
9919       if (obj.pNext) {
9920          dumpPNextChain(obj.pNext);
9921       } else {
9922          PRINT_SPACE
9923          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9924      }
9925
9926      print_VkPipelineTessellationStateCreateFlags(obj.flags, "flags", 1);
9927
9928      print_uint32_t(obj.patchControlPoints, "patchControlPoints", 0);
9929
9930      INDENT(-4);
9931      PRINT_SPACE
9932      if (commaNeeded)
9933          _OUT << "}," << std::endl;
9934      else
9935          _OUT << "}" << std::endl;
9936 }
9937 static void print_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
9938      PRINT_SPACE
9939      _OUT << "{" << std::endl;
9940      INDENT(4);
9941
9942      print_VkStructureType(obj->sType, "sType", 1);
9943
9944       if (obj->pNext) {
9945          dumpPNextChain(obj->pNext);
9946       } else {
9947          PRINT_SPACE
9948          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
9949      }
9950
9951      print_VkPipelineTessellationStateCreateFlags(obj->flags, "flags", 1);
9952
9953      print_uint32_t(obj->patchControlPoints, "patchControlPoints", 0);
9954
9955      INDENT(-4);
9956      PRINT_SPACE
9957      if (commaNeeded)
9958          _OUT << "}," << std::endl;
9959      else
9960          _OUT << "}" << std::endl;
9961 }
9962
9963 static void print_VkViewport(VkViewport obj, const std::string& s, bool commaNeeded=true) {
9964      PRINT_SPACE
9965      _OUT << "{" << std::endl;
9966      INDENT(4);
9967
9968      print_float(obj.x, "x", 1);
9969
9970      print_float(obj.y, "y", 1);
9971
9972      print_float(obj.width, "width", 1);
9973
9974      print_float(obj.height, "height", 1);
9975
9976      print_float(obj.minDepth, "minDepth", 1);
9977
9978      print_float(obj.maxDepth, "maxDepth", 0);
9979
9980      INDENT(-4);
9981      PRINT_SPACE
9982      if (commaNeeded)
9983          _OUT << "}," << std::endl;
9984      else
9985          _OUT << "}" << std::endl;
9986 }
9987 static void print_VkViewport(const VkViewport * obj, const std::string& s, bool commaNeeded=true) {
9988      PRINT_SPACE
9989      _OUT << "{" << std::endl;
9990      INDENT(4);
9991
9992      print_float(obj->x, "x", 1);
9993
9994      print_float(obj->y, "y", 1);
9995
9996      print_float(obj->width, "width", 1);
9997
9998      print_float(obj->height, "height", 1);
9999
10000      print_float(obj->minDepth, "minDepth", 1);
10001
10002      print_float(obj->maxDepth, "maxDepth", 0);
10003
10004      INDENT(-4);
10005      PRINT_SPACE
10006      if (commaNeeded)
10007          _OUT << "}," << std::endl;
10008      else
10009          _OUT << "}" << std::endl;
10010 }
10011
10012 static void print_VkPipelineViewportStateCreateInfo(VkPipelineViewportStateCreateInfo obj, const std::string& s, bool commaNeeded=true) {
10013      PRINT_SPACE
10014      _OUT << "{" << std::endl;
10015      INDENT(4);
10016
10017      print_VkStructureType(obj.sType, "sType", 1);
10018
10019       if (obj.pNext) {
10020          dumpPNextChain(obj.pNext);
10021       } else {
10022          PRINT_SPACE
10023          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10024      }
10025
10026      print_VkPipelineViewportStateCreateFlags(obj.flags, "flags", 1);
10027
10028      print_uint32_t(obj.viewportCount, "viewportCount", 1);
10029
10030      PRINT_SPACE
10031      _OUT << "\"pViewports\": " << std::endl;
10032      if (obj.pViewports) {
10033          PRINT_SPACE
10034          _OUT << "[" << std::endl;
10035          for (unsigned int i = 0; i < obj.viewportCount; i++) {
10036            if (i+1 == obj.viewportCount)
10037                print_VkViewport(obj.pViewports[i], "pViewports", 0);
10038            else
10039                print_VkViewport(obj.pViewports[i], "pViewports", 1);
10040          }
10041          PRINT_SPACE
10042          _OUT << "]," << std::endl;
10043     }
10044      else
10045      {
10046          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10047      }
10048
10049      print_uint32_t(obj.scissorCount, "scissorCount", 1);
10050
10051      PRINT_SPACE
10052      _OUT << "\"pScissors\": " << std::endl;
10053      if (obj.pScissors) {
10054          PRINT_SPACE
10055          _OUT << "[" << std::endl;
10056          for (unsigned int i = 0; i < obj.scissorCount; i++) {
10057            if (i+1 == obj.scissorCount)
10058                print_VkRect2D(obj.pScissors[i], "pScissors", 0);
10059            else
10060                print_VkRect2D(obj.pScissors[i], "pScissors", 1);
10061          }
10062          PRINT_SPACE
10063          _OUT << "]" << std::endl;
10064     }
10065      else
10066      {
10067          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
10068      }
10069
10070      INDENT(-4);
10071      PRINT_SPACE
10072      if (commaNeeded)
10073          _OUT << "}," << std::endl;
10074      else
10075          _OUT << "}" << std::endl;
10076 }
10077 static void print_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
10078      PRINT_SPACE
10079      _OUT << "{" << std::endl;
10080      INDENT(4);
10081
10082      print_VkStructureType(obj->sType, "sType", 1);
10083
10084       if (obj->pNext) {
10085          dumpPNextChain(obj->pNext);
10086       } else {
10087          PRINT_SPACE
10088          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10089      }
10090
10091      print_VkPipelineViewportStateCreateFlags(obj->flags, "flags", 1);
10092
10093      print_uint32_t(obj->viewportCount, "viewportCount", 1);
10094
10095      PRINT_SPACE
10096      _OUT << "\"pViewports\": " << std::endl;
10097      if (obj->pViewports) {
10098          PRINT_SPACE
10099          _OUT << "[" << std::endl;
10100          for (unsigned int i = 0; i < obj->viewportCount; i++) {
10101            if (i+1 == obj->viewportCount)
10102                print_VkViewport(obj->pViewports[i], "pViewports", 0);
10103            else
10104                print_VkViewport(obj->pViewports[i], "pViewports", 1);
10105          }
10106          PRINT_SPACE
10107          _OUT << "]," << std::endl;
10108     }
10109      else
10110      {
10111          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10112      }
10113
10114      print_uint32_t(obj->scissorCount, "scissorCount", 1);
10115
10116      PRINT_SPACE
10117      _OUT << "\"pScissors\": " << std::endl;
10118      if (obj->pScissors) {
10119          PRINT_SPACE
10120          _OUT << "[" << std::endl;
10121          for (unsigned int i = 0; i < obj->scissorCount; i++) {
10122            if (i+1 == obj->scissorCount)
10123                print_VkRect2D(obj->pScissors[i], "pScissors", 0);
10124            else
10125                print_VkRect2D(obj->pScissors[i], "pScissors", 1);
10126          }
10127          PRINT_SPACE
10128          _OUT << "]" << std::endl;
10129     }
10130      else
10131      {
10132          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
10133      }
10134
10135      INDENT(-4);
10136      PRINT_SPACE
10137      if (commaNeeded)
10138          _OUT << "}," << std::endl;
10139      else
10140          _OUT << "}" << std::endl;
10141 }
10142
10143 static void print_VkPipelineRasterizationStateCreateInfo(VkPipelineRasterizationStateCreateInfo obj, const std::string& s, bool commaNeeded=true) {
10144      PRINT_SPACE
10145      _OUT << "{" << std::endl;
10146      INDENT(4);
10147
10148      print_VkStructureType(obj.sType, "sType", 1);
10149
10150       if (obj.pNext) {
10151          dumpPNextChain(obj.pNext);
10152       } else {
10153          PRINT_SPACE
10154          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10155      }
10156
10157      print_VkPipelineRasterizationStateCreateFlags(obj.flags, "flags", 1);
10158
10159      print_VkBool32(obj.depthClampEnable, "depthClampEnable", 1);
10160
10161      print_VkBool32(obj.rasterizerDiscardEnable, "rasterizerDiscardEnable", 1);
10162
10163      print_VkPolygonMode(obj.polygonMode, "polygonMode", 1);
10164
10165      print_VkCullModeFlags(obj.cullMode, "cullMode", 1);
10166
10167      print_VkFrontFace(obj.frontFace, "frontFace", 1);
10168
10169      print_VkBool32(obj.depthBiasEnable, "depthBiasEnable", 1);
10170
10171      print_float(obj.depthBiasConstantFactor, "depthBiasConstantFactor", 1);
10172
10173      print_float(obj.depthBiasClamp, "depthBiasClamp", 1);
10174
10175      print_float(obj.depthBiasSlopeFactor, "depthBiasSlopeFactor", 1);
10176
10177      print_float(obj.lineWidth, "lineWidth", 0);
10178
10179      INDENT(-4);
10180      PRINT_SPACE
10181      if (commaNeeded)
10182          _OUT << "}," << std::endl;
10183      else
10184          _OUT << "}" << std::endl;
10185 }
10186 static void print_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
10187      PRINT_SPACE
10188      _OUT << "{" << std::endl;
10189      INDENT(4);
10190
10191      print_VkStructureType(obj->sType, "sType", 1);
10192
10193       if (obj->pNext) {
10194          dumpPNextChain(obj->pNext);
10195       } else {
10196          PRINT_SPACE
10197          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10198      }
10199
10200      print_VkPipelineRasterizationStateCreateFlags(obj->flags, "flags", 1);
10201
10202      print_VkBool32(obj->depthClampEnable, "depthClampEnable", 1);
10203
10204      print_VkBool32(obj->rasterizerDiscardEnable, "rasterizerDiscardEnable", 1);
10205
10206      print_VkPolygonMode(obj->polygonMode, "polygonMode", 1);
10207
10208      print_VkCullModeFlags(obj->cullMode, "cullMode", 1);
10209
10210      print_VkFrontFace(obj->frontFace, "frontFace", 1);
10211
10212      print_VkBool32(obj->depthBiasEnable, "depthBiasEnable", 1);
10213
10214      print_float(obj->depthBiasConstantFactor, "depthBiasConstantFactor", 1);
10215
10216      print_float(obj->depthBiasClamp, "depthBiasClamp", 1);
10217
10218      print_float(obj->depthBiasSlopeFactor, "depthBiasSlopeFactor", 1);
10219
10220      print_float(obj->lineWidth, "lineWidth", 0);
10221
10222      INDENT(-4);
10223      PRINT_SPACE
10224      if (commaNeeded)
10225          _OUT << "}," << std::endl;
10226      else
10227          _OUT << "}" << std::endl;
10228 }
10229
10230 static void print_VkPipelineMultisampleStateCreateInfo(VkPipelineMultisampleStateCreateInfo obj, const std::string& s, bool commaNeeded=true) {
10231      PRINT_SPACE
10232      _OUT << "{" << std::endl;
10233      INDENT(4);
10234
10235      print_VkStructureType(obj.sType, "sType", 1);
10236
10237       if (obj.pNext) {
10238          dumpPNextChain(obj.pNext);
10239       } else {
10240          PRINT_SPACE
10241          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10242      }
10243
10244      print_VkPipelineMultisampleStateCreateFlags(obj.flags, "flags", 1);
10245
10246      print_VkSampleCountFlagBits(obj.rasterizationSamples, "rasterizationSamples", 1);
10247
10248      print_VkBool32(obj.sampleShadingEnable, "sampleShadingEnable", 1);
10249
10250      print_float(obj.minSampleShading, "minSampleShading", 1);
10251
10252      deUint32 sampleMaskSize = ((obj.rasterizationSamples + 31) / 32);
10253      PRINT_SPACE
10254      _OUT << "\"pSampleMask\":" << std::endl;
10255      PRINT_SPACE
10256      if (obj.pSampleMask) {
10257        _OUT << "[" << std::endl;
10258        for (unsigned int i = 0; i < sampleMaskSize; i++) {
10259            bool isCommaNeeded = (i+1) != sampleMaskSize;
10260            print_uint32_t(obj.pSampleMask[i], "", isCommaNeeded);
10261        }
10262        PRINT_SPACE
10263        _OUT << "]" << "," << std::endl;
10264      } else {
10265        _OUT << "\"NULL\"" << "," << std::endl;
10266      }
10267
10268      print_VkBool32(obj.alphaToCoverageEnable, "alphaToCoverageEnable", 1);
10269
10270      print_VkBool32(obj.alphaToOneEnable, "alphaToOneEnable", 0);
10271
10272      INDENT(-4);
10273      PRINT_SPACE
10274      if (commaNeeded)
10275          _OUT << "}," << std::endl;
10276      else
10277          _OUT << "}" << std::endl;
10278 }
10279 static void print_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
10280      PRINT_SPACE
10281      _OUT << "{" << std::endl;
10282      INDENT(4);
10283
10284      print_VkStructureType(obj->sType, "sType", 1);
10285
10286       if (obj->pNext) {
10287          dumpPNextChain(obj->pNext);
10288       } else {
10289          PRINT_SPACE
10290          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10291      }
10292
10293      print_VkPipelineMultisampleStateCreateFlags(obj->flags, "flags", 1);
10294
10295      print_VkSampleCountFlagBits(obj->rasterizationSamples, "rasterizationSamples", 1);
10296
10297      print_VkBool32(obj->sampleShadingEnable, "sampleShadingEnable", 1);
10298
10299      print_float(obj->minSampleShading, "minSampleShading", 1);
10300
10301      deUint32 sampleMaskSize = ((obj->rasterizationSamples + 31) / 32);
10302      PRINT_SPACE
10303      _OUT << "\"pSampleMask\":" << std::endl;
10304      PRINT_SPACE
10305      if (obj->pSampleMask) {
10306        _OUT << "[" << std::endl;
10307        for (unsigned int i = 0; i < sampleMaskSize; i++) {
10308            bool isCommaNeeded = (i+1) != sampleMaskSize;
10309            print_uint32_t(obj->pSampleMask[i], "", isCommaNeeded);
10310        }
10311        PRINT_SPACE
10312        _OUT << "]" << "," << std::endl;
10313      } else {
10314        _OUT << "\"NULL\"" << "," << std::endl;
10315      }
10316
10317      print_VkBool32(obj->alphaToCoverageEnable, "alphaToCoverageEnable", 1);
10318
10319      print_VkBool32(obj->alphaToOneEnable, "alphaToOneEnable", 0);
10320
10321      INDENT(-4);
10322      PRINT_SPACE
10323      if (commaNeeded)
10324          _OUT << "}," << std::endl;
10325      else
10326          _OUT << "}" << std::endl;
10327 }
10328
10329 static void print_VkStencilOpState(VkStencilOpState obj, const std::string& s, bool commaNeeded=true) {
10330      PRINT_SPACE
10331      _OUT << "{" << std::endl;
10332      INDENT(4);
10333
10334      print_VkStencilOp(obj.failOp, "failOp", 1);
10335
10336      print_VkStencilOp(obj.passOp, "passOp", 1);
10337
10338      print_VkStencilOp(obj.depthFailOp, "depthFailOp", 1);
10339
10340      print_VkCompareOp(obj.compareOp, "compareOp", 1);
10341
10342      print_uint32_t(obj.compareMask, "compareMask", 1);
10343
10344      print_uint32_t(obj.writeMask, "writeMask", 1);
10345
10346      print_uint32_t(obj.reference, "reference", 0);
10347
10348      INDENT(-4);
10349      PRINT_SPACE
10350      if (commaNeeded)
10351          _OUT << "}," << std::endl;
10352      else
10353          _OUT << "}" << std::endl;
10354 }
10355 static void print_VkStencilOpState(const VkStencilOpState * obj, const std::string& s, bool commaNeeded=true) {
10356      PRINT_SPACE
10357      _OUT << "{" << std::endl;
10358      INDENT(4);
10359
10360      print_VkStencilOp(obj->failOp, "failOp", 1);
10361
10362      print_VkStencilOp(obj->passOp, "passOp", 1);
10363
10364      print_VkStencilOp(obj->depthFailOp, "depthFailOp", 1);
10365
10366      print_VkCompareOp(obj->compareOp, "compareOp", 1);
10367
10368      print_uint32_t(obj->compareMask, "compareMask", 1);
10369
10370      print_uint32_t(obj->writeMask, "writeMask", 1);
10371
10372      print_uint32_t(obj->reference, "reference", 0);
10373
10374      INDENT(-4);
10375      PRINT_SPACE
10376      if (commaNeeded)
10377          _OUT << "}," << std::endl;
10378      else
10379          _OUT << "}" << std::endl;
10380 }
10381
10382 static void print_VkPipelineDepthStencilStateCreateInfo(VkPipelineDepthStencilStateCreateInfo obj, const std::string& s, bool commaNeeded=true) {
10383      PRINT_SPACE
10384      _OUT << "{" << std::endl;
10385      INDENT(4);
10386
10387      print_VkStructureType(obj.sType, "sType", 1);
10388
10389       if (obj.pNext) {
10390          dumpPNextChain(obj.pNext);
10391       } else {
10392          PRINT_SPACE
10393          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10394      }
10395
10396      print_VkPipelineDepthStencilStateCreateFlags(obj.flags, "flags", 1);
10397
10398      print_VkBool32(obj.depthTestEnable, "depthTestEnable", 1);
10399
10400      print_VkBool32(obj.depthWriteEnable, "depthWriteEnable", 1);
10401
10402      print_VkCompareOp(obj.depthCompareOp, "depthCompareOp", 1);
10403
10404      print_VkBool32(obj.depthBoundsTestEnable, "depthBoundsTestEnable", 1);
10405
10406      print_VkBool32(obj.stencilTestEnable, "stencilTestEnable", 1);
10407
10408      PRINT_SPACE
10409      _OUT << "\"front\": " << std::endl;
10410      {
10411            print_VkStencilOpState(obj.front, "front", 1);
10412      }
10413
10414      PRINT_SPACE
10415      _OUT << "\"back\": " << std::endl;
10416      {
10417            print_VkStencilOpState(obj.back, "back", 1);
10418      }
10419
10420      print_float(obj.minDepthBounds, "minDepthBounds", 1);
10421
10422      print_float(obj.maxDepthBounds, "maxDepthBounds", 0);
10423
10424      INDENT(-4);
10425      PRINT_SPACE
10426      if (commaNeeded)
10427          _OUT << "}," << std::endl;
10428      else
10429          _OUT << "}" << std::endl;
10430 }
10431 static void print_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
10432      PRINT_SPACE
10433      _OUT << "{" << std::endl;
10434      INDENT(4);
10435
10436      print_VkStructureType(obj->sType, "sType", 1);
10437
10438       if (obj->pNext) {
10439          dumpPNextChain(obj->pNext);
10440       } else {
10441          PRINT_SPACE
10442          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10443      }
10444
10445      print_VkPipelineDepthStencilStateCreateFlags(obj->flags, "flags", 1);
10446
10447      print_VkBool32(obj->depthTestEnable, "depthTestEnable", 1);
10448
10449      print_VkBool32(obj->depthWriteEnable, "depthWriteEnable", 1);
10450
10451      print_VkCompareOp(obj->depthCompareOp, "depthCompareOp", 1);
10452
10453      print_VkBool32(obj->depthBoundsTestEnable, "depthBoundsTestEnable", 1);
10454
10455      print_VkBool32(obj->stencilTestEnable, "stencilTestEnable", 1);
10456
10457      PRINT_SPACE
10458      _OUT << "\"front\": " << std::endl;
10459      {
10460            print_VkStencilOpState(obj->front, "front", 1);
10461      }
10462
10463      PRINT_SPACE
10464      _OUT << "\"back\": " << std::endl;
10465      {
10466            print_VkStencilOpState(obj->back, "back", 1);
10467      }
10468
10469      print_float(obj->minDepthBounds, "minDepthBounds", 1);
10470
10471      print_float(obj->maxDepthBounds, "maxDepthBounds", 0);
10472
10473      INDENT(-4);
10474      PRINT_SPACE
10475      if (commaNeeded)
10476          _OUT << "}," << std::endl;
10477      else
10478          _OUT << "}" << std::endl;
10479 }
10480
10481 static void print_VkPipelineColorBlendAttachmentState(VkPipelineColorBlendAttachmentState obj, const std::string& s, bool commaNeeded=true) {
10482      PRINT_SPACE
10483      _OUT << "{" << std::endl;
10484      INDENT(4);
10485
10486      print_VkBool32(obj.blendEnable, "blendEnable", 1);
10487
10488      print_VkBlendFactor(obj.srcColorBlendFactor, "srcColorBlendFactor", 1);
10489
10490      print_VkBlendFactor(obj.dstColorBlendFactor, "dstColorBlendFactor", 1);
10491
10492      print_VkBlendOp(obj.colorBlendOp, "colorBlendOp", 1);
10493
10494      print_VkBlendFactor(obj.srcAlphaBlendFactor, "srcAlphaBlendFactor", 1);
10495
10496      print_VkBlendFactor(obj.dstAlphaBlendFactor, "dstAlphaBlendFactor", 1);
10497
10498      print_VkBlendOp(obj.alphaBlendOp, "alphaBlendOp", 1);
10499
10500      print_VkColorComponentFlags(obj.colorWriteMask, "colorWriteMask", 0);
10501
10502      INDENT(-4);
10503      PRINT_SPACE
10504      if (commaNeeded)
10505          _OUT << "}," << std::endl;
10506      else
10507          _OUT << "}" << std::endl;
10508 }
10509 static void print_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState * obj, const std::string& s, bool commaNeeded=true) {
10510      PRINT_SPACE
10511      _OUT << "{" << std::endl;
10512      INDENT(4);
10513
10514      print_VkBool32(obj->blendEnable, "blendEnable", 1);
10515
10516      print_VkBlendFactor(obj->srcColorBlendFactor, "srcColorBlendFactor", 1);
10517
10518      print_VkBlendFactor(obj->dstColorBlendFactor, "dstColorBlendFactor", 1);
10519
10520      print_VkBlendOp(obj->colorBlendOp, "colorBlendOp", 1);
10521
10522      print_VkBlendFactor(obj->srcAlphaBlendFactor, "srcAlphaBlendFactor", 1);
10523
10524      print_VkBlendFactor(obj->dstAlphaBlendFactor, "dstAlphaBlendFactor", 1);
10525
10526      print_VkBlendOp(obj->alphaBlendOp, "alphaBlendOp", 1);
10527
10528      print_VkColorComponentFlags(obj->colorWriteMask, "colorWriteMask", 0);
10529
10530      INDENT(-4);
10531      PRINT_SPACE
10532      if (commaNeeded)
10533          _OUT << "}," << std::endl;
10534      else
10535          _OUT << "}" << std::endl;
10536 }
10537
10538 static void print_VkPipelineColorBlendStateCreateInfo(VkPipelineColorBlendStateCreateInfo obj, const std::string& s, bool commaNeeded=true) {
10539      PRINT_SPACE
10540      _OUT << "{" << std::endl;
10541      INDENT(4);
10542
10543      print_VkStructureType(obj.sType, "sType", 1);
10544
10545       if (obj.pNext) {
10546          dumpPNextChain(obj.pNext);
10547       } else {
10548          PRINT_SPACE
10549          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10550      }
10551
10552      print_VkPipelineColorBlendStateCreateFlags(obj.flags, "flags", 1);
10553
10554      print_VkBool32(obj.logicOpEnable, "logicOpEnable", 1);
10555
10556      print_VkLogicOp(obj.logicOp, "logicOp", 1);
10557
10558      print_uint32_t(obj.attachmentCount, "attachmentCount", 1);
10559
10560      PRINT_SPACE
10561      _OUT << "\"pAttachments\": " << std::endl;
10562      if (obj.pAttachments) {
10563          PRINT_SPACE
10564          _OUT << "[" << std::endl;
10565          for (unsigned int i = 0; i < obj.attachmentCount; i++) {
10566            if (i+1 == obj.attachmentCount)
10567                print_VkPipelineColorBlendAttachmentState(obj.pAttachments[i], "pAttachments", 0);
10568            else
10569                print_VkPipelineColorBlendAttachmentState(obj.pAttachments[i], "pAttachments", 1);
10570          }
10571          PRINT_SPACE
10572          _OUT << "]," << std::endl;
10573     }
10574      else
10575      {
10576          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10577      }
10578
10579      PRINT_SPACE
10580      _OUT << "\"blendConstants\":" << std::endl;
10581      PRINT_SPACE
10582      if (obj.blendConstants) {
10583        _OUT << "[" << std::endl;
10584        for (unsigned int i = 0; i < 4; i++) {
10585            bool isCommaNeeded = (i+1) != 4;
10586            print_float(obj.blendConstants[i], "", isCommaNeeded);
10587        }
10588        PRINT_SPACE
10589        _OUT << "]" << "" << std::endl;
10590      } else {
10591        _OUT << "\"NULL\"" << "" << std::endl;
10592      }
10593
10594      INDENT(-4);
10595      PRINT_SPACE
10596      if (commaNeeded)
10597          _OUT << "}," << std::endl;
10598      else
10599          _OUT << "}" << std::endl;
10600 }
10601 static void print_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
10602      PRINT_SPACE
10603      _OUT << "{" << std::endl;
10604      INDENT(4);
10605
10606      print_VkStructureType(obj->sType, "sType", 1);
10607
10608       if (obj->pNext) {
10609          dumpPNextChain(obj->pNext);
10610       } else {
10611          PRINT_SPACE
10612          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10613      }
10614
10615      print_VkPipelineColorBlendStateCreateFlags(obj->flags, "flags", 1);
10616
10617      print_VkBool32(obj->logicOpEnable, "logicOpEnable", 1);
10618
10619      print_VkLogicOp(obj->logicOp, "logicOp", 1);
10620
10621      print_uint32_t(obj->attachmentCount, "attachmentCount", 1);
10622
10623      PRINT_SPACE
10624      _OUT << "\"pAttachments\": " << std::endl;
10625      if (obj->pAttachments) {
10626          PRINT_SPACE
10627          _OUT << "[" << std::endl;
10628          for (unsigned int i = 0; i < obj->attachmentCount; i++) {
10629            if (i+1 == obj->attachmentCount)
10630                print_VkPipelineColorBlendAttachmentState(obj->pAttachments[i], "pAttachments", 0);
10631            else
10632                print_VkPipelineColorBlendAttachmentState(obj->pAttachments[i], "pAttachments", 1);
10633          }
10634          PRINT_SPACE
10635          _OUT << "]," << std::endl;
10636     }
10637      else
10638      {
10639          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10640      }
10641
10642      PRINT_SPACE
10643      _OUT << "\"blendConstants\":" << std::endl;
10644      PRINT_SPACE
10645      if (obj->blendConstants) {
10646        _OUT << "[" << std::endl;
10647        for (unsigned int i = 0; i < 4; i++) {
10648            bool isCommaNeeded = (i+1) != 4;
10649            print_float(obj->blendConstants[i], "", isCommaNeeded);
10650        }
10651        PRINT_SPACE
10652        _OUT << "]" << "" << std::endl;
10653      } else {
10654        _OUT << "\"NULL\"" << "" << std::endl;
10655      }
10656
10657      INDENT(-4);
10658      PRINT_SPACE
10659      if (commaNeeded)
10660          _OUT << "}," << std::endl;
10661      else
10662          _OUT << "}" << std::endl;
10663 }
10664
10665 static void print_VkPipelineDynamicStateCreateInfo(VkPipelineDynamicStateCreateInfo obj, const std::string& s, bool commaNeeded=true) {
10666      PRINT_SPACE
10667      _OUT << "{" << std::endl;
10668      INDENT(4);
10669
10670      print_VkStructureType(obj.sType, "sType", 1);
10671
10672       if (obj.pNext) {
10673          dumpPNextChain(obj.pNext);
10674       } else {
10675          PRINT_SPACE
10676          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10677      }
10678
10679      print_VkPipelineDynamicStateCreateFlags(obj.flags, "flags", 1);
10680
10681      print_uint32_t(obj.dynamicStateCount, "dynamicStateCount", 1);
10682
10683      PRINT_SPACE
10684      _OUT << "\"pDynamicStates\":" << std::endl;
10685      PRINT_SPACE
10686      if (obj.pDynamicStates) {
10687        _OUT << "[" << std::endl;
10688        for (unsigned int i = 0; i < obj.dynamicStateCount; i++) {
10689            bool isCommaNeeded = (i+1) != obj.dynamicStateCount;
10690            print_VkDynamicState(obj.pDynamicStates[i], "", isCommaNeeded);
10691        }
10692        PRINT_SPACE
10693        _OUT << "]" << "" << std::endl;
10694      } else {
10695        _OUT << "\"NULL\"" << "" << std::endl;
10696      }
10697
10698      INDENT(-4);
10699      PRINT_SPACE
10700      if (commaNeeded)
10701          _OUT << "}," << std::endl;
10702      else
10703          _OUT << "}" << std::endl;
10704 }
10705 static void print_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
10706      PRINT_SPACE
10707      _OUT << "{" << std::endl;
10708      INDENT(4);
10709
10710      print_VkStructureType(obj->sType, "sType", 1);
10711
10712       if (obj->pNext) {
10713          dumpPNextChain(obj->pNext);
10714       } else {
10715          PRINT_SPACE
10716          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10717      }
10718
10719      print_VkPipelineDynamicStateCreateFlags(obj->flags, "flags", 1);
10720
10721      print_uint32_t(obj->dynamicStateCount, "dynamicStateCount", 1);
10722
10723      PRINT_SPACE
10724      _OUT << "\"pDynamicStates\":" << std::endl;
10725      PRINT_SPACE
10726      if (obj->pDynamicStates) {
10727        _OUT << "[" << std::endl;
10728        for (unsigned int i = 0; i < obj->dynamicStateCount; i++) {
10729            bool isCommaNeeded = (i+1) != obj->dynamicStateCount;
10730            print_VkDynamicState(obj->pDynamicStates[i], "", isCommaNeeded);
10731        }
10732        PRINT_SPACE
10733        _OUT << "]" << "" << std::endl;
10734      } else {
10735        _OUT << "\"NULL\"" << "" << std::endl;
10736      }
10737
10738      INDENT(-4);
10739      PRINT_SPACE
10740      if (commaNeeded)
10741          _OUT << "}," << std::endl;
10742      else
10743          _OUT << "}" << std::endl;
10744 }
10745
10746 static void print_VkGraphicsPipelineCreateInfo(VkGraphicsPipelineCreateInfo obj, const std::string& s, bool commaNeeded=true) {
10747      PRINT_SPACE
10748      _OUT << "{" << std::endl;
10749      INDENT(4);
10750
10751      print_VkStructureType(obj.sType, "sType", 1);
10752
10753       if (obj.pNext) {
10754          dumpPNextChain(obj.pNext);
10755       } else {
10756          PRINT_SPACE
10757          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10758      }
10759
10760      print_VkPipelineCreateFlags(obj.flags, "flags", 1);
10761
10762      print_uint32_t(obj.stageCount, "stageCount", 1);
10763
10764      PRINT_SPACE
10765      _OUT << "\"pStages\": " << std::endl;
10766      if (obj.pStages) {
10767          PRINT_SPACE
10768          _OUT << "[" << std::endl;
10769          for (unsigned int i = 0; i < obj.stageCount; i++) {
10770            if (i+1 == obj.stageCount)
10771                print_VkPipelineShaderStageCreateInfo(obj.pStages[i], "pStages", 0);
10772            else
10773                print_VkPipelineShaderStageCreateInfo(obj.pStages[i], "pStages", 1);
10774          }
10775          PRINT_SPACE
10776          _OUT << "]," << std::endl;
10777     }
10778      else
10779      {
10780          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10781      }
10782
10783      PRINT_SPACE
10784      _OUT << "\"pVertexInputState\": " << std::endl;
10785      if (obj.pVertexInputState) {
10786            print_VkPipelineVertexInputStateCreateInfo(obj.pVertexInputState, "pVertexInputState", 1);
10787      }
10788      else
10789      {
10790          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10791      }
10792
10793      PRINT_SPACE
10794      _OUT << "\"pInputAssemblyState\": " << std::endl;
10795      if (obj.pInputAssemblyState) {
10796            print_VkPipelineInputAssemblyStateCreateInfo(obj.pInputAssemblyState, "pInputAssemblyState", 1);
10797      }
10798      else
10799      {
10800          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10801      }
10802
10803      PRINT_SPACE
10804      _OUT << "\"pTessellationState\": " << std::endl;
10805      if (obj.pTessellationState) {
10806            print_VkPipelineTessellationStateCreateInfo(obj.pTessellationState, "pTessellationState", 1);
10807      }
10808      else
10809      {
10810          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10811      }
10812
10813      PRINT_SPACE
10814      _OUT << "\"pViewportState\": " << std::endl;
10815      if (obj.pViewportState) {
10816            print_VkPipelineViewportStateCreateInfo(obj.pViewportState, "pViewportState", 1);
10817      }
10818      else
10819      {
10820          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10821      }
10822
10823      PRINT_SPACE
10824      _OUT << "\"pRasterizationState\": " << std::endl;
10825      if (obj.pRasterizationState) {
10826            print_VkPipelineRasterizationStateCreateInfo(obj.pRasterizationState, "pRasterizationState", 1);
10827      }
10828      else
10829      {
10830          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10831      }
10832
10833      PRINT_SPACE
10834      _OUT << "\"pMultisampleState\": " << std::endl;
10835      if (obj.pMultisampleState) {
10836            print_VkPipelineMultisampleStateCreateInfo(obj.pMultisampleState, "pMultisampleState", 1);
10837      }
10838      else
10839      {
10840          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10841      }
10842
10843      PRINT_SPACE
10844      _OUT << "\"pDepthStencilState\": " << std::endl;
10845      if (obj.pDepthStencilState) {
10846            print_VkPipelineDepthStencilStateCreateInfo(obj.pDepthStencilState, "pDepthStencilState", 1);
10847      }
10848      else
10849      {
10850          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10851      }
10852
10853      PRINT_SPACE
10854      _OUT << "\"pColorBlendState\": " << std::endl;
10855      if (obj.pColorBlendState) {
10856            print_VkPipelineColorBlendStateCreateInfo(obj.pColorBlendState, "pColorBlendState", 1);
10857      }
10858      else
10859      {
10860          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10861      }
10862
10863      PRINT_SPACE
10864      _OUT << "\"pDynamicState\": " << std::endl;
10865      if (obj.pDynamicState) {
10866            print_VkPipelineDynamicStateCreateInfo(obj.pDynamicState, "pDynamicState", 1);
10867      }
10868      else
10869      {
10870          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10871      }
10872
10873      // CTS : required value
10874      PRINT_SPACE    _OUT << "\"" << "layout" << "\"" << " : " << obj.layout.getInternal() << "," << std::endl;
10875
10876      // CTS : required value
10877      PRINT_SPACE    _OUT << "\"" << "renderPass" << "\"" << " : " << obj.renderPass.getInternal() << "," << std::endl;
10878
10879      print_uint32_t(obj.subpass, "subpass", 1);
10880
10881      // CTS : required value
10882      PRINT_SPACE    _OUT << "\"" << "basePipelineHandle" << "\"" << " : " << "\"" << "\"," << std::endl;
10883
10884      print_int32_t(obj.basePipelineIndex, "basePipelineIndex", 0);
10885
10886      INDENT(-4);
10887      PRINT_SPACE
10888      if (commaNeeded)
10889          _OUT << "}," << std::endl;
10890      else
10891          _OUT << "}" << std::endl;
10892 }
10893 static void print_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
10894      PRINT_SPACE
10895      _OUT << "{" << std::endl;
10896      INDENT(4);
10897
10898      print_VkStructureType(obj->sType, "sType", 1);
10899
10900       if (obj->pNext) {
10901          dumpPNextChain(obj->pNext);
10902       } else {
10903          PRINT_SPACE
10904          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
10905      }
10906
10907      print_VkPipelineCreateFlags(obj->flags, "flags", 1);
10908
10909      print_uint32_t(obj->stageCount, "stageCount", 1);
10910
10911      PRINT_SPACE
10912      _OUT << "\"pStages\": " << std::endl;
10913      if (obj->pStages) {
10914          PRINT_SPACE
10915          _OUT << "[" << std::endl;
10916          for (unsigned int i = 0; i < obj->stageCount; i++) {
10917            if (i+1 == obj->stageCount)
10918                print_VkPipelineShaderStageCreateInfo(obj->pStages[i], "pStages", 0);
10919            else
10920                print_VkPipelineShaderStageCreateInfo(obj->pStages[i], "pStages", 1);
10921          }
10922          PRINT_SPACE
10923          _OUT << "]," << std::endl;
10924     }
10925      else
10926      {
10927          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10928      }
10929
10930      PRINT_SPACE
10931      _OUT << "\"pVertexInputState\": " << std::endl;
10932      if (obj->pVertexInputState) {
10933            print_VkPipelineVertexInputStateCreateInfo(obj->pVertexInputState, "pVertexInputState", 1);
10934      }
10935      else
10936      {
10937          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10938      }
10939
10940      PRINT_SPACE
10941      _OUT << "\"pInputAssemblyState\": " << std::endl;
10942      if (obj->pInputAssemblyState) {
10943            print_VkPipelineInputAssemblyStateCreateInfo(obj->pInputAssemblyState, "pInputAssemblyState", 1);
10944      }
10945      else
10946      {
10947          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10948      }
10949
10950      PRINT_SPACE
10951      _OUT << "\"pTessellationState\": " << std::endl;
10952      if (obj->pTessellationState) {
10953            print_VkPipelineTessellationStateCreateInfo(obj->pTessellationState, "pTessellationState", 1);
10954      }
10955      else
10956      {
10957          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10958      }
10959
10960      PRINT_SPACE
10961      _OUT << "\"pViewportState\": " << std::endl;
10962      if (obj->pViewportState) {
10963            print_VkPipelineViewportStateCreateInfo(obj->pViewportState, "pViewportState", 1);
10964      }
10965      else
10966      {
10967          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10968      }
10969
10970      PRINT_SPACE
10971      _OUT << "\"pRasterizationState\": " << std::endl;
10972      if (obj->pRasterizationState) {
10973            print_VkPipelineRasterizationStateCreateInfo(obj->pRasterizationState, "pRasterizationState", 1);
10974      }
10975      else
10976      {
10977          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10978      }
10979
10980      PRINT_SPACE
10981      _OUT << "\"pMultisampleState\": " << std::endl;
10982      if (obj->pMultisampleState) {
10983            print_VkPipelineMultisampleStateCreateInfo(obj->pMultisampleState, "pMultisampleState", 1);
10984      }
10985      else
10986      {
10987          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10988      }
10989
10990      PRINT_SPACE
10991      _OUT << "\"pDepthStencilState\": " << std::endl;
10992      if (obj->pDepthStencilState) {
10993            print_VkPipelineDepthStencilStateCreateInfo(obj->pDepthStencilState, "pDepthStencilState", 1);
10994      }
10995      else
10996      {
10997          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
10998      }
10999
11000      PRINT_SPACE
11001      _OUT << "\"pColorBlendState\": " << std::endl;
11002      if (obj->pColorBlendState) {
11003            print_VkPipelineColorBlendStateCreateInfo(obj->pColorBlendState, "pColorBlendState", 1);
11004      }
11005      else
11006      {
11007          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
11008      }
11009
11010      PRINT_SPACE
11011      _OUT << "\"pDynamicState\": " << std::endl;
11012      if (obj->pDynamicState) {
11013            print_VkPipelineDynamicStateCreateInfo(obj->pDynamicState, "pDynamicState", 1);
11014      }
11015      else
11016      {
11017          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
11018      }
11019
11020      // CTS : required value
11021      PRINT_SPACE    _OUT << "\"" << "layout" << "\"" << " : " << obj->layout.getInternal() << "," << std::endl;
11022
11023      // CTS : required value
11024      PRINT_SPACE    _OUT << "\"" << "renderPass" << "\"" << " : " << obj->renderPass.getInternal() << "," << std::endl;
11025
11026      print_uint32_t(obj->subpass, "subpass", 1);
11027
11028      // CTS : required value
11029      PRINT_SPACE    _OUT << "\"" << "basePipelineHandle" << "\"" << " : " << "\"" << "\"," << std::endl;
11030
11031      print_int32_t(obj->basePipelineIndex, "basePipelineIndex", 0);
11032
11033      INDENT(-4);
11034      PRINT_SPACE
11035      if (commaNeeded)
11036          _OUT << "}," << std::endl;
11037      else
11038          _OUT << "}" << std::endl;
11039 }
11040
11041 static void print_VkPushConstantRange(VkPushConstantRange obj, const std::string& s, bool commaNeeded=true) {
11042      PRINT_SPACE
11043      _OUT << "{" << std::endl;
11044      INDENT(4);
11045
11046      print_VkShaderStageFlags(obj.stageFlags, "stageFlags", 1);
11047
11048      print_uint32_t(obj.offset, "offset", 1);
11049
11050      print_uint32_t(obj.size, "size", 0);
11051
11052      INDENT(-4);
11053      PRINT_SPACE
11054      if (commaNeeded)
11055          _OUT << "}," << std::endl;
11056      else
11057          _OUT << "}" << std::endl;
11058 }
11059 static void print_VkPushConstantRange(const VkPushConstantRange * obj, const std::string& s, bool commaNeeded=true) {
11060      PRINT_SPACE
11061      _OUT << "{" << std::endl;
11062      INDENT(4);
11063
11064      print_VkShaderStageFlags(obj->stageFlags, "stageFlags", 1);
11065
11066      print_uint32_t(obj->offset, "offset", 1);
11067
11068      print_uint32_t(obj->size, "size", 0);
11069
11070      INDENT(-4);
11071      PRINT_SPACE
11072      if (commaNeeded)
11073          _OUT << "}," << std::endl;
11074      else
11075          _OUT << "}" << std::endl;
11076 }
11077
11078 static void print_VkPipelineLayoutCreateInfo(VkPipelineLayoutCreateInfo obj, const std::string& s, bool commaNeeded=true) {
11079      PRINT_SPACE
11080      _OUT << "{" << std::endl;
11081      INDENT(4);
11082
11083      print_VkStructureType(obj.sType, "sType", 1);
11084
11085       if (obj.pNext) {
11086          dumpPNextChain(obj.pNext);
11087       } else {
11088          PRINT_SPACE
11089          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11090      }
11091
11092      print_VkPipelineLayoutCreateFlags(obj.flags, "flags", 1);
11093
11094      print_uint32_t(obj.setLayoutCount, "setLayoutCount", 1);
11095
11096      PRINT_SPACE
11097      _OUT << "\"pSetLayouts\":" << std::endl;
11098      PRINT_SPACE
11099      if (obj.pSetLayouts) {
11100        _OUT << "[" << std::endl;
11101        for (unsigned int i = 0; i < obj.setLayoutCount; i++) {
11102            bool isCommaNeeded = (i+1) != obj.setLayoutCount;
11103            if (isCommaNeeded)
11104            {
11105                PRINT_SPACE
11106                _OUT << obj.pSetLayouts[i].getInternal() << "," << std::endl;
11107            }
11108            else
11109            {
11110                PRINT_SPACE
11111                _OUT << obj.pSetLayouts[i].getInternal() << std::endl;
11112            }
11113        }
11114        PRINT_SPACE
11115        _OUT << "]" << "," << std::endl;
11116      } else {
11117        _OUT << "\"NULL\"" << "," << std::endl;
11118      }
11119
11120      print_uint32_t(obj.pushConstantRangeCount, "pushConstantRangeCount", 1);
11121
11122      PRINT_SPACE
11123      _OUT << "\"pPushConstantRanges\": " << std::endl;
11124      if (obj.pPushConstantRanges) {
11125          PRINT_SPACE
11126          _OUT << "[" << std::endl;
11127          for (unsigned int i = 0; i < obj.pushConstantRangeCount; i++) {
11128            if (i+1 == obj.pushConstantRangeCount)
11129                print_VkPushConstantRange(obj.pPushConstantRanges[i], "pPushConstantRanges", 0);
11130            else
11131                print_VkPushConstantRange(obj.pPushConstantRanges[i], "pPushConstantRanges", 1);
11132          }
11133          PRINT_SPACE
11134          _OUT << "]" << std::endl;
11135     }
11136      else
11137      {
11138          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
11139      }
11140
11141      INDENT(-4);
11142      PRINT_SPACE
11143      if (commaNeeded)
11144          _OUT << "}," << std::endl;
11145      else
11146          _OUT << "}" << std::endl;
11147 }
11148 static void print_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
11149      PRINT_SPACE
11150      _OUT << "{" << std::endl;
11151      INDENT(4);
11152
11153      print_VkStructureType(obj->sType, "sType", 1);
11154
11155       if (obj->pNext) {
11156          dumpPNextChain(obj->pNext);
11157       } else {
11158          PRINT_SPACE
11159          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11160      }
11161
11162      print_VkPipelineLayoutCreateFlags(obj->flags, "flags", 1);
11163
11164      print_uint32_t(obj->setLayoutCount, "setLayoutCount", 1);
11165
11166      PRINT_SPACE
11167      _OUT << "\"pSetLayouts\":" << std::endl;
11168      PRINT_SPACE
11169      if (obj->pSetLayouts) {
11170        _OUT << "[" << std::endl;
11171        for (unsigned int i = 0; i < obj->setLayoutCount; i++) {
11172            bool isCommaNeeded = (i+1) != obj->setLayoutCount;
11173            if (isCommaNeeded)
11174            {
11175                PRINT_SPACE
11176                _OUT << obj->pSetLayouts[i].getInternal() << "," << std::endl;
11177            }
11178            else
11179            {
11180                PRINT_SPACE
11181                _OUT << obj->pSetLayouts[i].getInternal() << std::endl;
11182            }
11183        }
11184        PRINT_SPACE
11185        _OUT << "]" << "," << std::endl;
11186      } else {
11187        _OUT << "\"NULL\"" << "," << std::endl;
11188      }
11189
11190      print_uint32_t(obj->pushConstantRangeCount, "pushConstantRangeCount", 1);
11191
11192      PRINT_SPACE
11193      _OUT << "\"pPushConstantRanges\": " << std::endl;
11194      if (obj->pPushConstantRanges) {
11195          PRINT_SPACE
11196          _OUT << "[" << std::endl;
11197          for (unsigned int i = 0; i < obj->pushConstantRangeCount; i++) {
11198            if (i+1 == obj->pushConstantRangeCount)
11199                print_VkPushConstantRange(obj->pPushConstantRanges[i], "pPushConstantRanges", 0);
11200            else
11201                print_VkPushConstantRange(obj->pPushConstantRanges[i], "pPushConstantRanges", 1);
11202          }
11203          PRINT_SPACE
11204          _OUT << "]" << std::endl;
11205     }
11206      else
11207      {
11208          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
11209      }
11210
11211      INDENT(-4);
11212      PRINT_SPACE
11213      if (commaNeeded)
11214          _OUT << "}," << std::endl;
11215      else
11216          _OUT << "}" << std::endl;
11217 }
11218
11219 static void print_VkSamplerCreateInfo(VkSamplerCreateInfo obj, const std::string& s, bool commaNeeded=true) {
11220      PRINT_SPACE
11221      _OUT << "{" << std::endl;
11222      INDENT(4);
11223
11224      print_VkStructureType(obj.sType, "sType", 1);
11225
11226       if (obj.pNext) {
11227          dumpPNextChain(obj.pNext);
11228       } else {
11229          PRINT_SPACE
11230          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11231      }
11232
11233      print_VkSamplerCreateFlags(obj.flags, "flags", 1);
11234
11235      print_VkFilter(obj.magFilter, "magFilter", 1);
11236
11237      print_VkFilter(obj.minFilter, "minFilter", 1);
11238
11239      print_VkSamplerMipmapMode(obj.mipmapMode, "mipmapMode", 1);
11240
11241      print_VkSamplerAddressMode(obj.addressModeU, "addressModeU", 1);
11242
11243      print_VkSamplerAddressMode(obj.addressModeV, "addressModeV", 1);
11244
11245      print_VkSamplerAddressMode(obj.addressModeW, "addressModeW", 1);
11246
11247      print_float(obj.mipLodBias, "mipLodBias", 1);
11248
11249      print_VkBool32(obj.anisotropyEnable, "anisotropyEnable", 1);
11250
11251      print_float(obj.maxAnisotropy, "maxAnisotropy", 1);
11252
11253      print_VkBool32(obj.compareEnable, "compareEnable", 1);
11254
11255      print_VkCompareOp(obj.compareOp, "compareOp", 1);
11256
11257      print_float(obj.minLod, "minLod", 1);
11258
11259      print_float(obj.maxLod, "maxLod", 1);
11260
11261      print_VkBorderColor(obj.borderColor, "borderColor", 1);
11262
11263      print_VkBool32(obj.unnormalizedCoordinates, "unnormalizedCoordinates", 0);
11264
11265      INDENT(-4);
11266      PRINT_SPACE
11267      if (commaNeeded)
11268          _OUT << "}," << std::endl;
11269      else
11270          _OUT << "}" << std::endl;
11271 }
11272 static void print_VkSamplerCreateInfo(const VkSamplerCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
11273      PRINT_SPACE
11274      _OUT << "{" << std::endl;
11275      INDENT(4);
11276
11277      print_VkStructureType(obj->sType, "sType", 1);
11278
11279       if (obj->pNext) {
11280          dumpPNextChain(obj->pNext);
11281       } else {
11282          PRINT_SPACE
11283          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11284      }
11285
11286      print_VkSamplerCreateFlags(obj->flags, "flags", 1);
11287
11288      print_VkFilter(obj->magFilter, "magFilter", 1);
11289
11290      print_VkFilter(obj->minFilter, "minFilter", 1);
11291
11292      print_VkSamplerMipmapMode(obj->mipmapMode, "mipmapMode", 1);
11293
11294      print_VkSamplerAddressMode(obj->addressModeU, "addressModeU", 1);
11295
11296      print_VkSamplerAddressMode(obj->addressModeV, "addressModeV", 1);
11297
11298      print_VkSamplerAddressMode(obj->addressModeW, "addressModeW", 1);
11299
11300      print_float(obj->mipLodBias, "mipLodBias", 1);
11301
11302      print_VkBool32(obj->anisotropyEnable, "anisotropyEnable", 1);
11303
11304      print_float(obj->maxAnisotropy, "maxAnisotropy", 1);
11305
11306      print_VkBool32(obj->compareEnable, "compareEnable", 1);
11307
11308      print_VkCompareOp(obj->compareOp, "compareOp", 1);
11309
11310      print_float(obj->minLod, "minLod", 1);
11311
11312      print_float(obj->maxLod, "maxLod", 1);
11313
11314      print_VkBorderColor(obj->borderColor, "borderColor", 1);
11315
11316      print_VkBool32(obj->unnormalizedCoordinates, "unnormalizedCoordinates", 0);
11317
11318      INDENT(-4);
11319      PRINT_SPACE
11320      if (commaNeeded)
11321          _OUT << "}," << std::endl;
11322      else
11323          _OUT << "}" << std::endl;
11324 }
11325
11326 static void print_VkCopyDescriptorSet(VkCopyDescriptorSet obj, const std::string& s, bool commaNeeded=true) {
11327      PRINT_SPACE
11328      _OUT << "{" << std::endl;
11329      INDENT(4);
11330
11331      print_VkStructureType(obj.sType, "sType", 1);
11332
11333       if (obj.pNext) {
11334          dumpPNextChain(obj.pNext);
11335       } else {
11336          PRINT_SPACE
11337          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11338      }
11339
11340      // CTS : required value
11341      PRINT_SPACE    _OUT << "\"" << "srcSet" << "\"" << " : " << "\"" << "\"," << std::endl;
11342
11343      print_uint32_t(obj.srcBinding, "srcBinding", 1);
11344
11345      print_uint32_t(obj.srcArrayElement, "srcArrayElement", 1);
11346
11347      // CTS : required value
11348      PRINT_SPACE    _OUT << "\"" << "dstSet" << "\"" << " : " << "\"" << "\"," << std::endl;
11349
11350      print_uint32_t(obj.dstBinding, "dstBinding", 1);
11351
11352      print_uint32_t(obj.dstArrayElement, "dstArrayElement", 1);
11353
11354      print_uint32_t(obj.descriptorCount, "descriptorCount", 0);
11355
11356      INDENT(-4);
11357      PRINT_SPACE
11358      if (commaNeeded)
11359          _OUT << "}," << std::endl;
11360      else
11361          _OUT << "}" << std::endl;
11362 }
11363 static void print_VkCopyDescriptorSet(const VkCopyDescriptorSet * obj, const std::string& s, bool commaNeeded=true) {
11364      PRINT_SPACE
11365      _OUT << "{" << std::endl;
11366      INDENT(4);
11367
11368      print_VkStructureType(obj->sType, "sType", 1);
11369
11370       if (obj->pNext) {
11371          dumpPNextChain(obj->pNext);
11372       } else {
11373          PRINT_SPACE
11374          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11375      }
11376
11377      // CTS : required value
11378      PRINT_SPACE    _OUT << "\"" << "srcSet" << "\"" << " : " << "\"" << "\"," << std::endl;
11379
11380      print_uint32_t(obj->srcBinding, "srcBinding", 1);
11381
11382      print_uint32_t(obj->srcArrayElement, "srcArrayElement", 1);
11383
11384      // CTS : required value
11385      PRINT_SPACE    _OUT << "\"" << "dstSet" << "\"" << " : " << "\"" << "\"," << std::endl;
11386
11387      print_uint32_t(obj->dstBinding, "dstBinding", 1);
11388
11389      print_uint32_t(obj->dstArrayElement, "dstArrayElement", 1);
11390
11391      print_uint32_t(obj->descriptorCount, "descriptorCount", 0);
11392
11393      INDENT(-4);
11394      PRINT_SPACE
11395      if (commaNeeded)
11396          _OUT << "}," << std::endl;
11397      else
11398          _OUT << "}" << std::endl;
11399 }
11400
11401 static void print_VkDescriptorBufferInfo(VkDescriptorBufferInfo obj, const std::string& s, bool commaNeeded=true) {
11402      PRINT_SPACE
11403      _OUT << "{" << std::endl;
11404      INDENT(4);
11405
11406      // CTS : required value
11407      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl;
11408
11409      print_VkDeviceSize(obj.offset, "offset", 1);
11410
11411      print_VkDeviceSize(obj.range, "range", 0);
11412
11413      INDENT(-4);
11414      PRINT_SPACE
11415      if (commaNeeded)
11416          _OUT << "}," << std::endl;
11417      else
11418          _OUT << "}" << std::endl;
11419 }
11420 static void print_VkDescriptorBufferInfo(const VkDescriptorBufferInfo * obj, const std::string& s, bool commaNeeded=true) {
11421      PRINT_SPACE
11422      _OUT << "{" << std::endl;
11423      INDENT(4);
11424
11425      // CTS : required value
11426      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl;
11427
11428      print_VkDeviceSize(obj->offset, "offset", 1);
11429
11430      print_VkDeviceSize(obj->range, "range", 0);
11431
11432      INDENT(-4);
11433      PRINT_SPACE
11434      if (commaNeeded)
11435          _OUT << "}," << std::endl;
11436      else
11437          _OUT << "}" << std::endl;
11438 }
11439
11440 static void print_VkDescriptorImageInfo(VkDescriptorImageInfo obj, const std::string& s, bool commaNeeded=true) {
11441      PRINT_SPACE
11442      _OUT << "{" << std::endl;
11443      INDENT(4);
11444
11445      // CTS : required value
11446      PRINT_SPACE    _OUT << "\"" << "sampler" << "\"" << " : " << "\"" << "\"," << std::endl;
11447
11448      // CTS : required value
11449      PRINT_SPACE    _OUT << "\"" << "imageView" << "\"" << " : " << "\"" << "\"," << std::endl;
11450
11451      print_VkImageLayout(obj.imageLayout, "imageLayout", 0);
11452
11453      INDENT(-4);
11454      PRINT_SPACE
11455      if (commaNeeded)
11456          _OUT << "}," << std::endl;
11457      else
11458          _OUT << "}" << std::endl;
11459 }
11460 static void print_VkDescriptorImageInfo(const VkDescriptorImageInfo * obj, const std::string& s, bool commaNeeded=true) {
11461      PRINT_SPACE
11462      _OUT << "{" << std::endl;
11463      INDENT(4);
11464
11465      // CTS : required value
11466      PRINT_SPACE    _OUT << "\"" << "sampler" << "\"" << " : " << "\"" << "\"," << std::endl;
11467
11468      // CTS : required value
11469      PRINT_SPACE    _OUT << "\"" << "imageView" << "\"" << " : " << "\"" << "\"," << std::endl;
11470
11471      print_VkImageLayout(obj->imageLayout, "imageLayout", 0);
11472
11473      INDENT(-4);
11474      PRINT_SPACE
11475      if (commaNeeded)
11476          _OUT << "}," << std::endl;
11477      else
11478          _OUT << "}" << std::endl;
11479 }
11480
11481 static void print_VkDescriptorPoolSize(VkDescriptorPoolSize obj, const std::string& s, bool commaNeeded=true) {
11482      PRINT_SPACE
11483      _OUT << "{" << std::endl;
11484      INDENT(4);
11485
11486      print_VkDescriptorType(obj.type, "type", 1);
11487
11488      print_uint32_t(obj.descriptorCount, "descriptorCount", 0);
11489
11490      INDENT(-4);
11491      PRINT_SPACE
11492      if (commaNeeded)
11493          _OUT << "}," << std::endl;
11494      else
11495          _OUT << "}" << std::endl;
11496 }
11497 static void print_VkDescriptorPoolSize(const VkDescriptorPoolSize * obj, const std::string& s, bool commaNeeded=true) {
11498      PRINT_SPACE
11499      _OUT << "{" << std::endl;
11500      INDENT(4);
11501
11502      print_VkDescriptorType(obj->type, "type", 1);
11503
11504      print_uint32_t(obj->descriptorCount, "descriptorCount", 0);
11505
11506      INDENT(-4);
11507      PRINT_SPACE
11508      if (commaNeeded)
11509          _OUT << "}," << std::endl;
11510      else
11511          _OUT << "}" << std::endl;
11512 }
11513
11514 static void print_VkDescriptorPoolCreateInfo(VkDescriptorPoolCreateInfo obj, const std::string& s, bool commaNeeded=true) {
11515      PRINT_SPACE
11516      _OUT << "{" << std::endl;
11517      INDENT(4);
11518
11519      print_VkStructureType(obj.sType, "sType", 1);
11520
11521       if (obj.pNext) {
11522          dumpPNextChain(obj.pNext);
11523       } else {
11524          PRINT_SPACE
11525          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11526      }
11527
11528      print_VkDescriptorPoolCreateFlags(obj.flags, "flags", 1);
11529
11530      print_uint32_t(obj.maxSets, "maxSets", 1);
11531
11532      print_uint32_t(obj.poolSizeCount, "poolSizeCount", 1);
11533
11534      PRINT_SPACE
11535      _OUT << "\"pPoolSizes\": " << std::endl;
11536      if (obj.pPoolSizes) {
11537          PRINT_SPACE
11538          _OUT << "[" << std::endl;
11539          for (unsigned int i = 0; i < obj.poolSizeCount; i++) {
11540            if (i+1 == obj.poolSizeCount)
11541                print_VkDescriptorPoolSize(obj.pPoolSizes[i], "pPoolSizes", 0);
11542            else
11543                print_VkDescriptorPoolSize(obj.pPoolSizes[i], "pPoolSizes", 1);
11544          }
11545          PRINT_SPACE
11546          _OUT << "]" << std::endl;
11547     }
11548      else
11549      {
11550          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
11551      }
11552
11553      INDENT(-4);
11554      PRINT_SPACE
11555      if (commaNeeded)
11556          _OUT << "}," << std::endl;
11557      else
11558          _OUT << "}" << std::endl;
11559 }
11560 static void print_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
11561      PRINT_SPACE
11562      _OUT << "{" << std::endl;
11563      INDENT(4);
11564
11565      print_VkStructureType(obj->sType, "sType", 1);
11566
11567       if (obj->pNext) {
11568          dumpPNextChain(obj->pNext);
11569       } else {
11570          PRINT_SPACE
11571          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11572      }
11573
11574      print_VkDescriptorPoolCreateFlags(obj->flags, "flags", 1);
11575
11576      print_uint32_t(obj->maxSets, "maxSets", 1);
11577
11578      print_uint32_t(obj->poolSizeCount, "poolSizeCount", 1);
11579
11580      PRINT_SPACE
11581      _OUT << "\"pPoolSizes\": " << std::endl;
11582      if (obj->pPoolSizes) {
11583          PRINT_SPACE
11584          _OUT << "[" << std::endl;
11585          for (unsigned int i = 0; i < obj->poolSizeCount; i++) {
11586            if (i+1 == obj->poolSizeCount)
11587                print_VkDescriptorPoolSize(obj->pPoolSizes[i], "pPoolSizes", 0);
11588            else
11589                print_VkDescriptorPoolSize(obj->pPoolSizes[i], "pPoolSizes", 1);
11590          }
11591          PRINT_SPACE
11592          _OUT << "]" << std::endl;
11593     }
11594      else
11595      {
11596          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
11597      }
11598
11599      INDENT(-4);
11600      PRINT_SPACE
11601      if (commaNeeded)
11602          _OUT << "}," << std::endl;
11603      else
11604          _OUT << "}" << std::endl;
11605 }
11606
11607 static void print_VkDescriptorSetAllocateInfo(VkDescriptorSetAllocateInfo obj, const std::string& s, bool commaNeeded=true) {
11608      PRINT_SPACE
11609      _OUT << "{" << std::endl;
11610      INDENT(4);
11611
11612      print_VkStructureType(obj.sType, "sType", 1);
11613
11614       if (obj.pNext) {
11615          dumpPNextChain(obj.pNext);
11616       } else {
11617          PRINT_SPACE
11618          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11619      }
11620
11621      // CTS : required value
11622      PRINT_SPACE    _OUT << "\"" << "descriptorPool" << "\"" << " : " << "\"" << "\"," << std::endl;
11623
11624      print_uint32_t(obj.descriptorSetCount, "descriptorSetCount", 1);
11625
11626      PRINT_SPACE
11627      _OUT << "\"pSetLayouts\":" << std::endl;
11628      PRINT_SPACE
11629      if (obj.pSetLayouts) {
11630        _OUT << "[" << std::endl;
11631        for (unsigned int i = 0; i < obj.descriptorSetCount; i++) {
11632            std:: stringstream tmp;
11633            tmp << "pSetLayouts" << "_" << i;
11634            bool isCommaNeeded = (i+1) != obj.descriptorSetCount;
11635            print_VkDescriptorSetLayout(obj.pSetLayouts[i], tmp.str(), isCommaNeeded);
11636        }
11637        PRINT_SPACE
11638        _OUT << "]" << "" << std::endl;
11639      } else {
11640        _OUT << "\"NULL\"" << "" << std::endl;
11641      }
11642
11643      INDENT(-4);
11644      PRINT_SPACE
11645      if (commaNeeded)
11646          _OUT << "}," << std::endl;
11647      else
11648          _OUT << "}" << std::endl;
11649 }
11650 static void print_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo * obj, const std::string& s, bool commaNeeded=true) {
11651      PRINT_SPACE
11652      _OUT << "{" << std::endl;
11653      INDENT(4);
11654
11655      print_VkStructureType(obj->sType, "sType", 1);
11656
11657       if (obj->pNext) {
11658          dumpPNextChain(obj->pNext);
11659       } else {
11660          PRINT_SPACE
11661          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11662      }
11663
11664      // CTS : required value
11665      PRINT_SPACE    _OUT << "\"" << "descriptorPool" << "\"" << " : " << "\"" << "\"," << std::endl;
11666
11667      print_uint32_t(obj->descriptorSetCount, "descriptorSetCount", 1);
11668
11669      PRINT_SPACE
11670      _OUT << "\"pSetLayouts\":" << std::endl;
11671      PRINT_SPACE
11672      if (obj->pSetLayouts) {
11673        _OUT << "[" << std::endl;
11674        for (unsigned int i = 0; i < obj->descriptorSetCount; i++) {
11675            std:: stringstream tmp;
11676            tmp << "pSetLayouts" << "_" << i;
11677            bool isCommaNeeded = (i+1) != obj->descriptorSetCount;
11678            print_VkDescriptorSetLayout(obj->pSetLayouts[i], tmp.str(), isCommaNeeded);
11679        }
11680        PRINT_SPACE
11681        _OUT << "]" << "" << std::endl;
11682      } else {
11683        _OUT << "\"NULL\"" << "" << std::endl;
11684      }
11685
11686      INDENT(-4);
11687      PRINT_SPACE
11688      if (commaNeeded)
11689          _OUT << "}," << std::endl;
11690      else
11691          _OUT << "}" << std::endl;
11692 }
11693
11694 static void print_VkDescriptorSetLayoutBinding(VkDescriptorSetLayoutBinding obj, const std::string& s, bool commaNeeded=true) {
11695      PRINT_SPACE
11696      _OUT << "{" << std::endl;
11697      INDENT(4);
11698
11699      print_uint32_t(obj.binding, "binding", 1);
11700
11701      print_VkDescriptorType(obj.descriptorType, "descriptorType", 1);
11702
11703      print_uint32_t(obj.descriptorCount, "descriptorCount", 1);
11704
11705      print_VkShaderStageFlags(obj.stageFlags, "stageFlags", 1);
11706
11707      PRINT_SPACE
11708      _OUT << "\"pImmutableSamplers\":" << std::endl;
11709      PRINT_SPACE
11710      if (obj.pImmutableSamplers) {
11711        _OUT << "[" << std::endl;
11712        for (unsigned int i = 0; i < obj.descriptorCount; i++) {
11713            bool isCommaNeeded = (i+1) != obj.descriptorCount;
11714            if (isCommaNeeded)
11715            {
11716                PRINT_SPACE
11717                _OUT << obj.pImmutableSamplers[i].getInternal() << "," << std::endl;
11718            }
11719            else
11720            {
11721                PRINT_SPACE
11722                _OUT << obj.pImmutableSamplers[i].getInternal() << std::endl;
11723            }
11724        }
11725        PRINT_SPACE
11726        _OUT << "]" << "" << std::endl;
11727      } else {
11728        _OUT << "\"NULL\"" << "" << std::endl;
11729      }
11730
11731      INDENT(-4);
11732      PRINT_SPACE
11733      if (commaNeeded)
11734          _OUT << "}," << std::endl;
11735      else
11736          _OUT << "}" << std::endl;
11737 }
11738 static void print_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding * obj, const std::string& s, bool commaNeeded=true) {
11739      PRINT_SPACE
11740      _OUT << "{" << std::endl;
11741      INDENT(4);
11742
11743      print_uint32_t(obj->binding, "binding", 1);
11744
11745      print_VkDescriptorType(obj->descriptorType, "descriptorType", 1);
11746
11747      print_uint32_t(obj->descriptorCount, "descriptorCount", 1);
11748
11749      print_VkShaderStageFlags(obj->stageFlags, "stageFlags", 1);
11750
11751      PRINT_SPACE
11752      _OUT << "\"pImmutableSamplers\":" << std::endl;
11753      PRINT_SPACE
11754      if (obj->pImmutableSamplers) {
11755        _OUT << "[" << std::endl;
11756        for (unsigned int i = 0; i < obj->descriptorCount; i++) {
11757            bool isCommaNeeded = (i+1) != obj->descriptorCount;
11758            if (isCommaNeeded)
11759            {
11760                PRINT_SPACE
11761                _OUT << obj->pImmutableSamplers[i].getInternal() << "," << std::endl;
11762            }
11763            else
11764            {
11765                PRINT_SPACE
11766                _OUT << obj->pImmutableSamplers[i].getInternal() << std::endl;
11767            }
11768        }
11769        PRINT_SPACE
11770        _OUT << "]" << "" << std::endl;
11771      } else {
11772        _OUT << "\"NULL\"" << "" << std::endl;
11773      }
11774
11775      INDENT(-4);
11776      PRINT_SPACE
11777      if (commaNeeded)
11778          _OUT << "}," << std::endl;
11779      else
11780          _OUT << "}" << std::endl;
11781 }
11782
11783 static void print_VkDescriptorSetLayoutCreateInfo(VkDescriptorSetLayoutCreateInfo obj, const std::string& s, bool commaNeeded=true) {
11784      PRINT_SPACE
11785      _OUT << "{" << std::endl;
11786      INDENT(4);
11787
11788      print_VkStructureType(obj.sType, "sType", 1);
11789
11790       if (obj.pNext) {
11791          dumpPNextChain(obj.pNext);
11792       } else {
11793          PRINT_SPACE
11794          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11795      }
11796
11797      print_VkDescriptorSetLayoutCreateFlags(obj.flags, "flags", 1);
11798
11799      print_uint32_t(obj.bindingCount, "bindingCount", 1);
11800
11801      PRINT_SPACE
11802      _OUT << "\"pBindings\": " << std::endl;
11803      if (obj.pBindings) {
11804          PRINT_SPACE
11805          _OUT << "[" << std::endl;
11806          for (unsigned int i = 0; i < obj.bindingCount; i++) {
11807            if (i+1 == obj.bindingCount)
11808                print_VkDescriptorSetLayoutBinding(obj.pBindings[i], "pBindings", 0);
11809            else
11810                print_VkDescriptorSetLayoutBinding(obj.pBindings[i], "pBindings", 1);
11811          }
11812          PRINT_SPACE
11813          _OUT << "]" << std::endl;
11814     }
11815      else
11816      {
11817          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
11818      }
11819
11820      INDENT(-4);
11821      PRINT_SPACE
11822      if (commaNeeded)
11823          _OUT << "}," << std::endl;
11824      else
11825          _OUT << "}" << std::endl;
11826 }
11827 static void print_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
11828      PRINT_SPACE
11829      _OUT << "{" << std::endl;
11830      INDENT(4);
11831
11832      print_VkStructureType(obj->sType, "sType", 1);
11833
11834       if (obj->pNext) {
11835          dumpPNextChain(obj->pNext);
11836       } else {
11837          PRINT_SPACE
11838          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11839      }
11840
11841      print_VkDescriptorSetLayoutCreateFlags(obj->flags, "flags", 1);
11842
11843      print_uint32_t(obj->bindingCount, "bindingCount", 1);
11844
11845      PRINT_SPACE
11846      _OUT << "\"pBindings\": " << std::endl;
11847      if (obj->pBindings) {
11848          PRINT_SPACE
11849          _OUT << "[" << std::endl;
11850          for (unsigned int i = 0; i < obj->bindingCount; i++) {
11851            if (i+1 == obj->bindingCount)
11852                print_VkDescriptorSetLayoutBinding(obj->pBindings[i], "pBindings", 0);
11853            else
11854                print_VkDescriptorSetLayoutBinding(obj->pBindings[i], "pBindings", 1);
11855          }
11856          PRINT_SPACE
11857          _OUT << "]" << std::endl;
11858     }
11859      else
11860      {
11861          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
11862      }
11863
11864      INDENT(-4);
11865      PRINT_SPACE
11866      if (commaNeeded)
11867          _OUT << "}," << std::endl;
11868      else
11869          _OUT << "}" << std::endl;
11870 }
11871
11872 static void print_VkWriteDescriptorSet(VkWriteDescriptorSet obj, const std::string& s, bool commaNeeded=true) {
11873      PRINT_SPACE
11874      _OUT << "{" << std::endl;
11875      INDENT(4);
11876
11877      print_VkStructureType(obj.sType, "sType", 1);
11878
11879       if (obj.pNext) {
11880          dumpPNextChain(obj.pNext);
11881       } else {
11882          PRINT_SPACE
11883          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11884      }
11885
11886      // CTS : required value
11887      PRINT_SPACE    _OUT << "\"" << "dstSet" << "\"" << " : " << "\"" << "\"," << std::endl;
11888
11889      print_uint32_t(obj.dstBinding, "dstBinding", 1);
11890
11891      print_uint32_t(obj.dstArrayElement, "dstArrayElement", 1);
11892
11893      print_uint32_t(obj.descriptorCount, "descriptorCount", 1);
11894
11895      print_VkDescriptorType(obj.descriptorType, "descriptorType", 1);
11896
11897      PRINT_SPACE
11898      _OUT << "\"pImageInfo\": " << std::endl;
11899      if (obj.pImageInfo) {
11900          PRINT_SPACE
11901          _OUT << "[" << std::endl;
11902          for (unsigned int i = 0; i < obj.descriptorCount; i++) {
11903            if (i+1 == obj.descriptorCount)
11904                print_VkDescriptorImageInfo(obj.pImageInfo[i], "pImageInfo", 0);
11905            else
11906                print_VkDescriptorImageInfo(obj.pImageInfo[i], "pImageInfo", 1);
11907          }
11908          PRINT_SPACE
11909          _OUT << "]," << std::endl;
11910     }
11911      else
11912      {
11913          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
11914      }
11915
11916      PRINT_SPACE
11917      _OUT << "\"pBufferInfo\": " << std::endl;
11918      if (obj.pBufferInfo) {
11919          PRINT_SPACE
11920          _OUT << "[" << std::endl;
11921          for (unsigned int i = 0; i < obj.descriptorCount; i++) {
11922            if (i+1 == obj.descriptorCount)
11923                print_VkDescriptorBufferInfo(obj.pBufferInfo[i], "pBufferInfo", 0);
11924            else
11925                print_VkDescriptorBufferInfo(obj.pBufferInfo[i], "pBufferInfo", 1);
11926          }
11927          PRINT_SPACE
11928          _OUT << "]," << std::endl;
11929     }
11930      else
11931      {
11932          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
11933      }
11934
11935      PRINT_SPACE
11936      _OUT << "\"pTexelBufferView\":" << std::endl;
11937      PRINT_SPACE
11938      if (obj.pTexelBufferView) {
11939        _OUT << "[" << std::endl;
11940        for (unsigned int i = 0; i < obj.descriptorCount; i++) {
11941            std:: stringstream tmp;
11942            tmp << "pTexelBufferView" << "_" << i;
11943            bool isCommaNeeded = (i+1) != obj.descriptorCount;
11944            print_VkBufferView(obj.pTexelBufferView[i], tmp.str(), isCommaNeeded);
11945        }
11946        PRINT_SPACE
11947        _OUT << "]" << "" << std::endl;
11948      } else {
11949        _OUT << "\"NULL\"" << "" << std::endl;
11950      }
11951
11952      INDENT(-4);
11953      PRINT_SPACE
11954      if (commaNeeded)
11955          _OUT << "}," << std::endl;
11956      else
11957          _OUT << "}" << std::endl;
11958 }
11959 static void print_VkWriteDescriptorSet(const VkWriteDescriptorSet * obj, const std::string& s, bool commaNeeded=true) {
11960      PRINT_SPACE
11961      _OUT << "{" << std::endl;
11962      INDENT(4);
11963
11964      print_VkStructureType(obj->sType, "sType", 1);
11965
11966       if (obj->pNext) {
11967          dumpPNextChain(obj->pNext);
11968       } else {
11969          PRINT_SPACE
11970          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
11971      }
11972
11973      // CTS : required value
11974      PRINT_SPACE    _OUT << "\"" << "dstSet" << "\"" << " : " << "\"" << "\"," << std::endl;
11975
11976      print_uint32_t(obj->dstBinding, "dstBinding", 1);
11977
11978      print_uint32_t(obj->dstArrayElement, "dstArrayElement", 1);
11979
11980      print_uint32_t(obj->descriptorCount, "descriptorCount", 1);
11981
11982      print_VkDescriptorType(obj->descriptorType, "descriptorType", 1);
11983
11984      PRINT_SPACE
11985      _OUT << "\"pImageInfo\": " << std::endl;
11986      if (obj->pImageInfo) {
11987          PRINT_SPACE
11988          _OUT << "[" << std::endl;
11989          for (unsigned int i = 0; i < obj->descriptorCount; i++) {
11990            if (i+1 == obj->descriptorCount)
11991                print_VkDescriptorImageInfo(obj->pImageInfo[i], "pImageInfo", 0);
11992            else
11993                print_VkDescriptorImageInfo(obj->pImageInfo[i], "pImageInfo", 1);
11994          }
11995          PRINT_SPACE
11996          _OUT << "]," << std::endl;
11997     }
11998      else
11999      {
12000          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12001      }
12002
12003      PRINT_SPACE
12004      _OUT << "\"pBufferInfo\": " << std::endl;
12005      if (obj->pBufferInfo) {
12006          PRINT_SPACE
12007          _OUT << "[" << std::endl;
12008          for (unsigned int i = 0; i < obj->descriptorCount; i++) {
12009            if (i+1 == obj->descriptorCount)
12010                print_VkDescriptorBufferInfo(obj->pBufferInfo[i], "pBufferInfo", 0);
12011            else
12012                print_VkDescriptorBufferInfo(obj->pBufferInfo[i], "pBufferInfo", 1);
12013          }
12014          PRINT_SPACE
12015          _OUT << "]," << std::endl;
12016     }
12017      else
12018      {
12019          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12020      }
12021
12022      PRINT_SPACE
12023      _OUT << "\"pTexelBufferView\":" << std::endl;
12024      PRINT_SPACE
12025      if (obj->pTexelBufferView) {
12026        _OUT << "[" << std::endl;
12027        for (unsigned int i = 0; i < obj->descriptorCount; i++) {
12028            std:: stringstream tmp;
12029            tmp << "pTexelBufferView" << "_" << i;
12030            bool isCommaNeeded = (i+1) != obj->descriptorCount;
12031            print_VkBufferView(obj->pTexelBufferView[i], tmp.str(), isCommaNeeded);
12032        }
12033        PRINT_SPACE
12034        _OUT << "]" << "" << std::endl;
12035      } else {
12036        _OUT << "\"NULL\"" << "" << std::endl;
12037      }
12038
12039      INDENT(-4);
12040      PRINT_SPACE
12041      if (commaNeeded)
12042          _OUT << "}," << std::endl;
12043      else
12044          _OUT << "}" << std::endl;
12045 }
12046
12047 static void print_VkAttachmentDescription(VkAttachmentDescription obj, const std::string& s, bool commaNeeded=true) {
12048      PRINT_SPACE
12049      _OUT << "{" << std::endl;
12050      INDENT(4);
12051
12052      print_VkAttachmentDescriptionFlags(obj.flags, "flags", 1);
12053
12054      print_VkFormat(obj.format, "format", 1);
12055
12056      print_VkSampleCountFlagBits(obj.samples, "samples", 1);
12057
12058      print_VkAttachmentLoadOp(obj.loadOp, "loadOp", 1);
12059
12060      print_VkAttachmentStoreOp(obj.storeOp, "storeOp", 1);
12061
12062      print_VkAttachmentLoadOp(obj.stencilLoadOp, "stencilLoadOp", 1);
12063
12064      print_VkAttachmentStoreOp(obj.stencilStoreOp, "stencilStoreOp", 1);
12065
12066      print_VkImageLayout(obj.initialLayout, "initialLayout", 1);
12067
12068      print_VkImageLayout(obj.finalLayout, "finalLayout", 0);
12069
12070      INDENT(-4);
12071      PRINT_SPACE
12072      if (commaNeeded)
12073          _OUT << "}," << std::endl;
12074      else
12075          _OUT << "}" << std::endl;
12076 }
12077 static void print_VkAttachmentDescription(const VkAttachmentDescription * obj, const std::string& s, bool commaNeeded=true) {
12078      PRINT_SPACE
12079      _OUT << "{" << std::endl;
12080      INDENT(4);
12081
12082      print_VkAttachmentDescriptionFlags(obj->flags, "flags", 1);
12083
12084      print_VkFormat(obj->format, "format", 1);
12085
12086      print_VkSampleCountFlagBits(obj->samples, "samples", 1);
12087
12088      print_VkAttachmentLoadOp(obj->loadOp, "loadOp", 1);
12089
12090      print_VkAttachmentStoreOp(obj->storeOp, "storeOp", 1);
12091
12092      print_VkAttachmentLoadOp(obj->stencilLoadOp, "stencilLoadOp", 1);
12093
12094      print_VkAttachmentStoreOp(obj->stencilStoreOp, "stencilStoreOp", 1);
12095
12096      print_VkImageLayout(obj->initialLayout, "initialLayout", 1);
12097
12098      print_VkImageLayout(obj->finalLayout, "finalLayout", 0);
12099
12100      INDENT(-4);
12101      PRINT_SPACE
12102      if (commaNeeded)
12103          _OUT << "}," << std::endl;
12104      else
12105          _OUT << "}" << std::endl;
12106 }
12107
12108 static void print_VkAttachmentReference(VkAttachmentReference obj, const std::string& s, bool commaNeeded=true) {
12109      PRINT_SPACE
12110      _OUT << "{" << std::endl;
12111      INDENT(4);
12112
12113      print_uint32_t(obj.attachment, "attachment", 1);
12114
12115      print_VkImageLayout(obj.layout, "layout", 0);
12116
12117      INDENT(-4);
12118      PRINT_SPACE
12119      if (commaNeeded)
12120          _OUT << "}," << std::endl;
12121      else
12122          _OUT << "}" << std::endl;
12123 }
12124 static void print_VkAttachmentReference(const VkAttachmentReference * obj, const std::string& s, bool commaNeeded=true) {
12125      PRINT_SPACE
12126      _OUT << "{" << std::endl;
12127      INDENT(4);
12128
12129      print_uint32_t(obj->attachment, "attachment", 1);
12130
12131      print_VkImageLayout(obj->layout, "layout", 0);
12132
12133      INDENT(-4);
12134      PRINT_SPACE
12135      if (commaNeeded)
12136          _OUT << "}," << std::endl;
12137      else
12138          _OUT << "}" << std::endl;
12139 }
12140
12141 static void print_VkFramebufferCreateInfo(VkFramebufferCreateInfo obj, const std::string& s, bool commaNeeded=true) {
12142      PRINT_SPACE
12143      _OUT << "{" << std::endl;
12144      INDENT(4);
12145
12146      print_VkStructureType(obj.sType, "sType", 1);
12147
12148       if (obj.pNext) {
12149          dumpPNextChain(obj.pNext);
12150       } else {
12151          PRINT_SPACE
12152          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
12153      }
12154
12155      print_VkFramebufferCreateFlags(obj.flags, "flags", 1);
12156
12157      // CTS : required value
12158      PRINT_SPACE    _OUT << "\"" << "renderPass" << "\"" << " : " << obj.renderPass.getInternal() << "," << std::endl;
12159
12160      print_uint32_t(obj.attachmentCount, "attachmentCount", 1);
12161
12162      PRINT_SPACE
12163      _OUT << "\"pAttachments\":" << std::endl;
12164      PRINT_SPACE
12165      if (obj.pAttachments) {
12166        _OUT << "[" << std::endl;
12167        for (unsigned int i = 0; i < obj.attachmentCount; i++) {
12168            std:: stringstream tmp;
12169            tmp << "pAttachments" << "_" << i;
12170            bool isCommaNeeded = (i+1) != obj.attachmentCount;
12171            print_VkImageView(obj.pAttachments[i], tmp.str(), isCommaNeeded);
12172        }
12173        PRINT_SPACE
12174        _OUT << "]" << "," << std::endl;
12175      } else {
12176        _OUT << "\"NULL\"" << "," << std::endl;
12177      }
12178
12179      print_uint32_t(obj.width, "width", 1);
12180
12181      print_uint32_t(obj.height, "height", 1);
12182
12183      print_uint32_t(obj.layers, "layers", 0);
12184
12185      INDENT(-4);
12186      PRINT_SPACE
12187      if (commaNeeded)
12188          _OUT << "}," << std::endl;
12189      else
12190          _OUT << "}" << std::endl;
12191 }
12192 static void print_VkFramebufferCreateInfo(const VkFramebufferCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
12193      PRINT_SPACE
12194      _OUT << "{" << std::endl;
12195      INDENT(4);
12196
12197      print_VkStructureType(obj->sType, "sType", 1);
12198
12199       if (obj->pNext) {
12200          dumpPNextChain(obj->pNext);
12201       } else {
12202          PRINT_SPACE
12203          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
12204      }
12205
12206      print_VkFramebufferCreateFlags(obj->flags, "flags", 1);
12207
12208      // CTS : required value
12209      PRINT_SPACE    _OUT << "\"" << "renderPass" << "\"" << " : " << obj->renderPass.getInternal() << "," << std::endl;
12210
12211      print_uint32_t(obj->attachmentCount, "attachmentCount", 1);
12212
12213      PRINT_SPACE
12214      _OUT << "\"pAttachments\":" << std::endl;
12215      PRINT_SPACE
12216      if (obj->pAttachments) {
12217        _OUT << "[" << std::endl;
12218        for (unsigned int i = 0; i < obj->attachmentCount; i++) {
12219            std:: stringstream tmp;
12220            tmp << "pAttachments" << "_" << i;
12221            bool isCommaNeeded = (i+1) != obj->attachmentCount;
12222            print_VkImageView(obj->pAttachments[i], tmp.str(), isCommaNeeded);
12223        }
12224        PRINT_SPACE
12225        _OUT << "]" << "," << std::endl;
12226      } else {
12227        _OUT << "\"NULL\"" << "," << std::endl;
12228      }
12229
12230      print_uint32_t(obj->width, "width", 1);
12231
12232      print_uint32_t(obj->height, "height", 1);
12233
12234      print_uint32_t(obj->layers, "layers", 0);
12235
12236      INDENT(-4);
12237      PRINT_SPACE
12238      if (commaNeeded)
12239          _OUT << "}," << std::endl;
12240      else
12241          _OUT << "}" << std::endl;
12242 }
12243
12244 static void print_VkSubpassDescription(VkSubpassDescription obj, const std::string& s, bool commaNeeded=true) {
12245      PRINT_SPACE
12246      _OUT << "{" << std::endl;
12247      INDENT(4);
12248
12249      print_VkSubpassDescriptionFlags(obj.flags, "flags", 1);
12250
12251      print_VkPipelineBindPoint(obj.pipelineBindPoint, "pipelineBindPoint", 1);
12252
12253      print_uint32_t(obj.inputAttachmentCount, "inputAttachmentCount", 1);
12254
12255      PRINT_SPACE
12256      _OUT << "\"pInputAttachments\": " << std::endl;
12257      if (obj.pInputAttachments) {
12258          PRINT_SPACE
12259          _OUT << "[" << std::endl;
12260          for (unsigned int i = 0; i < obj.inputAttachmentCount; i++) {
12261            if (i+1 == obj.inputAttachmentCount)
12262                print_VkAttachmentReference(obj.pInputAttachments[i], "pInputAttachments", 0);
12263            else
12264                print_VkAttachmentReference(obj.pInputAttachments[i], "pInputAttachments", 1);
12265          }
12266          PRINT_SPACE
12267          _OUT << "]," << std::endl;
12268     }
12269      else
12270      {
12271          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12272      }
12273
12274      print_uint32_t(obj.colorAttachmentCount, "colorAttachmentCount", 1);
12275
12276      PRINT_SPACE
12277      _OUT << "\"pColorAttachments\": " << std::endl;
12278      if (obj.pColorAttachments) {
12279          PRINT_SPACE
12280          _OUT << "[" << std::endl;
12281          for (unsigned int i = 0; i < obj.colorAttachmentCount; i++) {
12282            if (i+1 == obj.colorAttachmentCount)
12283                print_VkAttachmentReference(obj.pColorAttachments[i], "pColorAttachments", 0);
12284            else
12285                print_VkAttachmentReference(obj.pColorAttachments[i], "pColorAttachments", 1);
12286          }
12287          PRINT_SPACE
12288          _OUT << "]," << std::endl;
12289     }
12290      else
12291      {
12292          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12293      }
12294
12295      PRINT_SPACE
12296      _OUT << "\"pResolveAttachments\": " << std::endl;
12297      if (obj.pResolveAttachments) {
12298          PRINT_SPACE
12299          _OUT << "[" << std::endl;
12300          for (unsigned int i = 0; i < obj.colorAttachmentCount; i++) {
12301            if (i+1 == obj.colorAttachmentCount)
12302                print_VkAttachmentReference(obj.pResolveAttachments[i], "pResolveAttachments", 0);
12303            else
12304                print_VkAttachmentReference(obj.pResolveAttachments[i], "pResolveAttachments", 1);
12305          }
12306          PRINT_SPACE
12307          _OUT << "]," << std::endl;
12308     }
12309      else
12310      {
12311          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12312      }
12313
12314      PRINT_SPACE
12315      _OUT << "\"pDepthStencilAttachment\": " << std::endl;
12316      if (obj.pDepthStencilAttachment) {
12317            print_VkAttachmentReference(obj.pDepthStencilAttachment, "pDepthStencilAttachment", 1);
12318      }
12319      else
12320      {
12321          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12322      }
12323
12324      print_uint32_t(obj.preserveAttachmentCount, "preserveAttachmentCount", 1);
12325
12326      PRINT_SPACE
12327      _OUT << "\"pPreserveAttachments\":" << std::endl;
12328      PRINT_SPACE
12329      if (obj.pPreserveAttachments) {
12330        _OUT << "[" << std::endl;
12331        for (unsigned int i = 0; i < obj.preserveAttachmentCount; i++) {
12332            bool isCommaNeeded = (i+1) != obj.preserveAttachmentCount;
12333            print_uint32_t(obj.pPreserveAttachments[i], "", isCommaNeeded);
12334        }
12335        PRINT_SPACE
12336        _OUT << "]" << "" << std::endl;
12337      } else {
12338        _OUT << "\"NULL\"" << "" << std::endl;
12339      }
12340
12341      INDENT(-4);
12342      PRINT_SPACE
12343      if (commaNeeded)
12344          _OUT << "}," << std::endl;
12345      else
12346          _OUT << "}" << std::endl;
12347 }
12348 static void print_VkSubpassDescription(const VkSubpassDescription * obj, const std::string& s, bool commaNeeded=true) {
12349      PRINT_SPACE
12350      _OUT << "{" << std::endl;
12351      INDENT(4);
12352
12353      print_VkSubpassDescriptionFlags(obj->flags, "flags", 1);
12354
12355      print_VkPipelineBindPoint(obj->pipelineBindPoint, "pipelineBindPoint", 1);
12356
12357      print_uint32_t(obj->inputAttachmentCount, "inputAttachmentCount", 1);
12358
12359      PRINT_SPACE
12360      _OUT << "\"pInputAttachments\": " << std::endl;
12361      if (obj->pInputAttachments) {
12362          PRINT_SPACE
12363          _OUT << "[" << std::endl;
12364          for (unsigned int i = 0; i < obj->inputAttachmentCount; i++) {
12365            if (i+1 == obj->inputAttachmentCount)
12366                print_VkAttachmentReference(obj->pInputAttachments[i], "pInputAttachments", 0);
12367            else
12368                print_VkAttachmentReference(obj->pInputAttachments[i], "pInputAttachments", 1);
12369          }
12370          PRINT_SPACE
12371          _OUT << "]," << std::endl;
12372     }
12373      else
12374      {
12375          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12376      }
12377
12378      print_uint32_t(obj->colorAttachmentCount, "colorAttachmentCount", 1);
12379
12380      PRINT_SPACE
12381      _OUT << "\"pColorAttachments\": " << std::endl;
12382      if (obj->pColorAttachments) {
12383          PRINT_SPACE
12384          _OUT << "[" << std::endl;
12385          for (unsigned int i = 0; i < obj->colorAttachmentCount; i++) {
12386            if (i+1 == obj->colorAttachmentCount)
12387                print_VkAttachmentReference(obj->pColorAttachments[i], "pColorAttachments", 0);
12388            else
12389                print_VkAttachmentReference(obj->pColorAttachments[i], "pColorAttachments", 1);
12390          }
12391          PRINT_SPACE
12392          _OUT << "]," << std::endl;
12393     }
12394      else
12395      {
12396          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12397      }
12398
12399      PRINT_SPACE
12400      _OUT << "\"pResolveAttachments\": " << std::endl;
12401      if (obj->pResolveAttachments) {
12402          PRINT_SPACE
12403          _OUT << "[" << std::endl;
12404          for (unsigned int i = 0; i < obj->colorAttachmentCount; i++) {
12405            if (i+1 == obj->colorAttachmentCount)
12406                print_VkAttachmentReference(obj->pResolveAttachments[i], "pResolveAttachments", 0);
12407            else
12408                print_VkAttachmentReference(obj->pResolveAttachments[i], "pResolveAttachments", 1);
12409          }
12410          PRINT_SPACE
12411          _OUT << "]," << std::endl;
12412     }
12413      else
12414      {
12415          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12416      }
12417
12418      PRINT_SPACE
12419      _OUT << "\"pDepthStencilAttachment\": " << std::endl;
12420      if (obj->pDepthStencilAttachment) {
12421            print_VkAttachmentReference(obj->pDepthStencilAttachment, "pDepthStencilAttachment", 1);
12422      }
12423      else
12424      {
12425          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12426      }
12427
12428      print_uint32_t(obj->preserveAttachmentCount, "preserveAttachmentCount", 1);
12429
12430      PRINT_SPACE
12431      _OUT << "\"pPreserveAttachments\":" << std::endl;
12432      PRINT_SPACE
12433      if (obj->pPreserveAttachments) {
12434        _OUT << "[" << std::endl;
12435        for (unsigned int i = 0; i < obj->preserveAttachmentCount; i++) {
12436            bool isCommaNeeded = (i+1) != obj->preserveAttachmentCount;
12437            print_uint32_t(obj->pPreserveAttachments[i], "", isCommaNeeded);
12438        }
12439        PRINT_SPACE
12440        _OUT << "]" << "" << std::endl;
12441      } else {
12442        _OUT << "\"NULL\"" << "" << std::endl;
12443      }
12444
12445      INDENT(-4);
12446      PRINT_SPACE
12447      if (commaNeeded)
12448          _OUT << "}," << std::endl;
12449      else
12450          _OUT << "}" << std::endl;
12451 }
12452
12453 static void print_VkSubpassDependency(VkSubpassDependency obj, const std::string& s, bool commaNeeded=true) {
12454      PRINT_SPACE
12455      _OUT << "{" << std::endl;
12456      INDENT(4);
12457
12458      print_uint32_t(obj.srcSubpass, "srcSubpass", 1);
12459
12460      print_uint32_t(obj.dstSubpass, "dstSubpass", 1);
12461
12462      print_VkPipelineStageFlags(obj.srcStageMask, "srcStageMask", 1);
12463
12464      print_VkPipelineStageFlags(obj.dstStageMask, "dstStageMask", 1);
12465
12466      print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1);
12467
12468      print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 1);
12469
12470      print_VkDependencyFlags(obj.dependencyFlags, "dependencyFlags", 0);
12471
12472      INDENT(-4);
12473      PRINT_SPACE
12474      if (commaNeeded)
12475          _OUT << "}," << std::endl;
12476      else
12477          _OUT << "}" << std::endl;
12478 }
12479 static void print_VkSubpassDependency(const VkSubpassDependency * obj, const std::string& s, bool commaNeeded=true) {
12480      PRINT_SPACE
12481      _OUT << "{" << std::endl;
12482      INDENT(4);
12483
12484      print_uint32_t(obj->srcSubpass, "srcSubpass", 1);
12485
12486      print_uint32_t(obj->dstSubpass, "dstSubpass", 1);
12487
12488      print_VkPipelineStageFlags(obj->srcStageMask, "srcStageMask", 1);
12489
12490      print_VkPipelineStageFlags(obj->dstStageMask, "dstStageMask", 1);
12491
12492      print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1);
12493
12494      print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 1);
12495
12496      print_VkDependencyFlags(obj->dependencyFlags, "dependencyFlags", 0);
12497
12498      INDENT(-4);
12499      PRINT_SPACE
12500      if (commaNeeded)
12501          _OUT << "}," << std::endl;
12502      else
12503          _OUT << "}" << std::endl;
12504 }
12505
12506 static void print_VkRenderPassCreateInfo(VkRenderPassCreateInfo obj, const std::string& s, bool commaNeeded=true) {
12507      PRINT_SPACE
12508      _OUT << "{" << std::endl;
12509      INDENT(4);
12510
12511      print_VkStructureType(obj.sType, "sType", 1);
12512
12513       if (obj.pNext) {
12514          dumpPNextChain(obj.pNext);
12515       } else {
12516          PRINT_SPACE
12517          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
12518      }
12519
12520      print_VkRenderPassCreateFlags(obj.flags, "flags", 1);
12521
12522      print_uint32_t(obj.attachmentCount, "attachmentCount", 1);
12523
12524      PRINT_SPACE
12525      _OUT << "\"pAttachments\": " << std::endl;
12526      if (obj.pAttachments) {
12527          PRINT_SPACE
12528          _OUT << "[" << std::endl;
12529          for (unsigned int i = 0; i < obj.attachmentCount; i++) {
12530            if (i+1 == obj.attachmentCount)
12531                print_VkAttachmentDescription(obj.pAttachments[i], "pAttachments", 0);
12532            else
12533                print_VkAttachmentDescription(obj.pAttachments[i], "pAttachments", 1);
12534          }
12535          PRINT_SPACE
12536          _OUT << "]," << std::endl;
12537     }
12538      else
12539      {
12540          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12541      }
12542
12543      print_uint32_t(obj.subpassCount, "subpassCount", 1);
12544
12545      PRINT_SPACE
12546      _OUT << "\"pSubpasses\": " << std::endl;
12547      if (obj.pSubpasses) {
12548          PRINT_SPACE
12549          _OUT << "[" << std::endl;
12550          for (unsigned int i = 0; i < obj.subpassCount; i++) {
12551            if (i+1 == obj.subpassCount)
12552                print_VkSubpassDescription(obj.pSubpasses[i], "pSubpasses", 0);
12553            else
12554                print_VkSubpassDescription(obj.pSubpasses[i], "pSubpasses", 1);
12555          }
12556          PRINT_SPACE
12557          _OUT << "]," << std::endl;
12558     }
12559      else
12560      {
12561          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12562      }
12563
12564      print_uint32_t(obj.dependencyCount, "dependencyCount", 1);
12565
12566      PRINT_SPACE
12567      _OUT << "\"pDependencies\": " << std::endl;
12568      if (obj.pDependencies) {
12569          PRINT_SPACE
12570          _OUT << "[" << std::endl;
12571          for (unsigned int i = 0; i < obj.dependencyCount; i++) {
12572            if (i+1 == obj.dependencyCount)
12573                print_VkSubpassDependency(obj.pDependencies[i], "pDependencies", 0);
12574            else
12575                print_VkSubpassDependency(obj.pDependencies[i], "pDependencies", 1);
12576          }
12577          PRINT_SPACE
12578          _OUT << "]" << std::endl;
12579     }
12580      else
12581      {
12582          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
12583      }
12584
12585      INDENT(-4);
12586      PRINT_SPACE
12587      if (commaNeeded)
12588          _OUT << "}," << std::endl;
12589      else
12590          _OUT << "}" << std::endl;
12591 }
12592 static void print_VkRenderPassCreateInfo(const VkRenderPassCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
12593      PRINT_SPACE
12594      _OUT << "{" << std::endl;
12595      INDENT(4);
12596
12597      print_VkStructureType(obj->sType, "sType", 1);
12598
12599       if (obj->pNext) {
12600          dumpPNextChain(obj->pNext);
12601       } else {
12602          PRINT_SPACE
12603          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
12604      }
12605
12606      print_VkRenderPassCreateFlags(obj->flags, "flags", 1);
12607
12608      print_uint32_t(obj->attachmentCount, "attachmentCount", 1);
12609
12610      PRINT_SPACE
12611      _OUT << "\"pAttachments\": " << std::endl;
12612      if (obj->pAttachments) {
12613          PRINT_SPACE
12614          _OUT << "[" << std::endl;
12615          for (unsigned int i = 0; i < obj->attachmentCount; i++) {
12616            if (i+1 == obj->attachmentCount)
12617                print_VkAttachmentDescription(obj->pAttachments[i], "pAttachments", 0);
12618            else
12619                print_VkAttachmentDescription(obj->pAttachments[i], "pAttachments", 1);
12620          }
12621          PRINT_SPACE
12622          _OUT << "]," << std::endl;
12623     }
12624      else
12625      {
12626          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12627      }
12628
12629      print_uint32_t(obj->subpassCount, "subpassCount", 1);
12630
12631      PRINT_SPACE
12632      _OUT << "\"pSubpasses\": " << std::endl;
12633      if (obj->pSubpasses) {
12634          PRINT_SPACE
12635          _OUT << "[" << std::endl;
12636          for (unsigned int i = 0; i < obj->subpassCount; i++) {
12637            if (i+1 == obj->subpassCount)
12638                print_VkSubpassDescription(obj->pSubpasses[i], "pSubpasses", 0);
12639            else
12640                print_VkSubpassDescription(obj->pSubpasses[i], "pSubpasses", 1);
12641          }
12642          PRINT_SPACE
12643          _OUT << "]," << std::endl;
12644     }
12645      else
12646      {
12647          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
12648      }
12649
12650      print_uint32_t(obj->dependencyCount, "dependencyCount", 1);
12651
12652      PRINT_SPACE
12653      _OUT << "\"pDependencies\": " << std::endl;
12654      if (obj->pDependencies) {
12655          PRINT_SPACE
12656          _OUT << "[" << std::endl;
12657          for (unsigned int i = 0; i < obj->dependencyCount; i++) {
12658            if (i+1 == obj->dependencyCount)
12659                print_VkSubpassDependency(obj->pDependencies[i], "pDependencies", 0);
12660            else
12661                print_VkSubpassDependency(obj->pDependencies[i], "pDependencies", 1);
12662          }
12663          PRINT_SPACE
12664          _OUT << "]" << std::endl;
12665     }
12666      else
12667      {
12668          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
12669      }
12670
12671      INDENT(-4);
12672      PRINT_SPACE
12673      if (commaNeeded)
12674          _OUT << "}," << std::endl;
12675      else
12676          _OUT << "}" << std::endl;
12677 }
12678
12679 static void print_VkCommandPoolCreateInfo(VkCommandPoolCreateInfo obj, const std::string& s, bool commaNeeded=true) {
12680      PRINT_SPACE
12681      _OUT << "{" << std::endl;
12682      INDENT(4);
12683
12684      print_VkStructureType(obj.sType, "sType", 1);
12685
12686       if (obj.pNext) {
12687          dumpPNextChain(obj.pNext);
12688       } else {
12689          PRINT_SPACE
12690          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
12691      }
12692
12693      print_VkCommandPoolCreateFlags(obj.flags, "flags", 1);
12694
12695      print_uint32_t(obj.queueFamilyIndex, "queueFamilyIndex", 0);
12696
12697      INDENT(-4);
12698      PRINT_SPACE
12699      if (commaNeeded)
12700          _OUT << "}," << std::endl;
12701      else
12702          _OUT << "}" << std::endl;
12703 }
12704 static void print_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
12705      PRINT_SPACE
12706      _OUT << "{" << std::endl;
12707      INDENT(4);
12708
12709      print_VkStructureType(obj->sType, "sType", 1);
12710
12711       if (obj->pNext) {
12712          dumpPNextChain(obj->pNext);
12713       } else {
12714          PRINT_SPACE
12715          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
12716      }
12717
12718      print_VkCommandPoolCreateFlags(obj->flags, "flags", 1);
12719
12720      print_uint32_t(obj->queueFamilyIndex, "queueFamilyIndex", 0);
12721
12722      INDENT(-4);
12723      PRINT_SPACE
12724      if (commaNeeded)
12725          _OUT << "}," << std::endl;
12726      else
12727          _OUT << "}" << std::endl;
12728 }
12729
12730 static void print_VkCommandBufferAllocateInfo(VkCommandBufferAllocateInfo obj, const std::string& s, bool commaNeeded=true) {
12731      PRINT_SPACE
12732      _OUT << "{" << std::endl;
12733      INDENT(4);
12734
12735      print_VkStructureType(obj.sType, "sType", 1);
12736
12737       if (obj.pNext) {
12738          dumpPNextChain(obj.pNext);
12739       } else {
12740          PRINT_SPACE
12741          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
12742      }
12743
12744      // CTS : required value
12745      PRINT_SPACE    _OUT << "\"" << "commandPool" << "\"" << " : " << "\"" << "\"," << std::endl;
12746
12747      print_VkCommandBufferLevel(obj.level, "level", 1);
12748
12749      print_uint32_t(obj.commandBufferCount, "commandBufferCount", 0);
12750
12751      INDENT(-4);
12752      PRINT_SPACE
12753      if (commaNeeded)
12754          _OUT << "}," << std::endl;
12755      else
12756          _OUT << "}" << std::endl;
12757 }
12758 static void print_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo * obj, const std::string& s, bool commaNeeded=true) {
12759      PRINT_SPACE
12760      _OUT << "{" << std::endl;
12761      INDENT(4);
12762
12763      print_VkStructureType(obj->sType, "sType", 1);
12764
12765       if (obj->pNext) {
12766          dumpPNextChain(obj->pNext);
12767       } else {
12768          PRINT_SPACE
12769          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
12770      }
12771
12772      // CTS : required value
12773      PRINT_SPACE    _OUT << "\"" << "commandPool" << "\"" << " : " << "\"" << "\"," << std::endl;
12774
12775      print_VkCommandBufferLevel(obj->level, "level", 1);
12776
12777      print_uint32_t(obj->commandBufferCount, "commandBufferCount", 0);
12778
12779      INDENT(-4);
12780      PRINT_SPACE
12781      if (commaNeeded)
12782          _OUT << "}," << std::endl;
12783      else
12784          _OUT << "}" << std::endl;
12785 }
12786
12787 static void print_VkCommandBufferInheritanceInfo(VkCommandBufferInheritanceInfo obj, const std::string& s, bool commaNeeded=true) {
12788      PRINT_SPACE
12789      _OUT << "{" << std::endl;
12790      INDENT(4);
12791
12792      print_VkStructureType(obj.sType, "sType", 1);
12793
12794       if (obj.pNext) {
12795          dumpPNextChain(obj.pNext);
12796       } else {
12797          PRINT_SPACE
12798          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
12799      }
12800
12801      // CTS : required value
12802      PRINT_SPACE    _OUT << "\"" << "renderPass" << "\"" << " : " << obj.renderPass.getInternal() << "," << std::endl;
12803
12804      print_uint32_t(obj.subpass, "subpass", 1);
12805
12806      // CTS : required value
12807      PRINT_SPACE    _OUT << "\"" << "framebuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
12808
12809      print_VkBool32(obj.occlusionQueryEnable, "occlusionQueryEnable", 1);
12810
12811      print_VkQueryControlFlags(obj.queryFlags, "queryFlags", 1);
12812
12813      print_VkQueryPipelineStatisticFlags(obj.pipelineStatistics, "pipelineStatistics", 0);
12814
12815      INDENT(-4);
12816      PRINT_SPACE
12817      if (commaNeeded)
12818          _OUT << "}," << std::endl;
12819      else
12820          _OUT << "}" << std::endl;
12821 }
12822 static void print_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo * obj, const std::string& s, bool commaNeeded=true) {
12823      PRINT_SPACE
12824      _OUT << "{" << std::endl;
12825      INDENT(4);
12826
12827      print_VkStructureType(obj->sType, "sType", 1);
12828
12829       if (obj->pNext) {
12830          dumpPNextChain(obj->pNext);
12831       } else {
12832          PRINT_SPACE
12833          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
12834      }
12835
12836      // CTS : required value
12837      PRINT_SPACE    _OUT << "\"" << "renderPass" << "\"" << " : " << obj->renderPass.getInternal() << "," << std::endl;
12838
12839      print_uint32_t(obj->subpass, "subpass", 1);
12840
12841      // CTS : required value
12842      PRINT_SPACE    _OUT << "\"" << "framebuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
12843
12844      print_VkBool32(obj->occlusionQueryEnable, "occlusionQueryEnable", 1);
12845
12846      print_VkQueryControlFlags(obj->queryFlags, "queryFlags", 1);
12847
12848      print_VkQueryPipelineStatisticFlags(obj->pipelineStatistics, "pipelineStatistics", 0);
12849
12850      INDENT(-4);
12851      PRINT_SPACE
12852      if (commaNeeded)
12853          _OUT << "}," << std::endl;
12854      else
12855          _OUT << "}" << std::endl;
12856 }
12857
12858 static void print_VkCommandBufferBeginInfo(VkCommandBufferBeginInfo obj, const std::string& s, bool commaNeeded=true) {
12859      PRINT_SPACE
12860      _OUT << "{" << std::endl;
12861      INDENT(4);
12862
12863      print_VkStructureType(obj.sType, "sType", 1);
12864
12865       if (obj.pNext) {
12866          dumpPNextChain(obj.pNext);
12867       } else {
12868          PRINT_SPACE
12869          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
12870      }
12871
12872      print_VkCommandBufferUsageFlags(obj.flags, "flags", 1);
12873
12874      PRINT_SPACE
12875      _OUT << "\"pInheritanceInfo\": " << std::endl;
12876      if (obj.pInheritanceInfo) {
12877            print_VkCommandBufferInheritanceInfo(obj.pInheritanceInfo, "pInheritanceInfo", 0);
12878      }
12879      else
12880      {
12881          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
12882      }
12883
12884      INDENT(-4);
12885      PRINT_SPACE
12886      if (commaNeeded)
12887          _OUT << "}," << std::endl;
12888      else
12889          _OUT << "}" << std::endl;
12890 }
12891 static void print_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo * obj, const std::string& s, bool commaNeeded=true) {
12892      PRINT_SPACE
12893      _OUT << "{" << std::endl;
12894      INDENT(4);
12895
12896      print_VkStructureType(obj->sType, "sType", 1);
12897
12898       if (obj->pNext) {
12899          dumpPNextChain(obj->pNext);
12900       } else {
12901          PRINT_SPACE
12902          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
12903      }
12904
12905      print_VkCommandBufferUsageFlags(obj->flags, "flags", 1);
12906
12907      PRINT_SPACE
12908      _OUT << "\"pInheritanceInfo\": " << std::endl;
12909      if (obj->pInheritanceInfo) {
12910            print_VkCommandBufferInheritanceInfo(obj->pInheritanceInfo, "pInheritanceInfo", 0);
12911      }
12912      else
12913      {
12914          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
12915      }
12916
12917      INDENT(-4);
12918      PRINT_SPACE
12919      if (commaNeeded)
12920          _OUT << "}," << std::endl;
12921      else
12922          _OUT << "}" << std::endl;
12923 }
12924
12925 static void print_VkBufferCopy(VkBufferCopy obj, const std::string& s, bool commaNeeded=true) {
12926      PRINT_SPACE
12927      _OUT << "{" << std::endl;
12928      INDENT(4);
12929
12930      print_VkDeviceSize(obj.srcOffset, "srcOffset", 1);
12931
12932      print_VkDeviceSize(obj.dstOffset, "dstOffset", 1);
12933
12934      print_VkDeviceSize(obj.size, "size", 0);
12935
12936      INDENT(-4);
12937      PRINT_SPACE
12938      if (commaNeeded)
12939          _OUT << "}," << std::endl;
12940      else
12941          _OUT << "}" << std::endl;
12942 }
12943 static void print_VkBufferCopy(const VkBufferCopy * obj, const std::string& s, bool commaNeeded=true) {
12944      PRINT_SPACE
12945      _OUT << "{" << std::endl;
12946      INDENT(4);
12947
12948      print_VkDeviceSize(obj->srcOffset, "srcOffset", 1);
12949
12950      print_VkDeviceSize(obj->dstOffset, "dstOffset", 1);
12951
12952      print_VkDeviceSize(obj->size, "size", 0);
12953
12954      INDENT(-4);
12955      PRINT_SPACE
12956      if (commaNeeded)
12957          _OUT << "}," << std::endl;
12958      else
12959          _OUT << "}" << std::endl;
12960 }
12961
12962 static void print_VkImageSubresourceLayers(VkImageSubresourceLayers obj, const std::string& s, bool commaNeeded=true) {
12963      PRINT_SPACE
12964      _OUT << "{" << std::endl;
12965      INDENT(4);
12966
12967      print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 1);
12968
12969      print_uint32_t(obj.mipLevel, "mipLevel", 1);
12970
12971      print_uint32_t(obj.baseArrayLayer, "baseArrayLayer", 1);
12972
12973      print_uint32_t(obj.layerCount, "layerCount", 0);
12974
12975      INDENT(-4);
12976      PRINT_SPACE
12977      if (commaNeeded)
12978          _OUT << "}," << std::endl;
12979      else
12980          _OUT << "}" << std::endl;
12981 }
12982 static void print_VkImageSubresourceLayers(const VkImageSubresourceLayers * obj, const std::string& s, bool commaNeeded=true) {
12983      PRINT_SPACE
12984      _OUT << "{" << std::endl;
12985      INDENT(4);
12986
12987      print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 1);
12988
12989      print_uint32_t(obj->mipLevel, "mipLevel", 1);
12990
12991      print_uint32_t(obj->baseArrayLayer, "baseArrayLayer", 1);
12992
12993      print_uint32_t(obj->layerCount, "layerCount", 0);
12994
12995      INDENT(-4);
12996      PRINT_SPACE
12997      if (commaNeeded)
12998          _OUT << "}," << std::endl;
12999      else
13000          _OUT << "}" << std::endl;
13001 }
13002
13003 static void print_VkBufferImageCopy(VkBufferImageCopy obj, const std::string& s, bool commaNeeded=true) {
13004      PRINT_SPACE
13005      _OUT << "{" << std::endl;
13006      INDENT(4);
13007
13008      print_VkDeviceSize(obj.bufferOffset, "bufferOffset", 1);
13009
13010      print_uint32_t(obj.bufferRowLength, "bufferRowLength", 1);
13011
13012      print_uint32_t(obj.bufferImageHeight, "bufferImageHeight", 1);
13013
13014      PRINT_SPACE
13015      _OUT << "\"imageSubresource\": " << std::endl;
13016      {
13017            print_VkImageSubresourceLayers(obj.imageSubresource, "imageSubresource", 1);
13018      }
13019
13020      PRINT_SPACE
13021      _OUT << "\"imageOffset\": " << std::endl;
13022      {
13023            print_VkOffset3D(obj.imageOffset, "imageOffset", 1);
13024      }
13025
13026      PRINT_SPACE
13027      _OUT << "\"imageExtent\": " << std::endl;
13028      {
13029            print_VkExtent3D(obj.imageExtent, "imageExtent", 0);
13030      }
13031
13032      INDENT(-4);
13033      PRINT_SPACE
13034      if (commaNeeded)
13035          _OUT << "}," << std::endl;
13036      else
13037          _OUT << "}" << std::endl;
13038 }
13039 static void print_VkBufferImageCopy(const VkBufferImageCopy * obj, const std::string& s, bool commaNeeded=true) {
13040      PRINT_SPACE
13041      _OUT << "{" << std::endl;
13042      INDENT(4);
13043
13044      print_VkDeviceSize(obj->bufferOffset, "bufferOffset", 1);
13045
13046      print_uint32_t(obj->bufferRowLength, "bufferRowLength", 1);
13047
13048      print_uint32_t(obj->bufferImageHeight, "bufferImageHeight", 1);
13049
13050      PRINT_SPACE
13051      _OUT << "\"imageSubresource\": " << std::endl;
13052      {
13053            print_VkImageSubresourceLayers(obj->imageSubresource, "imageSubresource", 1);
13054      }
13055
13056      PRINT_SPACE
13057      _OUT << "\"imageOffset\": " << std::endl;
13058      {
13059            print_VkOffset3D(obj->imageOffset, "imageOffset", 1);
13060      }
13061
13062      PRINT_SPACE
13063      _OUT << "\"imageExtent\": " << std::endl;
13064      {
13065            print_VkExtent3D(obj->imageExtent, "imageExtent", 0);
13066      }
13067
13068      INDENT(-4);
13069      PRINT_SPACE
13070      if (commaNeeded)
13071          _OUT << "}," << std::endl;
13072      else
13073          _OUT << "}" << std::endl;
13074 }
13075
13076 static void print_VkClearColorValue(VkClearColorValue obj, const std::string& s, bool commaNeeded=true) {
13077      PRINT_SPACE
13078      _OUT << "{" << std::endl;
13079      INDENT(4);
13080
13081      PRINT_SPACE
13082      _OUT << "\"float32\":" << std::endl;
13083      PRINT_SPACE
13084      if (obj.float32) {
13085        _OUT << "[" << std::endl;
13086        for (unsigned int i = 0; i < 4; i++) {
13087            bool isCommaNeeded = (i+1) != 4;
13088            print_float(obj.float32[i], "", isCommaNeeded);
13089        }
13090        PRINT_SPACE
13091        _OUT << "]" << "," << std::endl;
13092      } else {
13093        _OUT << "\"NULL\"" << "," << std::endl;
13094      }
13095
13096      PRINT_SPACE
13097      _OUT << "\"int32\":" << std::endl;
13098      PRINT_SPACE
13099      if (obj.int32) {
13100        _OUT << "[" << std::endl;
13101        for (unsigned int i = 0; i < 4; i++) {
13102            bool isCommaNeeded = (i+1) != 4;
13103            print_int32_t(obj.int32[i], "", isCommaNeeded);
13104        }
13105        PRINT_SPACE
13106        _OUT << "]" << "," << std::endl;
13107      } else {
13108        _OUT << "\"NULL\"" << "," << std::endl;
13109      }
13110
13111      PRINT_SPACE
13112      _OUT << "\"uint32\":" << std::endl;
13113      PRINT_SPACE
13114      if (obj.uint32) {
13115        _OUT << "[" << std::endl;
13116        for (unsigned int i = 0; i < 4; i++) {
13117            bool isCommaNeeded = (i+1) != 4;
13118            print_uint32_t(obj.uint32[i], "", isCommaNeeded);
13119        }
13120        PRINT_SPACE
13121        _OUT << "]" << "" << std::endl;
13122      } else {
13123        _OUT << "\"NULL\"" << "" << std::endl;
13124      }
13125
13126      INDENT(-4);
13127      PRINT_SPACE
13128      if (commaNeeded)
13129          _OUT << "}," << std::endl;
13130      else
13131          _OUT << "}" << std::endl;
13132 }
13133 static void print_VkClearColorValue(const VkClearColorValue * obj, const std::string& s, bool commaNeeded=true) {
13134      PRINT_SPACE
13135      _OUT << "{" << std::endl;
13136      INDENT(4);
13137
13138      PRINT_SPACE
13139      _OUT << "\"float32\":" << std::endl;
13140      PRINT_SPACE
13141      if (obj->float32) {
13142        _OUT << "[" << std::endl;
13143        for (unsigned int i = 0; i < 4; i++) {
13144            bool isCommaNeeded = (i+1) != 4;
13145            print_float(obj->float32[i], "", isCommaNeeded);
13146        }
13147        PRINT_SPACE
13148        _OUT << "]" << "," << std::endl;
13149      } else {
13150        _OUT << "\"NULL\"" << "," << std::endl;
13151      }
13152
13153      PRINT_SPACE
13154      _OUT << "\"int32\":" << std::endl;
13155      PRINT_SPACE
13156      if (obj->int32) {
13157        _OUT << "[" << std::endl;
13158        for (unsigned int i = 0; i < 4; i++) {
13159            bool isCommaNeeded = (i+1) != 4;
13160            print_int32_t(obj->int32[i], "", isCommaNeeded);
13161        }
13162        PRINT_SPACE
13163        _OUT << "]" << "," << std::endl;
13164      } else {
13165        _OUT << "\"NULL\"" << "," << std::endl;
13166      }
13167
13168      PRINT_SPACE
13169      _OUT << "\"uint32\":" << std::endl;
13170      PRINT_SPACE
13171      if (obj->uint32) {
13172        _OUT << "[" << std::endl;
13173        for (unsigned int i = 0; i < 4; i++) {
13174            bool isCommaNeeded = (i+1) != 4;
13175            print_uint32_t(obj->uint32[i], "", isCommaNeeded);
13176        }
13177        PRINT_SPACE
13178        _OUT << "]" << "" << std::endl;
13179      } else {
13180        _OUT << "\"NULL\"" << "" << std::endl;
13181      }
13182
13183      INDENT(-4);
13184      PRINT_SPACE
13185      if (commaNeeded)
13186          _OUT << "}," << std::endl;
13187      else
13188          _OUT << "}" << std::endl;
13189 }
13190
13191 static void print_VkClearDepthStencilValue(VkClearDepthStencilValue obj, const std::string& s, bool commaNeeded=true) {
13192      PRINT_SPACE
13193      _OUT << "{" << std::endl;
13194      INDENT(4);
13195
13196      print_float(obj.depth, "depth", 1);
13197
13198      print_uint32_t(obj.stencil, "stencil", 0);
13199
13200      INDENT(-4);
13201      PRINT_SPACE
13202      if (commaNeeded)
13203          _OUT << "}," << std::endl;
13204      else
13205          _OUT << "}" << std::endl;
13206 }
13207 static void print_VkClearDepthStencilValue(const VkClearDepthStencilValue * obj, const std::string& s, bool commaNeeded=true) {
13208      PRINT_SPACE
13209      _OUT << "{" << std::endl;
13210      INDENT(4);
13211
13212      print_float(obj->depth, "depth", 1);
13213
13214      print_uint32_t(obj->stencil, "stencil", 0);
13215
13216      INDENT(-4);
13217      PRINT_SPACE
13218      if (commaNeeded)
13219          _OUT << "}," << std::endl;
13220      else
13221          _OUT << "}" << std::endl;
13222 }
13223
13224 static void print_VkClearValue(VkClearValue obj, const std::string& s, bool commaNeeded=true) {
13225      PRINT_SPACE
13226      _OUT << "{" << std::endl;
13227      INDENT(4);
13228
13229      print_VkClearColorValue(obj.color, "color", 1);
13230
13231      PRINT_SPACE
13232      _OUT << "\"depthStencil\": " << std::endl;
13233      {
13234            print_VkClearDepthStencilValue(obj.depthStencil, "depthStencil", 0);
13235      }
13236
13237      INDENT(-4);
13238      PRINT_SPACE
13239      if (commaNeeded)
13240          _OUT << "}," << std::endl;
13241      else
13242          _OUT << "}" << std::endl;
13243 }
13244 static void print_VkClearValue(const VkClearValue * obj, const std::string& s, bool commaNeeded=true) {
13245      PRINT_SPACE
13246      _OUT << "{" << std::endl;
13247      INDENT(4);
13248
13249      print_VkClearColorValue(obj->color, "color", 1);
13250
13251      PRINT_SPACE
13252      _OUT << "\"depthStencil\": " << std::endl;
13253      {
13254            print_VkClearDepthStencilValue(obj->depthStencil, "depthStencil", 0);
13255      }
13256
13257      INDENT(-4);
13258      PRINT_SPACE
13259      if (commaNeeded)
13260          _OUT << "}," << std::endl;
13261      else
13262          _OUT << "}" << std::endl;
13263 }
13264
13265 static void print_VkClearAttachment(VkClearAttachment obj, const std::string& s, bool commaNeeded=true) {
13266      PRINT_SPACE
13267      _OUT << "{" << std::endl;
13268      INDENT(4);
13269
13270      print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 1);
13271
13272      print_uint32_t(obj.colorAttachment, "colorAttachment", 1);
13273
13274      print_VkClearValue(obj.clearValue, "clearValue", 0);
13275
13276      INDENT(-4);
13277      PRINT_SPACE
13278      if (commaNeeded)
13279          _OUT << "}," << std::endl;
13280      else
13281          _OUT << "}" << std::endl;
13282 }
13283 static void print_VkClearAttachment(const VkClearAttachment * obj, const std::string& s, bool commaNeeded=true) {
13284      PRINT_SPACE
13285      _OUT << "{" << std::endl;
13286      INDENT(4);
13287
13288      print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 1);
13289
13290      print_uint32_t(obj->colorAttachment, "colorAttachment", 1);
13291
13292      print_VkClearValue(obj->clearValue, "clearValue", 0);
13293
13294      INDENT(-4);
13295      PRINT_SPACE
13296      if (commaNeeded)
13297          _OUT << "}," << std::endl;
13298      else
13299          _OUT << "}" << std::endl;
13300 }
13301
13302 static void print_VkClearRect(VkClearRect obj, const std::string& s, bool commaNeeded=true) {
13303      PRINT_SPACE
13304      _OUT << "{" << std::endl;
13305      INDENT(4);
13306
13307      PRINT_SPACE
13308      _OUT << "\"rect\": " << std::endl;
13309      {
13310            print_VkRect2D(obj.rect, "rect", 1);
13311      }
13312
13313      print_uint32_t(obj.baseArrayLayer, "baseArrayLayer", 1);
13314
13315      print_uint32_t(obj.layerCount, "layerCount", 0);
13316
13317      INDENT(-4);
13318      PRINT_SPACE
13319      if (commaNeeded)
13320          _OUT << "}," << std::endl;
13321      else
13322          _OUT << "}" << std::endl;
13323 }
13324 static void print_VkClearRect(const VkClearRect * obj, const std::string& s, bool commaNeeded=true) {
13325      PRINT_SPACE
13326      _OUT << "{" << std::endl;
13327      INDENT(4);
13328
13329      PRINT_SPACE
13330      _OUT << "\"rect\": " << std::endl;
13331      {
13332            print_VkRect2D(obj->rect, "rect", 1);
13333      }
13334
13335      print_uint32_t(obj->baseArrayLayer, "baseArrayLayer", 1);
13336
13337      print_uint32_t(obj->layerCount, "layerCount", 0);
13338
13339      INDENT(-4);
13340      PRINT_SPACE
13341      if (commaNeeded)
13342          _OUT << "}," << std::endl;
13343      else
13344          _OUT << "}" << std::endl;
13345 }
13346
13347 static void print_VkImageBlit(VkImageBlit obj, const std::string& s, bool commaNeeded=true) {
13348      PRINT_SPACE
13349      _OUT << "{" << std::endl;
13350      INDENT(4);
13351
13352      PRINT_SPACE
13353      _OUT << "\"srcSubresource\": " << std::endl;
13354      {
13355            print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1);
13356      }
13357
13358      PRINT_SPACE
13359      _OUT << "\"srcOffsets\":" << std::endl;
13360      PRINT_SPACE
13361      if (obj.srcOffsets) {
13362        _OUT << "[" << std::endl;
13363        for (unsigned int i = 0; i < 2; i++) {
13364            bool isCommaNeeded = (i+1) != 2;
13365            print_VkOffset3D(obj.srcOffsets[i], "", isCommaNeeded);
13366        }
13367        PRINT_SPACE
13368        _OUT << "]" << "," << std::endl;
13369      } else {
13370        _OUT << "\"NULL\"" << "," << std::endl;
13371      }
13372
13373      PRINT_SPACE
13374      _OUT << "\"dstSubresource\": " << std::endl;
13375      {
13376            print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1);
13377      }
13378
13379      PRINT_SPACE
13380      _OUT << "\"dstOffsets\":" << std::endl;
13381      PRINT_SPACE
13382      if (obj.dstOffsets) {
13383        _OUT << "[" << std::endl;
13384        for (unsigned int i = 0; i < 2; i++) {
13385            bool isCommaNeeded = (i+1) != 2;
13386            print_VkOffset3D(obj.dstOffsets[i], "", isCommaNeeded);
13387        }
13388        PRINT_SPACE
13389        _OUT << "]" << "" << std::endl;
13390      } else {
13391        _OUT << "\"NULL\"" << "" << std::endl;
13392      }
13393
13394      INDENT(-4);
13395      PRINT_SPACE
13396      if (commaNeeded)
13397          _OUT << "}," << std::endl;
13398      else
13399          _OUT << "}" << std::endl;
13400 }
13401 static void print_VkImageBlit(const VkImageBlit * obj, const std::string& s, bool commaNeeded=true) {
13402      PRINT_SPACE
13403      _OUT << "{" << std::endl;
13404      INDENT(4);
13405
13406      PRINT_SPACE
13407      _OUT << "\"srcSubresource\": " << std::endl;
13408      {
13409            print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1);
13410      }
13411
13412      PRINT_SPACE
13413      _OUT << "\"srcOffsets\":" << std::endl;
13414      PRINT_SPACE
13415      if (obj->srcOffsets) {
13416        _OUT << "[" << std::endl;
13417        for (unsigned int i = 0; i < 2; i++) {
13418            bool isCommaNeeded = (i+1) != 2;
13419            print_VkOffset3D(obj->srcOffsets[i], "", isCommaNeeded);
13420        }
13421        PRINT_SPACE
13422        _OUT << "]" << "," << std::endl;
13423      } else {
13424        _OUT << "\"NULL\"" << "," << std::endl;
13425      }
13426
13427      PRINT_SPACE
13428      _OUT << "\"dstSubresource\": " << std::endl;
13429      {
13430            print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1);
13431      }
13432
13433      PRINT_SPACE
13434      _OUT << "\"dstOffsets\":" << std::endl;
13435      PRINT_SPACE
13436      if (obj->dstOffsets) {
13437        _OUT << "[" << std::endl;
13438        for (unsigned int i = 0; i < 2; i++) {
13439            bool isCommaNeeded = (i+1) != 2;
13440            print_VkOffset3D(obj->dstOffsets[i], "", isCommaNeeded);
13441        }
13442        PRINT_SPACE
13443        _OUT << "]" << "" << std::endl;
13444      } else {
13445        _OUT << "\"NULL\"" << "" << std::endl;
13446      }
13447
13448      INDENT(-4);
13449      PRINT_SPACE
13450      if (commaNeeded)
13451          _OUT << "}," << std::endl;
13452      else
13453          _OUT << "}" << std::endl;
13454 }
13455
13456 static void print_VkImageCopy(VkImageCopy obj, const std::string& s, bool commaNeeded=true) {
13457      PRINT_SPACE
13458      _OUT << "{" << std::endl;
13459      INDENT(4);
13460
13461      PRINT_SPACE
13462      _OUT << "\"srcSubresource\": " << std::endl;
13463      {
13464            print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1);
13465      }
13466
13467      PRINT_SPACE
13468      _OUT << "\"srcOffset\": " << std::endl;
13469      {
13470            print_VkOffset3D(obj.srcOffset, "srcOffset", 1);
13471      }
13472
13473      PRINT_SPACE
13474      _OUT << "\"dstSubresource\": " << std::endl;
13475      {
13476            print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1);
13477      }
13478
13479      PRINT_SPACE
13480      _OUT << "\"dstOffset\": " << std::endl;
13481      {
13482            print_VkOffset3D(obj.dstOffset, "dstOffset", 1);
13483      }
13484
13485      PRINT_SPACE
13486      _OUT << "\"extent\": " << std::endl;
13487      {
13488            print_VkExtent3D(obj.extent, "extent", 0);
13489      }
13490
13491      INDENT(-4);
13492      PRINT_SPACE
13493      if (commaNeeded)
13494          _OUT << "}," << std::endl;
13495      else
13496          _OUT << "}" << std::endl;
13497 }
13498 static void print_VkImageCopy(const VkImageCopy * obj, const std::string& s, bool commaNeeded=true) {
13499      PRINT_SPACE
13500      _OUT << "{" << std::endl;
13501      INDENT(4);
13502
13503      PRINT_SPACE
13504      _OUT << "\"srcSubresource\": " << std::endl;
13505      {
13506            print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1);
13507      }
13508
13509      PRINT_SPACE
13510      _OUT << "\"srcOffset\": " << std::endl;
13511      {
13512            print_VkOffset3D(obj->srcOffset, "srcOffset", 1);
13513      }
13514
13515      PRINT_SPACE
13516      _OUT << "\"dstSubresource\": " << std::endl;
13517      {
13518            print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1);
13519      }
13520
13521      PRINT_SPACE
13522      _OUT << "\"dstOffset\": " << std::endl;
13523      {
13524            print_VkOffset3D(obj->dstOffset, "dstOffset", 1);
13525      }
13526
13527      PRINT_SPACE
13528      _OUT << "\"extent\": " << std::endl;
13529      {
13530            print_VkExtent3D(obj->extent, "extent", 0);
13531      }
13532
13533      INDENT(-4);
13534      PRINT_SPACE
13535      if (commaNeeded)
13536          _OUT << "}," << std::endl;
13537      else
13538          _OUT << "}" << std::endl;
13539 }
13540
13541 static void print_VkImageResolve(VkImageResolve obj, const std::string& s, bool commaNeeded=true) {
13542      PRINT_SPACE
13543      _OUT << "{" << std::endl;
13544      INDENT(4);
13545
13546      PRINT_SPACE
13547      _OUT << "\"srcSubresource\": " << std::endl;
13548      {
13549            print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1);
13550      }
13551
13552      PRINT_SPACE
13553      _OUT << "\"srcOffset\": " << std::endl;
13554      {
13555            print_VkOffset3D(obj.srcOffset, "srcOffset", 1);
13556      }
13557
13558      PRINT_SPACE
13559      _OUT << "\"dstSubresource\": " << std::endl;
13560      {
13561            print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1);
13562      }
13563
13564      PRINT_SPACE
13565      _OUT << "\"dstOffset\": " << std::endl;
13566      {
13567            print_VkOffset3D(obj.dstOffset, "dstOffset", 1);
13568      }
13569
13570      PRINT_SPACE
13571      _OUT << "\"extent\": " << std::endl;
13572      {
13573            print_VkExtent3D(obj.extent, "extent", 0);
13574      }
13575
13576      INDENT(-4);
13577      PRINT_SPACE
13578      if (commaNeeded)
13579          _OUT << "}," << std::endl;
13580      else
13581          _OUT << "}" << std::endl;
13582 }
13583 static void print_VkImageResolve(const VkImageResolve * obj, const std::string& s, bool commaNeeded=true) {
13584      PRINT_SPACE
13585      _OUT << "{" << std::endl;
13586      INDENT(4);
13587
13588      PRINT_SPACE
13589      _OUT << "\"srcSubresource\": " << std::endl;
13590      {
13591            print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1);
13592      }
13593
13594      PRINT_SPACE
13595      _OUT << "\"srcOffset\": " << std::endl;
13596      {
13597            print_VkOffset3D(obj->srcOffset, "srcOffset", 1);
13598      }
13599
13600      PRINT_SPACE
13601      _OUT << "\"dstSubresource\": " << std::endl;
13602      {
13603            print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1);
13604      }
13605
13606      PRINT_SPACE
13607      _OUT << "\"dstOffset\": " << std::endl;
13608      {
13609            print_VkOffset3D(obj->dstOffset, "dstOffset", 1);
13610      }
13611
13612      PRINT_SPACE
13613      _OUT << "\"extent\": " << std::endl;
13614      {
13615            print_VkExtent3D(obj->extent, "extent", 0);
13616      }
13617
13618      INDENT(-4);
13619      PRINT_SPACE
13620      if (commaNeeded)
13621          _OUT << "}," << std::endl;
13622      else
13623          _OUT << "}" << std::endl;
13624 }
13625
13626 static void print_VkRenderPassBeginInfo(VkRenderPassBeginInfo obj, const std::string& s, bool commaNeeded=true) {
13627      PRINT_SPACE
13628      _OUT << "{" << std::endl;
13629      INDENT(4);
13630
13631      print_VkStructureType(obj.sType, "sType", 1);
13632
13633       if (obj.pNext) {
13634          dumpPNextChain(obj.pNext);
13635       } else {
13636          PRINT_SPACE
13637          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
13638      }
13639
13640      // CTS : required value
13641      PRINT_SPACE    _OUT << "\"" << "renderPass" << "\"" << " : " << obj.renderPass.getInternal() << "," << std::endl;
13642
13643      // CTS : required value
13644      PRINT_SPACE    _OUT << "\"" << "framebuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
13645
13646      PRINT_SPACE
13647      _OUT << "\"renderArea\": " << std::endl;
13648      {
13649            print_VkRect2D(obj.renderArea, "renderArea", 1);
13650      }
13651
13652      print_uint32_t(obj.clearValueCount, "clearValueCount", 1);
13653
13654      PRINT_SPACE
13655      _OUT << "\"pClearValues\":" << std::endl;
13656      PRINT_SPACE
13657      if (obj.pClearValues) {
13658        _OUT << "[" << std::endl;
13659        for (unsigned int i = 0; i < obj.clearValueCount; i++) {
13660            bool isCommaNeeded = (i+1) != obj.clearValueCount;
13661            print_VkClearValue(obj.pClearValues[i], "", isCommaNeeded);
13662        }
13663        PRINT_SPACE
13664        _OUT << "]" << "" << std::endl;
13665      } else {
13666        _OUT << "\"NULL\"" << "" << std::endl;
13667      }
13668
13669      INDENT(-4);
13670      PRINT_SPACE
13671      if (commaNeeded)
13672          _OUT << "}," << std::endl;
13673      else
13674          _OUT << "}" << std::endl;
13675 }
13676 static void print_VkRenderPassBeginInfo(const VkRenderPassBeginInfo * obj, const std::string& s, bool commaNeeded=true) {
13677      PRINT_SPACE
13678      _OUT << "{" << std::endl;
13679      INDENT(4);
13680
13681      print_VkStructureType(obj->sType, "sType", 1);
13682
13683       if (obj->pNext) {
13684          dumpPNextChain(obj->pNext);
13685       } else {
13686          PRINT_SPACE
13687          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
13688      }
13689
13690      // CTS : required value
13691      PRINT_SPACE    _OUT << "\"" << "renderPass" << "\"" << " : " << obj->renderPass.getInternal() << "," << std::endl;
13692
13693      // CTS : required value
13694      PRINT_SPACE    _OUT << "\"" << "framebuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
13695
13696      PRINT_SPACE
13697      _OUT << "\"renderArea\": " << std::endl;
13698      {
13699            print_VkRect2D(obj->renderArea, "renderArea", 1);
13700      }
13701
13702      print_uint32_t(obj->clearValueCount, "clearValueCount", 1);
13703
13704      PRINT_SPACE
13705      _OUT << "\"pClearValues\":" << std::endl;
13706      PRINT_SPACE
13707      if (obj->pClearValues) {
13708        _OUT << "[" << std::endl;
13709        for (unsigned int i = 0; i < obj->clearValueCount; i++) {
13710            bool isCommaNeeded = (i+1) != obj->clearValueCount;
13711            print_VkClearValue(obj->pClearValues[i], "", isCommaNeeded);
13712        }
13713        PRINT_SPACE
13714        _OUT << "]" << "" << std::endl;
13715      } else {
13716        _OUT << "\"NULL\"" << "" << std::endl;
13717      }
13718
13719      INDENT(-4);
13720      PRINT_SPACE
13721      if (commaNeeded)
13722          _OUT << "}," << std::endl;
13723      else
13724          _OUT << "}" << std::endl;
13725 }
13726
13727 static void print_VkSamplerYcbcrConversion(VkSamplerYcbcrConversion obj, const std::string& str, bool commaNeeded=true) {
13728      PRINT_SPACE
13729      if (commaNeeded)
13730          _OUT << "\"" << str << "\"" << "," << std::endl;
13731      else
13732          _OUT << "\"" << str << "\"" << std::endl;
13733 }
13734 static void print_VkSamplerYcbcrConversion(const VkSamplerYcbcrConversion * obj, const std::string& str, bool commaNeeded=true) {
13735      PRINT_SPACE
13736      if (commaNeeded)
13737          _OUT << "\"" << str << "\"" << "," << std::endl;
13738      else
13739          _OUT << "\"" << str << "\"" << std::endl;
13740 }
13741
13742 static std::map<deUint64, std::string> VkSubgroupFeatureFlagBits_map = {
13743     std::make_pair(1ULL << 0, "VK_SUBGROUP_FEATURE_BASIC_BIT"),
13744     std::make_pair(1ULL << 1, "VK_SUBGROUP_FEATURE_VOTE_BIT"),
13745     std::make_pair(1ULL << 2, "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT"),
13746     std::make_pair(1ULL << 3, "VK_SUBGROUP_FEATURE_BALLOT_BIT"),
13747     std::make_pair(1ULL << 4, "VK_SUBGROUP_FEATURE_SHUFFLE_BIT"),
13748     std::make_pair(1ULL << 5, "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT"),
13749     std::make_pair(1ULL << 6, "VK_SUBGROUP_FEATURE_CLUSTERED_BIT"),
13750     std::make_pair(1ULL << 7, "VK_SUBGROUP_FEATURE_QUAD_BIT"),
13751     std::make_pair(1ULL << 8, "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV"),
13752 };
13753 static void print_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) {
13754      PRINT_SPACE
13755      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13756      if (commaNeeded)
13757          _OUT << "\"" <<  VkSubgroupFeatureFlagBits_map[obj] << "\"," << std::endl;
13758      else
13759          _OUT << "\"" << VkSubgroupFeatureFlagBits_map[obj] << "\"" << std::endl;
13760 }
13761 static void print_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) {
13762      PRINT_SPACE
13763      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13764      if (commaNeeded)
13765          _OUT << "\"" <<  VkSubgroupFeatureFlagBits_map[*obj] << "\"," << std::endl;
13766      else
13767          _OUT << "\"" << VkSubgroupFeatureFlagBits_map[*obj] << "\"" << std::endl;
13768 }
13769
13770 static std::map<deUint64, std::string> VkPeerMemoryFeatureFlagBits_map = {
13771     std::make_pair(1ULL << 0, "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT"),
13772     std::make_pair(1ULL << 1, "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT"),
13773     std::make_pair(1ULL << 2, "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT"),
13774     std::make_pair(1ULL << 3, "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT"),
13775 };
13776 static void print_VkPeerMemoryFeatureFlagBits(VkPeerMemoryFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) {
13777      PRINT_SPACE
13778      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13779      if (commaNeeded)
13780          _OUT << "\"" <<  VkPeerMemoryFeatureFlagBits_map[obj] << "\"," << std::endl;
13781      else
13782          _OUT << "\"" << VkPeerMemoryFeatureFlagBits_map[obj] << "\"" << std::endl;
13783 }
13784 static void print_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) {
13785      PRINT_SPACE
13786      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13787      if (commaNeeded)
13788          _OUT << "\"" <<  VkPeerMemoryFeatureFlagBits_map[*obj] << "\"," << std::endl;
13789      else
13790          _OUT << "\"" << VkPeerMemoryFeatureFlagBits_map[*obj] << "\"" << std::endl;
13791 }
13792
13793 static std::map<deUint64, std::string> VkMemoryAllocateFlagBits_map = {
13794     std::make_pair(1ULL << 0, "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT"),
13795     std::make_pair(1ULL << 1, "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT"),
13796     std::make_pair(1ULL << 2, "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"),
13797 };
13798 static void print_VkMemoryAllocateFlagBits(VkMemoryAllocateFlagBits obj, const std::string& str, bool commaNeeded=true) {
13799      PRINT_SPACE
13800      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13801      if (commaNeeded)
13802          _OUT << "\"" <<  VkMemoryAllocateFlagBits_map[obj] << "\"," << std::endl;
13803      else
13804          _OUT << "\"" << VkMemoryAllocateFlagBits_map[obj] << "\"" << std::endl;
13805 }
13806 static void print_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits * obj, const std::string& str, bool commaNeeded=true) {
13807      PRINT_SPACE
13808      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13809      if (commaNeeded)
13810          _OUT << "\"" <<  VkMemoryAllocateFlagBits_map[*obj] << "\"," << std::endl;
13811      else
13812          _OUT << "\"" << VkMemoryAllocateFlagBits_map[*obj] << "\"" << std::endl;
13813 }
13814
13815 static std::map<deUint64, std::string> VkPointClippingBehavior_map = {
13816     std::make_pair(0, "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES"),
13817     std::make_pair(1, "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY"),
13818 };
13819 static void print_VkPointClippingBehavior(VkPointClippingBehavior obj, const std::string& str, bool commaNeeded=true) {
13820      PRINT_SPACE
13821      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13822      if (commaNeeded)
13823          _OUT << "\"" <<  VkPointClippingBehavior_map[obj] << "\"," << std::endl;
13824      else
13825          _OUT << "\"" << VkPointClippingBehavior_map[obj] << "\"" << std::endl;
13826 }
13827 static void print_VkPointClippingBehavior(const VkPointClippingBehavior * obj, const std::string& str, bool commaNeeded=true) {
13828      PRINT_SPACE
13829      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13830      if (commaNeeded)
13831          _OUT << "\"" <<  VkPointClippingBehavior_map[*obj] << "\"," << std::endl;
13832      else
13833          _OUT << "\"" << VkPointClippingBehavior_map[*obj] << "\"" << std::endl;
13834 }
13835
13836 static std::map<deUint64, std::string> VkTessellationDomainOrigin_map = {
13837     std::make_pair(0, "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT"),
13838     std::make_pair(1, "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT"),
13839 };
13840 static void print_VkTessellationDomainOrigin(VkTessellationDomainOrigin obj, const std::string& str, bool commaNeeded=true) {
13841      PRINT_SPACE
13842      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13843      if (commaNeeded)
13844          _OUT << "\"" <<  VkTessellationDomainOrigin_map[obj] << "\"," << std::endl;
13845      else
13846          _OUT << "\"" << VkTessellationDomainOrigin_map[obj] << "\"" << std::endl;
13847 }
13848 static void print_VkTessellationDomainOrigin(const VkTessellationDomainOrigin * obj, const std::string& str, bool commaNeeded=true) {
13849      PRINT_SPACE
13850      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13851      if (commaNeeded)
13852          _OUT << "\"" <<  VkTessellationDomainOrigin_map[*obj] << "\"," << std::endl;
13853      else
13854          _OUT << "\"" << VkTessellationDomainOrigin_map[*obj] << "\"" << std::endl;
13855 }
13856
13857 static std::map<deUint64, std::string> VkSamplerYcbcrModelConversion_map = {
13858     std::make_pair(0, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY"),
13859     std::make_pair(1, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY"),
13860     std::make_pair(2, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709"),
13861     std::make_pair(3, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601"),
13862     std::make_pair(4, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020"),
13863 };
13864 static void print_VkSamplerYcbcrModelConversion(VkSamplerYcbcrModelConversion obj, const std::string& str, bool commaNeeded=true) {
13865      PRINT_SPACE
13866      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13867      if (commaNeeded)
13868          _OUT << "\"" <<  VkSamplerYcbcrModelConversion_map[obj] << "\"," << std::endl;
13869      else
13870          _OUT << "\"" << VkSamplerYcbcrModelConversion_map[obj] << "\"" << std::endl;
13871 }
13872 static void print_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion * obj, const std::string& str, bool commaNeeded=true) {
13873      PRINT_SPACE
13874      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13875      if (commaNeeded)
13876          _OUT << "\"" <<  VkSamplerYcbcrModelConversion_map[*obj] << "\"," << std::endl;
13877      else
13878          _OUT << "\"" << VkSamplerYcbcrModelConversion_map[*obj] << "\"" << std::endl;
13879 }
13880
13881 static std::map<deUint64, std::string> VkSamplerYcbcrRange_map = {
13882     std::make_pair(0, "VK_SAMPLER_YCBCR_RANGE_ITU_FULL"),
13883     std::make_pair(1, "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW"),
13884 };
13885 static void print_VkSamplerYcbcrRange(VkSamplerYcbcrRange obj, const std::string& str, bool commaNeeded=true) {
13886      PRINT_SPACE
13887      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13888      if (commaNeeded)
13889          _OUT << "\"" <<  VkSamplerYcbcrRange_map[obj] << "\"," << std::endl;
13890      else
13891          _OUT << "\"" << VkSamplerYcbcrRange_map[obj] << "\"" << std::endl;
13892 }
13893 static void print_VkSamplerYcbcrRange(const VkSamplerYcbcrRange * obj, const std::string& str, bool commaNeeded=true) {
13894      PRINT_SPACE
13895      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13896      if (commaNeeded)
13897          _OUT << "\"" <<  VkSamplerYcbcrRange_map[*obj] << "\"," << std::endl;
13898      else
13899          _OUT << "\"" << VkSamplerYcbcrRange_map[*obj] << "\"" << std::endl;
13900 }
13901
13902 static std::map<deUint64, std::string> VkChromaLocation_map = {
13903     std::make_pair(0, "VK_CHROMA_LOCATION_COSITED_EVEN"),
13904     std::make_pair(1, "VK_CHROMA_LOCATION_MIDPOINT"),
13905 };
13906 static void print_VkChromaLocation(VkChromaLocation obj, const std::string& str, bool commaNeeded=true) {
13907      PRINT_SPACE
13908      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13909      if (commaNeeded)
13910          _OUT << "\"" <<  VkChromaLocation_map[obj] << "\"," << std::endl;
13911      else
13912          _OUT << "\"" << VkChromaLocation_map[obj] << "\"" << std::endl;
13913 }
13914 static void print_VkChromaLocation(const VkChromaLocation * obj, const std::string& str, bool commaNeeded=true) {
13915      PRINT_SPACE
13916      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13917      if (commaNeeded)
13918          _OUT << "\"" <<  VkChromaLocation_map[*obj] << "\"," << std::endl;
13919      else
13920          _OUT << "\"" << VkChromaLocation_map[*obj] << "\"" << std::endl;
13921 }
13922
13923 static std::map<deUint64, std::string> VkExternalMemoryHandleTypeFlagBits_map = {
13924     std::make_pair(1ULL << 0, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"),
13925     std::make_pair(1ULL << 1, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT"),
13926     std::make_pair(1ULL << 2, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"),
13927     std::make_pair(1ULL << 3, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT"),
13928     std::make_pair(1ULL << 4, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT"),
13929     std::make_pair(1ULL << 5, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT"),
13930     std::make_pair(1ULL << 6, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT"),
13931     std::make_pair(1ULL << 9, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT"),
13932     std::make_pair(1ULL << 10, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID"),
13933     std::make_pair(1ULL << 7, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"),
13934     std::make_pair(1ULL << 8, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"),
13935     std::make_pair(1ULL << 11, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA"),
13936     std::make_pair(1ULL << 12, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV"),
13937     std::make_pair(1ULL << 13, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RESERVED_13_BIT_NV"),
13938 };
13939 static void print_VkExternalMemoryHandleTypeFlagBits(VkExternalMemoryHandleTypeFlagBits obj, const std::string& str, bool commaNeeded=true) {
13940      PRINT_SPACE
13941      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13942      if (commaNeeded)
13943          _OUT << "\"" <<  VkExternalMemoryHandleTypeFlagBits_map[obj] << "\"," << std::endl;
13944      else
13945          _OUT << "\"" << VkExternalMemoryHandleTypeFlagBits_map[obj] << "\"" << std::endl;
13946 }
13947 static void print_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits * obj, const std::string& str, bool commaNeeded=true) {
13948      PRINT_SPACE
13949      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13950      if (commaNeeded)
13951          _OUT << "\"" <<  VkExternalMemoryHandleTypeFlagBits_map[*obj] << "\"," << std::endl;
13952      else
13953          _OUT << "\"" << VkExternalMemoryHandleTypeFlagBits_map[*obj] << "\"" << std::endl;
13954 }
13955
13956 static std::map<deUint64, std::string> VkExternalMemoryFeatureFlagBits_map = {
13957     std::make_pair(1ULL << 0, "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT"),
13958     std::make_pair(1ULL << 1, "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT"),
13959     std::make_pair(1ULL << 2, "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT"),
13960 };
13961 static void print_VkExternalMemoryFeatureFlagBits(VkExternalMemoryFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) {
13962      PRINT_SPACE
13963      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13964      if (commaNeeded)
13965          _OUT << "\"" <<  VkExternalMemoryFeatureFlagBits_map[obj] << "\"," << std::endl;
13966      else
13967          _OUT << "\"" << VkExternalMemoryFeatureFlagBits_map[obj] << "\"" << std::endl;
13968 }
13969 static void print_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) {
13970      PRINT_SPACE
13971      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13972      if (commaNeeded)
13973          _OUT << "\"" <<  VkExternalMemoryFeatureFlagBits_map[*obj] << "\"," << std::endl;
13974      else
13975          _OUT << "\"" << VkExternalMemoryFeatureFlagBits_map[*obj] << "\"" << std::endl;
13976 }
13977
13978 static std::map<deUint64, std::string> VkExternalFenceHandleTypeFlagBits_map = {
13979     std::make_pair(1ULL << 0, "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT"),
13980     std::make_pair(1ULL << 1, "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT"),
13981     std::make_pair(1ULL << 2, "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"),
13982     std::make_pair(1ULL << 3, "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT"),
13983     std::make_pair(1ULL << 4, "VK_EXTERNAL_FENCE_HANDLE_TYPE_RESERVED_4_BIT_NV"),
13984     std::make_pair(1ULL << 5, "VK_EXTERNAL_FENCE_HANDLE_TYPE_RESERVED_5_BIT_NV"),
13985 };
13986 static void print_VkExternalFenceHandleTypeFlagBits(VkExternalFenceHandleTypeFlagBits obj, const std::string& str, bool commaNeeded=true) {
13987      PRINT_SPACE
13988      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13989      if (commaNeeded)
13990          _OUT << "\"" <<  VkExternalFenceHandleTypeFlagBits_map[obj] << "\"," << std::endl;
13991      else
13992          _OUT << "\"" << VkExternalFenceHandleTypeFlagBits_map[obj] << "\"" << std::endl;
13993 }
13994 static void print_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits * obj, const std::string& str, bool commaNeeded=true) {
13995      PRINT_SPACE
13996      if (str != "") _OUT << "\"" << str << "\"" << " : ";
13997      if (commaNeeded)
13998          _OUT << "\"" <<  VkExternalFenceHandleTypeFlagBits_map[*obj] << "\"," << std::endl;
13999      else
14000          _OUT << "\"" << VkExternalFenceHandleTypeFlagBits_map[*obj] << "\"" << std::endl;
14001 }
14002
14003 static std::map<deUint64, std::string> VkExternalFenceFeatureFlagBits_map = {
14004     std::make_pair(1ULL << 0, "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT"),
14005     std::make_pair(1ULL << 1, "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT"),
14006 };
14007 static void print_VkExternalFenceFeatureFlagBits(VkExternalFenceFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) {
14008      PRINT_SPACE
14009      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14010      if (commaNeeded)
14011          _OUT << "\"" <<  VkExternalFenceFeatureFlagBits_map[obj] << "\"," << std::endl;
14012      else
14013          _OUT << "\"" << VkExternalFenceFeatureFlagBits_map[obj] << "\"" << std::endl;
14014 }
14015 static void print_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) {
14016      PRINT_SPACE
14017      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14018      if (commaNeeded)
14019          _OUT << "\"" <<  VkExternalFenceFeatureFlagBits_map[*obj] << "\"," << std::endl;
14020      else
14021          _OUT << "\"" << VkExternalFenceFeatureFlagBits_map[*obj] << "\"" << std::endl;
14022 }
14023
14024 static std::map<deUint64, std::string> VkFenceImportFlagBits_map = {
14025     std::make_pair(1ULL << 0, "VK_FENCE_IMPORT_TEMPORARY_BIT"),
14026 };
14027 static void print_VkFenceImportFlagBits(VkFenceImportFlagBits obj, const std::string& str, bool commaNeeded=true) {
14028      PRINT_SPACE
14029      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14030      if (commaNeeded)
14031          _OUT << "\"" <<  VkFenceImportFlagBits_map[obj] << "\"," << std::endl;
14032      else
14033          _OUT << "\"" << VkFenceImportFlagBits_map[obj] << "\"" << std::endl;
14034 }
14035 static void print_VkFenceImportFlagBits(const VkFenceImportFlagBits * obj, const std::string& str, bool commaNeeded=true) {
14036      PRINT_SPACE
14037      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14038      if (commaNeeded)
14039          _OUT << "\"" <<  VkFenceImportFlagBits_map[*obj] << "\"," << std::endl;
14040      else
14041          _OUT << "\"" << VkFenceImportFlagBits_map[*obj] << "\"" << std::endl;
14042 }
14043
14044 static std::map<deUint64, std::string> VkSemaphoreImportFlagBits_map = {
14045     std::make_pair(1ULL << 0, "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT"),
14046 };
14047 static void print_VkSemaphoreImportFlagBits(VkSemaphoreImportFlagBits obj, const std::string& str, bool commaNeeded=true) {
14048      PRINT_SPACE
14049      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14050      if (commaNeeded)
14051          _OUT << "\"" <<  VkSemaphoreImportFlagBits_map[obj] << "\"," << std::endl;
14052      else
14053          _OUT << "\"" << VkSemaphoreImportFlagBits_map[obj] << "\"" << std::endl;
14054 }
14055 static void print_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits * obj, const std::string& str, bool commaNeeded=true) {
14056      PRINT_SPACE
14057      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14058      if (commaNeeded)
14059          _OUT << "\"" <<  VkSemaphoreImportFlagBits_map[*obj] << "\"," << std::endl;
14060      else
14061          _OUT << "\"" << VkSemaphoreImportFlagBits_map[*obj] << "\"" << std::endl;
14062 }
14063
14064 static std::map<deUint64, std::string> VkExternalSemaphoreHandleTypeFlagBits_map = {
14065     std::make_pair(1ULL << 0, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT"),
14066     std::make_pair(1ULL << 1, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT"),
14067     std::make_pair(1ULL << 2, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"),
14068     std::make_pair(1ULL << 3, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT"),
14069     std::make_pair(1ULL << 4, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT"),
14070     std::make_pair(1ULL << 7, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA"),
14071     std::make_pair(1ULL << 5, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_RESERVED_5_BIT_NV"),
14072     std::make_pair(1ULL << 6, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_RESERVED_6_BIT_NV"),
14073 };
14074 static void print_VkExternalSemaphoreHandleTypeFlagBits(VkExternalSemaphoreHandleTypeFlagBits obj, const std::string& str, bool commaNeeded=true) {
14075      PRINT_SPACE
14076      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14077      if (commaNeeded)
14078          _OUT << "\"" <<  VkExternalSemaphoreHandleTypeFlagBits_map[obj] << "\"," << std::endl;
14079      else
14080          _OUT << "\"" << VkExternalSemaphoreHandleTypeFlagBits_map[obj] << "\"" << std::endl;
14081 }
14082 static void print_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits * obj, const std::string& str, bool commaNeeded=true) {
14083      PRINT_SPACE
14084      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14085      if (commaNeeded)
14086          _OUT << "\"" <<  VkExternalSemaphoreHandleTypeFlagBits_map[*obj] << "\"," << std::endl;
14087      else
14088          _OUT << "\"" << VkExternalSemaphoreHandleTypeFlagBits_map[*obj] << "\"" << std::endl;
14089 }
14090
14091 static std::map<deUint64, std::string> VkExternalSemaphoreFeatureFlagBits_map = {
14092     std::make_pair(1ULL << 0, "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT"),
14093     std::make_pair(1ULL << 1, "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT"),
14094 };
14095 static void print_VkExternalSemaphoreFeatureFlagBits(VkExternalSemaphoreFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) {
14096      PRINT_SPACE
14097      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14098      if (commaNeeded)
14099          _OUT << "\"" <<  VkExternalSemaphoreFeatureFlagBits_map[obj] << "\"," << std::endl;
14100      else
14101          _OUT << "\"" << VkExternalSemaphoreFeatureFlagBits_map[obj] << "\"" << std::endl;
14102 }
14103 static void print_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) {
14104      PRINT_SPACE
14105      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14106      if (commaNeeded)
14107          _OUT << "\"" <<  VkExternalSemaphoreFeatureFlagBits_map[*obj] << "\"," << std::endl;
14108      else
14109          _OUT << "\"" << VkExternalSemaphoreFeatureFlagBits_map[*obj] << "\"" << std::endl;
14110 }
14111
14112 static void print_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags obj, const std::string& str, bool commaNeeded=true) {
14113      PRINT_SPACE
14114      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14115      const int max_bits = 64; // We don't expect the number to be larger.
14116      std::bitset<max_bits> b(obj);
14117      _OUT << "\"";
14118      if (obj == 0) _OUT << "0";
14119      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14120          if (b[i] == 1) {
14121              bitCount++;
14122              if (bitCount < b.count())
14123                  _OUT << VkSubgroupFeatureFlagBits_map[1ULL<<i] << " | ";
14124              else
14125                  _OUT << VkSubgroupFeatureFlagBits_map[1ULL<<i];
14126          }
14127      }
14128      if (commaNeeded)
14129        _OUT << "\"" << ",";
14130      else
14131        _OUT << "\""<< "";
14132      _OUT << std::endl;
14133 }
14134 static void print_VkSubgroupFeatureFlags(const VkSubgroupFeatureFlags * obj, const std::string& str, bool commaNeeded=true) {
14135      PRINT_SPACE
14136      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14137      const int max_bits = 64; // We don't expect the number to be larger.
14138      std::bitset<max_bits> b(obj);
14139      _OUT << "\"";
14140      if (obj == 0) _OUT << "0";
14141      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14142          if (b[i] == 1) {
14143              bitCount++;
14144              if (bitCount < b.count())
14145                  _OUT << VkSubgroupFeatureFlagBits_map[1ULL<<i] << " | ";
14146              else
14147                  _OUT << VkSubgroupFeatureFlagBits_map[1ULL<<i];
14148          }
14149      }
14150      if (commaNeeded)
14151        _OUT << "\"" << ",";
14152      else
14153        _OUT << "\""<< "";
14154      _OUT << std::endl;
14155 }
14156
14157 static void print_VkPeerMemoryFeatureFlags(VkPeerMemoryFeatureFlags obj, const std::string& str, bool commaNeeded=true) {
14158      PRINT_SPACE
14159      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14160      const int max_bits = 64; // We don't expect the number to be larger.
14161      std::bitset<max_bits> b(obj);
14162      _OUT << "\"";
14163      if (obj == 0) _OUT << "0";
14164      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14165          if (b[i] == 1) {
14166              bitCount++;
14167              if (bitCount < b.count())
14168                  _OUT << VkPeerMemoryFeatureFlagBits_map[1ULL<<i] << " | ";
14169              else
14170                  _OUT << VkPeerMemoryFeatureFlagBits_map[1ULL<<i];
14171          }
14172      }
14173      if (commaNeeded)
14174        _OUT << "\"" << ",";
14175      else
14176        _OUT << "\""<< "";
14177      _OUT << std::endl;
14178 }
14179 static void print_VkPeerMemoryFeatureFlags(const VkPeerMemoryFeatureFlags * obj, const std::string& str, bool commaNeeded=true) {
14180      PRINT_SPACE
14181      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14182      const int max_bits = 64; // We don't expect the number to be larger.
14183      std::bitset<max_bits> b(obj);
14184      _OUT << "\"";
14185      if (obj == 0) _OUT << "0";
14186      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14187          if (b[i] == 1) {
14188              bitCount++;
14189              if (bitCount < b.count())
14190                  _OUT << VkPeerMemoryFeatureFlagBits_map[1ULL<<i] << " | ";
14191              else
14192                  _OUT << VkPeerMemoryFeatureFlagBits_map[1ULL<<i];
14193          }
14194      }
14195      if (commaNeeded)
14196        _OUT << "\"" << ",";
14197      else
14198        _OUT << "\""<< "";
14199      _OUT << std::endl;
14200 }
14201
14202 static void print_VkMemoryAllocateFlags(VkMemoryAllocateFlags obj, const std::string& str, bool commaNeeded=true) {
14203      PRINT_SPACE
14204      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14205      const int max_bits = 64; // We don't expect the number to be larger.
14206      std::bitset<max_bits> b(obj);
14207      _OUT << "\"";
14208      if (obj == 0) _OUT << "0";
14209      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14210          if (b[i] == 1) {
14211              bitCount++;
14212              if (bitCount < b.count())
14213                  _OUT << VkMemoryAllocateFlagBits_map[1ULL<<i] << " | ";
14214              else
14215                  _OUT << VkMemoryAllocateFlagBits_map[1ULL<<i];
14216          }
14217      }
14218      if (commaNeeded)
14219        _OUT << "\"" << ",";
14220      else
14221        _OUT << "\""<< "";
14222      _OUT << std::endl;
14223 }
14224 static void print_VkMemoryAllocateFlags(const VkMemoryAllocateFlags * obj, const std::string& str, bool commaNeeded=true) {
14225      PRINT_SPACE
14226      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14227      const int max_bits = 64; // We don't expect the number to be larger.
14228      std::bitset<max_bits> b(obj);
14229      _OUT << "\"";
14230      if (obj == 0) _OUT << "0";
14231      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14232          if (b[i] == 1) {
14233              bitCount++;
14234              if (bitCount < b.count())
14235                  _OUT << VkMemoryAllocateFlagBits_map[1ULL<<i] << " | ";
14236              else
14237                  _OUT << VkMemoryAllocateFlagBits_map[1ULL<<i];
14238          }
14239      }
14240      if (commaNeeded)
14241        _OUT << "\"" << ",";
14242      else
14243        _OUT << "\""<< "";
14244      _OUT << std::endl;
14245 }
14246
14247 static void print_VkExternalMemoryHandleTypeFlags(VkExternalMemoryHandleTypeFlags obj, const std::string& str, bool commaNeeded=true) {
14248      PRINT_SPACE
14249      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14250      const int max_bits = 64; // We don't expect the number to be larger.
14251      std::bitset<max_bits> b(obj);
14252      _OUT << "\"";
14253      if (obj == 0) _OUT << "0";
14254      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14255          if (b[i] == 1) {
14256              bitCount++;
14257              if (bitCount < b.count())
14258                  _OUT << VkExternalMemoryHandleTypeFlagBits_map[1ULL<<i] << " | ";
14259              else
14260                  _OUT << VkExternalMemoryHandleTypeFlagBits_map[1ULL<<i];
14261          }
14262      }
14263      if (commaNeeded)
14264        _OUT << "\"" << ",";
14265      else
14266        _OUT << "\""<< "";
14267      _OUT << std::endl;
14268 }
14269 static void print_VkExternalMemoryHandleTypeFlags(const VkExternalMemoryHandleTypeFlags * obj, const std::string& str, bool commaNeeded=true) {
14270      PRINT_SPACE
14271      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14272      const int max_bits = 64; // We don't expect the number to be larger.
14273      std::bitset<max_bits> b(obj);
14274      _OUT << "\"";
14275      if (obj == 0) _OUT << "0";
14276      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14277          if (b[i] == 1) {
14278              bitCount++;
14279              if (bitCount < b.count())
14280                  _OUT << VkExternalMemoryHandleTypeFlagBits_map[1ULL<<i] << " | ";
14281              else
14282                  _OUT << VkExternalMemoryHandleTypeFlagBits_map[1ULL<<i];
14283          }
14284      }
14285      if (commaNeeded)
14286        _OUT << "\"" << ",";
14287      else
14288        _OUT << "\""<< "";
14289      _OUT << std::endl;
14290 }
14291
14292 static void print_VkExternalMemoryFeatureFlags(VkExternalMemoryFeatureFlags obj, const std::string& str, bool commaNeeded=true) {
14293      PRINT_SPACE
14294      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14295      const int max_bits = 64; // We don't expect the number to be larger.
14296      std::bitset<max_bits> b(obj);
14297      _OUT << "\"";
14298      if (obj == 0) _OUT << "0";
14299      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14300          if (b[i] == 1) {
14301              bitCount++;
14302              if (bitCount < b.count())
14303                  _OUT << VkExternalMemoryFeatureFlagBits_map[1ULL<<i] << " | ";
14304              else
14305                  _OUT << VkExternalMemoryFeatureFlagBits_map[1ULL<<i];
14306          }
14307      }
14308      if (commaNeeded)
14309        _OUT << "\"" << ",";
14310      else
14311        _OUT << "\""<< "";
14312      _OUT << std::endl;
14313 }
14314 static void print_VkExternalMemoryFeatureFlags(const VkExternalMemoryFeatureFlags * obj, const std::string& str, bool commaNeeded=true) {
14315      PRINT_SPACE
14316      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14317      const int max_bits = 64; // We don't expect the number to be larger.
14318      std::bitset<max_bits> b(obj);
14319      _OUT << "\"";
14320      if (obj == 0) _OUT << "0";
14321      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14322          if (b[i] == 1) {
14323              bitCount++;
14324              if (bitCount < b.count())
14325                  _OUT << VkExternalMemoryFeatureFlagBits_map[1ULL<<i] << " | ";
14326              else
14327                  _OUT << VkExternalMemoryFeatureFlagBits_map[1ULL<<i];
14328          }
14329      }
14330      if (commaNeeded)
14331        _OUT << "\"" << ",";
14332      else
14333        _OUT << "\""<< "";
14334      _OUT << std::endl;
14335 }
14336
14337 static void print_VkExternalFenceHandleTypeFlags(VkExternalFenceHandleTypeFlags obj, const std::string& str, bool commaNeeded=true) {
14338      PRINT_SPACE
14339      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14340      const int max_bits = 64; // We don't expect the number to be larger.
14341      std::bitset<max_bits> b(obj);
14342      _OUT << "\"";
14343      if (obj == 0) _OUT << "0";
14344      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14345          if (b[i] == 1) {
14346              bitCount++;
14347              if (bitCount < b.count())
14348                  _OUT << VkExternalFenceHandleTypeFlagBits_map[1ULL<<i] << " | ";
14349              else
14350                  _OUT << VkExternalFenceHandleTypeFlagBits_map[1ULL<<i];
14351          }
14352      }
14353      if (commaNeeded)
14354        _OUT << "\"" << ",";
14355      else
14356        _OUT << "\""<< "";
14357      _OUT << std::endl;
14358 }
14359 static void print_VkExternalFenceHandleTypeFlags(const VkExternalFenceHandleTypeFlags * obj, const std::string& str, bool commaNeeded=true) {
14360      PRINT_SPACE
14361      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14362      const int max_bits = 64; // We don't expect the number to be larger.
14363      std::bitset<max_bits> b(obj);
14364      _OUT << "\"";
14365      if (obj == 0) _OUT << "0";
14366      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14367          if (b[i] == 1) {
14368              bitCount++;
14369              if (bitCount < b.count())
14370                  _OUT << VkExternalFenceHandleTypeFlagBits_map[1ULL<<i] << " | ";
14371              else
14372                  _OUT << VkExternalFenceHandleTypeFlagBits_map[1ULL<<i];
14373          }
14374      }
14375      if (commaNeeded)
14376        _OUT << "\"" << ",";
14377      else
14378        _OUT << "\""<< "";
14379      _OUT << std::endl;
14380 }
14381
14382 static void print_VkExternalFenceFeatureFlags(VkExternalFenceFeatureFlags obj, const std::string& str, bool commaNeeded=true) {
14383      PRINT_SPACE
14384      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14385      const int max_bits = 64; // We don't expect the number to be larger.
14386      std::bitset<max_bits> b(obj);
14387      _OUT << "\"";
14388      if (obj == 0) _OUT << "0";
14389      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14390          if (b[i] == 1) {
14391              bitCount++;
14392              if (bitCount < b.count())
14393                  _OUT << VkExternalFenceFeatureFlagBits_map[1ULL<<i] << " | ";
14394              else
14395                  _OUT << VkExternalFenceFeatureFlagBits_map[1ULL<<i];
14396          }
14397      }
14398      if (commaNeeded)
14399        _OUT << "\"" << ",";
14400      else
14401        _OUT << "\""<< "";
14402      _OUT << std::endl;
14403 }
14404 static void print_VkExternalFenceFeatureFlags(const VkExternalFenceFeatureFlags * obj, const std::string& str, bool commaNeeded=true) {
14405      PRINT_SPACE
14406      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14407      const int max_bits = 64; // We don't expect the number to be larger.
14408      std::bitset<max_bits> b(obj);
14409      _OUT << "\"";
14410      if (obj == 0) _OUT << "0";
14411      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14412          if (b[i] == 1) {
14413              bitCount++;
14414              if (bitCount < b.count())
14415                  _OUT << VkExternalFenceFeatureFlagBits_map[1ULL<<i] << " | ";
14416              else
14417                  _OUT << VkExternalFenceFeatureFlagBits_map[1ULL<<i];
14418          }
14419      }
14420      if (commaNeeded)
14421        _OUT << "\"" << ",";
14422      else
14423        _OUT << "\""<< "";
14424      _OUT << std::endl;
14425 }
14426
14427 static void print_VkFenceImportFlags(VkFenceImportFlags obj, const std::string& str, bool commaNeeded=true) {
14428      PRINT_SPACE
14429      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14430      const int max_bits = 64; // We don't expect the number to be larger.
14431      std::bitset<max_bits> b(obj);
14432      _OUT << "\"";
14433      if (obj == 0) _OUT << "0";
14434      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14435          if (b[i] == 1) {
14436              bitCount++;
14437              if (bitCount < b.count())
14438                  _OUT << VkFenceImportFlagBits_map[1ULL<<i] << " | ";
14439              else
14440                  _OUT << VkFenceImportFlagBits_map[1ULL<<i];
14441          }
14442      }
14443      if (commaNeeded)
14444        _OUT << "\"" << ",";
14445      else
14446        _OUT << "\""<< "";
14447      _OUT << std::endl;
14448 }
14449 static void print_VkFenceImportFlags(const VkFenceImportFlags * obj, const std::string& str, bool commaNeeded=true) {
14450      PRINT_SPACE
14451      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14452      const int max_bits = 64; // We don't expect the number to be larger.
14453      std::bitset<max_bits> b(obj);
14454      _OUT << "\"";
14455      if (obj == 0) _OUT << "0";
14456      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14457          if (b[i] == 1) {
14458              bitCount++;
14459              if (bitCount < b.count())
14460                  _OUT << VkFenceImportFlagBits_map[1ULL<<i] << " | ";
14461              else
14462                  _OUT << VkFenceImportFlagBits_map[1ULL<<i];
14463          }
14464      }
14465      if (commaNeeded)
14466        _OUT << "\"" << ",";
14467      else
14468        _OUT << "\""<< "";
14469      _OUT << std::endl;
14470 }
14471
14472 static void print_VkSemaphoreImportFlags(VkSemaphoreImportFlags obj, const std::string& str, bool commaNeeded=true) {
14473      PRINT_SPACE
14474      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14475      const int max_bits = 64; // We don't expect the number to be larger.
14476      std::bitset<max_bits> b(obj);
14477      _OUT << "\"";
14478      if (obj == 0) _OUT << "0";
14479      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14480          if (b[i] == 1) {
14481              bitCount++;
14482              if (bitCount < b.count())
14483                  _OUT << VkSemaphoreImportFlagBits_map[1ULL<<i] << " | ";
14484              else
14485                  _OUT << VkSemaphoreImportFlagBits_map[1ULL<<i];
14486          }
14487      }
14488      if (commaNeeded)
14489        _OUT << "\"" << ",";
14490      else
14491        _OUT << "\""<< "";
14492      _OUT << std::endl;
14493 }
14494 static void print_VkSemaphoreImportFlags(const VkSemaphoreImportFlags * obj, const std::string& str, bool commaNeeded=true) {
14495      PRINT_SPACE
14496      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14497      const int max_bits = 64; // We don't expect the number to be larger.
14498      std::bitset<max_bits> b(obj);
14499      _OUT << "\"";
14500      if (obj == 0) _OUT << "0";
14501      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14502          if (b[i] == 1) {
14503              bitCount++;
14504              if (bitCount < b.count())
14505                  _OUT << VkSemaphoreImportFlagBits_map[1ULL<<i] << " | ";
14506              else
14507                  _OUT << VkSemaphoreImportFlagBits_map[1ULL<<i];
14508          }
14509      }
14510      if (commaNeeded)
14511        _OUT << "\"" << ",";
14512      else
14513        _OUT << "\""<< "";
14514      _OUT << std::endl;
14515 }
14516
14517 static void print_VkExternalSemaphoreHandleTypeFlags(VkExternalSemaphoreHandleTypeFlags obj, const std::string& str, bool commaNeeded=true) {
14518      PRINT_SPACE
14519      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14520      const int max_bits = 64; // We don't expect the number to be larger.
14521      std::bitset<max_bits> b(obj);
14522      _OUT << "\"";
14523      if (obj == 0) _OUT << "0";
14524      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14525          if (b[i] == 1) {
14526              bitCount++;
14527              if (bitCount < b.count())
14528                  _OUT << VkExternalSemaphoreHandleTypeFlagBits_map[1ULL<<i] << " | ";
14529              else
14530                  _OUT << VkExternalSemaphoreHandleTypeFlagBits_map[1ULL<<i];
14531          }
14532      }
14533      if (commaNeeded)
14534        _OUT << "\"" << ",";
14535      else
14536        _OUT << "\""<< "";
14537      _OUT << std::endl;
14538 }
14539 static void print_VkExternalSemaphoreHandleTypeFlags(const VkExternalSemaphoreHandleTypeFlags * obj, const std::string& str, bool commaNeeded=true) {
14540      PRINT_SPACE
14541      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14542      const int max_bits = 64; // We don't expect the number to be larger.
14543      std::bitset<max_bits> b(obj);
14544      _OUT << "\"";
14545      if (obj == 0) _OUT << "0";
14546      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14547          if (b[i] == 1) {
14548              bitCount++;
14549              if (bitCount < b.count())
14550                  _OUT << VkExternalSemaphoreHandleTypeFlagBits_map[1ULL<<i] << " | ";
14551              else
14552                  _OUT << VkExternalSemaphoreHandleTypeFlagBits_map[1ULL<<i];
14553          }
14554      }
14555      if (commaNeeded)
14556        _OUT << "\"" << ",";
14557      else
14558        _OUT << "\""<< "";
14559      _OUT << std::endl;
14560 }
14561
14562 static void print_VkExternalSemaphoreFeatureFlags(VkExternalSemaphoreFeatureFlags obj, const std::string& str, bool commaNeeded=true) {
14563      PRINT_SPACE
14564      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14565      const int max_bits = 64; // We don't expect the number to be larger.
14566      std::bitset<max_bits> b(obj);
14567      _OUT << "\"";
14568      if (obj == 0) _OUT << "0";
14569      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14570          if (b[i] == 1) {
14571              bitCount++;
14572              if (bitCount < b.count())
14573                  _OUT << VkExternalSemaphoreFeatureFlagBits_map[1ULL<<i] << " | ";
14574              else
14575                  _OUT << VkExternalSemaphoreFeatureFlagBits_map[1ULL<<i];
14576          }
14577      }
14578      if (commaNeeded)
14579        _OUT << "\"" << ",";
14580      else
14581        _OUT << "\""<< "";
14582      _OUT << std::endl;
14583 }
14584 static void print_VkExternalSemaphoreFeatureFlags(const VkExternalSemaphoreFeatureFlags * obj, const std::string& str, bool commaNeeded=true) {
14585      PRINT_SPACE
14586      if (str != "") _OUT << "\"" << str << "\"" << " : ";
14587      const int max_bits = 64; // We don't expect the number to be larger.
14588      std::bitset<max_bits> b(obj);
14589      _OUT << "\"";
14590      if (obj == 0) _OUT << "0";
14591      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
14592          if (b[i] == 1) {
14593              bitCount++;
14594              if (bitCount < b.count())
14595                  _OUT << VkExternalSemaphoreFeatureFlagBits_map[1ULL<<i] << " | ";
14596              else
14597                  _OUT << VkExternalSemaphoreFeatureFlagBits_map[1ULL<<i];
14598          }
14599      }
14600      if (commaNeeded)
14601        _OUT << "\"" << ",";
14602      else
14603        _OUT << "\""<< "";
14604      _OUT << std::endl;
14605 }
14606
14607 static void print_VkPhysicalDeviceSubgroupProperties(VkPhysicalDeviceSubgroupProperties obj, const std::string& s, bool commaNeeded=true) {
14608      PRINT_SPACE
14609      _OUT << "{" << std::endl;
14610      INDENT(4);
14611
14612      print_VkStructureType(obj.sType, "sType", 1);
14613
14614       if (obj.pNext) {
14615          dumpPNextChain(obj.pNext);
14616       } else {
14617          PRINT_SPACE
14618          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14619      }
14620
14621      print_uint32_t(obj.subgroupSize, "subgroupSize", 1);
14622
14623      print_VkShaderStageFlags(obj.supportedStages, "supportedStages", 1);
14624
14625      print_VkSubgroupFeatureFlags(obj.supportedOperations, "supportedOperations", 1);
14626
14627      print_VkBool32(obj.quadOperationsInAllStages, "quadOperationsInAllStages", 0);
14628
14629      INDENT(-4);
14630      PRINT_SPACE
14631      if (commaNeeded)
14632          _OUT << "}," << std::endl;
14633      else
14634          _OUT << "}" << std::endl;
14635 }
14636 static void print_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties * obj, const std::string& s, bool commaNeeded=true) {
14637      PRINT_SPACE
14638      _OUT << "{" << std::endl;
14639      INDENT(4);
14640
14641      print_VkStructureType(obj->sType, "sType", 1);
14642
14643       if (obj->pNext) {
14644          dumpPNextChain(obj->pNext);
14645       } else {
14646          PRINT_SPACE
14647          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14648      }
14649
14650      print_uint32_t(obj->subgroupSize, "subgroupSize", 1);
14651
14652      print_VkShaderStageFlags(obj->supportedStages, "supportedStages", 1);
14653
14654      print_VkSubgroupFeatureFlags(obj->supportedOperations, "supportedOperations", 1);
14655
14656      print_VkBool32(obj->quadOperationsInAllStages, "quadOperationsInAllStages", 0);
14657
14658      INDENT(-4);
14659      PRINT_SPACE
14660      if (commaNeeded)
14661          _OUT << "}," << std::endl;
14662      else
14663          _OUT << "}" << std::endl;
14664 }
14665
14666 static void print_VkBindBufferMemoryInfo(VkBindBufferMemoryInfo obj, const std::string& s, bool commaNeeded=true) {
14667      PRINT_SPACE
14668      _OUT << "{" << std::endl;
14669      INDENT(4);
14670
14671      print_VkStructureType(obj.sType, "sType", 1);
14672
14673       if (obj.pNext) {
14674          dumpPNextChain(obj.pNext);
14675       } else {
14676          PRINT_SPACE
14677          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14678      }
14679
14680      // CTS : required value
14681      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl;
14682
14683      // CTS : required value
14684      PRINT_SPACE    _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl;
14685
14686      print_VkDeviceSize(obj.memoryOffset, "memoryOffset", 0);
14687
14688      INDENT(-4);
14689      PRINT_SPACE
14690      if (commaNeeded)
14691          _OUT << "}," << std::endl;
14692      else
14693          _OUT << "}" << std::endl;
14694 }
14695 static void print_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo * obj, const std::string& s, bool commaNeeded=true) {
14696      PRINT_SPACE
14697      _OUT << "{" << std::endl;
14698      INDENT(4);
14699
14700      print_VkStructureType(obj->sType, "sType", 1);
14701
14702       if (obj->pNext) {
14703          dumpPNextChain(obj->pNext);
14704       } else {
14705          PRINT_SPACE
14706          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14707      }
14708
14709      // CTS : required value
14710      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl;
14711
14712      // CTS : required value
14713      PRINT_SPACE    _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl;
14714
14715      print_VkDeviceSize(obj->memoryOffset, "memoryOffset", 0);
14716
14717      INDENT(-4);
14718      PRINT_SPACE
14719      if (commaNeeded)
14720          _OUT << "}," << std::endl;
14721      else
14722          _OUT << "}" << std::endl;
14723 }
14724
14725 static void print_VkBindImageMemoryInfo(VkBindImageMemoryInfo obj, const std::string& s, bool commaNeeded=true) {
14726      PRINT_SPACE
14727      _OUT << "{" << std::endl;
14728      INDENT(4);
14729
14730      print_VkStructureType(obj.sType, "sType", 1);
14731
14732       if (obj.pNext) {
14733          dumpPNextChain(obj.pNext);
14734       } else {
14735          PRINT_SPACE
14736          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14737      }
14738
14739      // CTS : required value
14740      PRINT_SPACE    _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl;
14741
14742      // CTS : required value
14743      PRINT_SPACE    _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl;
14744
14745      print_VkDeviceSize(obj.memoryOffset, "memoryOffset", 0);
14746
14747      INDENT(-4);
14748      PRINT_SPACE
14749      if (commaNeeded)
14750          _OUT << "}," << std::endl;
14751      else
14752          _OUT << "}" << std::endl;
14753 }
14754 static void print_VkBindImageMemoryInfo(const VkBindImageMemoryInfo * obj, const std::string& s, bool commaNeeded=true) {
14755      PRINT_SPACE
14756      _OUT << "{" << std::endl;
14757      INDENT(4);
14758
14759      print_VkStructureType(obj->sType, "sType", 1);
14760
14761       if (obj->pNext) {
14762          dumpPNextChain(obj->pNext);
14763       } else {
14764          PRINT_SPACE
14765          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14766      }
14767
14768      // CTS : required value
14769      PRINT_SPACE    _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl;
14770
14771      // CTS : required value
14772      PRINT_SPACE    _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl;
14773
14774      print_VkDeviceSize(obj->memoryOffset, "memoryOffset", 0);
14775
14776      INDENT(-4);
14777      PRINT_SPACE
14778      if (commaNeeded)
14779          _OUT << "}," << std::endl;
14780      else
14781          _OUT << "}" << std::endl;
14782 }
14783
14784 static void print_VkPhysicalDevice16BitStorageFeatures(VkPhysicalDevice16BitStorageFeatures obj, const std::string& s, bool commaNeeded=true) {
14785      PRINT_SPACE
14786      _OUT << "{" << std::endl;
14787      INDENT(4);
14788
14789      print_VkStructureType(obj.sType, "sType", 1);
14790
14791       if (obj.pNext) {
14792          dumpPNextChain(obj.pNext);
14793       } else {
14794          PRINT_SPACE
14795          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14796      }
14797
14798      print_VkBool32(obj.storageBuffer16BitAccess, "storageBuffer16BitAccess", 1);
14799
14800      print_VkBool32(obj.uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1);
14801
14802      print_VkBool32(obj.storagePushConstant16, "storagePushConstant16", 1);
14803
14804      print_VkBool32(obj.storageInputOutput16, "storageInputOutput16", 0);
14805
14806      INDENT(-4);
14807      PRINT_SPACE
14808      if (commaNeeded)
14809          _OUT << "}," << std::endl;
14810      else
14811          _OUT << "}" << std::endl;
14812 }
14813 static void print_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures * obj, const std::string& s, bool commaNeeded=true) {
14814      PRINT_SPACE
14815      _OUT << "{" << std::endl;
14816      INDENT(4);
14817
14818      print_VkStructureType(obj->sType, "sType", 1);
14819
14820       if (obj->pNext) {
14821          dumpPNextChain(obj->pNext);
14822       } else {
14823          PRINT_SPACE
14824          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14825      }
14826
14827      print_VkBool32(obj->storageBuffer16BitAccess, "storageBuffer16BitAccess", 1);
14828
14829      print_VkBool32(obj->uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1);
14830
14831      print_VkBool32(obj->storagePushConstant16, "storagePushConstant16", 1);
14832
14833      print_VkBool32(obj->storageInputOutput16, "storageInputOutput16", 0);
14834
14835      INDENT(-4);
14836      PRINT_SPACE
14837      if (commaNeeded)
14838          _OUT << "}," << std::endl;
14839      else
14840          _OUT << "}" << std::endl;
14841 }
14842
14843 static void print_VkMemoryDedicatedRequirements(VkMemoryDedicatedRequirements obj, const std::string& s, bool commaNeeded=true) {
14844      PRINT_SPACE
14845      _OUT << "{" << std::endl;
14846      INDENT(4);
14847
14848      print_VkStructureType(obj.sType, "sType", 1);
14849
14850       if (obj.pNext) {
14851          dumpPNextChain(obj.pNext);
14852       } else {
14853          PRINT_SPACE
14854          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14855      }
14856
14857      print_VkBool32(obj.prefersDedicatedAllocation, "prefersDedicatedAllocation", 1);
14858
14859      print_VkBool32(obj.requiresDedicatedAllocation, "requiresDedicatedAllocation", 0);
14860
14861      INDENT(-4);
14862      PRINT_SPACE
14863      if (commaNeeded)
14864          _OUT << "}," << std::endl;
14865      else
14866          _OUT << "}" << std::endl;
14867 }
14868 static void print_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements * obj, const std::string& s, bool commaNeeded=true) {
14869      PRINT_SPACE
14870      _OUT << "{" << std::endl;
14871      INDENT(4);
14872
14873      print_VkStructureType(obj->sType, "sType", 1);
14874
14875       if (obj->pNext) {
14876          dumpPNextChain(obj->pNext);
14877       } else {
14878          PRINT_SPACE
14879          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14880      }
14881
14882      print_VkBool32(obj->prefersDedicatedAllocation, "prefersDedicatedAllocation", 1);
14883
14884      print_VkBool32(obj->requiresDedicatedAllocation, "requiresDedicatedAllocation", 0);
14885
14886      INDENT(-4);
14887      PRINT_SPACE
14888      if (commaNeeded)
14889          _OUT << "}," << std::endl;
14890      else
14891          _OUT << "}" << std::endl;
14892 }
14893
14894 static void print_VkMemoryDedicatedAllocateInfo(VkMemoryDedicatedAllocateInfo obj, const std::string& s, bool commaNeeded=true) {
14895      PRINT_SPACE
14896      _OUT << "{" << std::endl;
14897      INDENT(4);
14898
14899      print_VkStructureType(obj.sType, "sType", 1);
14900
14901       if (obj.pNext) {
14902          dumpPNextChain(obj.pNext);
14903       } else {
14904          PRINT_SPACE
14905          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14906      }
14907
14908      // CTS : required value
14909      PRINT_SPACE    _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl;
14910
14911      // CTS : required value
14912      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"" << std::endl;
14913
14914      INDENT(-4);
14915      PRINT_SPACE
14916      if (commaNeeded)
14917          _OUT << "}," << std::endl;
14918      else
14919          _OUT << "}" << std::endl;
14920 }
14921 static void print_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo * obj, const std::string& s, bool commaNeeded=true) {
14922      PRINT_SPACE
14923      _OUT << "{" << std::endl;
14924      INDENT(4);
14925
14926      print_VkStructureType(obj->sType, "sType", 1);
14927
14928       if (obj->pNext) {
14929          dumpPNextChain(obj->pNext);
14930       } else {
14931          PRINT_SPACE
14932          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14933      }
14934
14935      // CTS : required value
14936      PRINT_SPACE    _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl;
14937
14938      // CTS : required value
14939      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"" << std::endl;
14940
14941      INDENT(-4);
14942      PRINT_SPACE
14943      if (commaNeeded)
14944          _OUT << "}," << std::endl;
14945      else
14946          _OUT << "}" << std::endl;
14947 }
14948
14949 static void print_VkMemoryAllocateFlagsInfo(VkMemoryAllocateFlagsInfo obj, const std::string& s, bool commaNeeded=true) {
14950      PRINT_SPACE
14951      _OUT << "{" << std::endl;
14952      INDENT(4);
14953
14954      print_VkStructureType(obj.sType, "sType", 1);
14955
14956       if (obj.pNext) {
14957          dumpPNextChain(obj.pNext);
14958       } else {
14959          PRINT_SPACE
14960          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14961      }
14962
14963      print_VkMemoryAllocateFlags(obj.flags, "flags", 1);
14964
14965      print_uint32_t(obj.deviceMask, "deviceMask", 0);
14966
14967      INDENT(-4);
14968      PRINT_SPACE
14969      if (commaNeeded)
14970          _OUT << "}," << std::endl;
14971      else
14972          _OUT << "}" << std::endl;
14973 }
14974 static void print_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo * obj, const std::string& s, bool commaNeeded=true) {
14975      PRINT_SPACE
14976      _OUT << "{" << std::endl;
14977      INDENT(4);
14978
14979      print_VkStructureType(obj->sType, "sType", 1);
14980
14981       if (obj->pNext) {
14982          dumpPNextChain(obj->pNext);
14983       } else {
14984          PRINT_SPACE
14985          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
14986      }
14987
14988      print_VkMemoryAllocateFlags(obj->flags, "flags", 1);
14989
14990      print_uint32_t(obj->deviceMask, "deviceMask", 0);
14991
14992      INDENT(-4);
14993      PRINT_SPACE
14994      if (commaNeeded)
14995          _OUT << "}," << std::endl;
14996      else
14997          _OUT << "}" << std::endl;
14998 }
14999
15000 static void print_VkDeviceGroupRenderPassBeginInfo(VkDeviceGroupRenderPassBeginInfo obj, const std::string& s, bool commaNeeded=true) {
15001      PRINT_SPACE
15002      _OUT << "{" << std::endl;
15003      INDENT(4);
15004
15005      print_VkStructureType(obj.sType, "sType", 1);
15006
15007       if (obj.pNext) {
15008          dumpPNextChain(obj.pNext);
15009       } else {
15010          PRINT_SPACE
15011          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15012      }
15013
15014      print_uint32_t(obj.deviceMask, "deviceMask", 1);
15015
15016      print_uint32_t(obj.deviceRenderAreaCount, "deviceRenderAreaCount", 1);
15017
15018      PRINT_SPACE
15019      _OUT << "\"pDeviceRenderAreas\": " << std::endl;
15020      if (obj.pDeviceRenderAreas) {
15021          PRINT_SPACE
15022          _OUT << "[" << std::endl;
15023          for (unsigned int i = 0; i < obj.deviceRenderAreaCount; i++) {
15024            if (i+1 == obj.deviceRenderAreaCount)
15025                print_VkRect2D(obj.pDeviceRenderAreas[i], "pDeviceRenderAreas", 0);
15026            else
15027                print_VkRect2D(obj.pDeviceRenderAreas[i], "pDeviceRenderAreas", 1);
15028          }
15029          PRINT_SPACE
15030          _OUT << "]" << std::endl;
15031     }
15032      else
15033      {
15034          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
15035      }
15036
15037      INDENT(-4);
15038      PRINT_SPACE
15039      if (commaNeeded)
15040          _OUT << "}," << std::endl;
15041      else
15042          _OUT << "}" << std::endl;
15043 }
15044 static void print_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo * obj, const std::string& s, bool commaNeeded=true) {
15045      PRINT_SPACE
15046      _OUT << "{" << std::endl;
15047      INDENT(4);
15048
15049      print_VkStructureType(obj->sType, "sType", 1);
15050
15051       if (obj->pNext) {
15052          dumpPNextChain(obj->pNext);
15053       } else {
15054          PRINT_SPACE
15055          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15056      }
15057
15058      print_uint32_t(obj->deviceMask, "deviceMask", 1);
15059
15060      print_uint32_t(obj->deviceRenderAreaCount, "deviceRenderAreaCount", 1);
15061
15062      PRINT_SPACE
15063      _OUT << "\"pDeviceRenderAreas\": " << std::endl;
15064      if (obj->pDeviceRenderAreas) {
15065          PRINT_SPACE
15066          _OUT << "[" << std::endl;
15067          for (unsigned int i = 0; i < obj->deviceRenderAreaCount; i++) {
15068            if (i+1 == obj->deviceRenderAreaCount)
15069                print_VkRect2D(obj->pDeviceRenderAreas[i], "pDeviceRenderAreas", 0);
15070            else
15071                print_VkRect2D(obj->pDeviceRenderAreas[i], "pDeviceRenderAreas", 1);
15072          }
15073          PRINT_SPACE
15074          _OUT << "]" << std::endl;
15075     }
15076      else
15077      {
15078          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
15079      }
15080
15081      INDENT(-4);
15082      PRINT_SPACE
15083      if (commaNeeded)
15084          _OUT << "}," << std::endl;
15085      else
15086          _OUT << "}" << std::endl;
15087 }
15088
15089 static void print_VkDeviceGroupCommandBufferBeginInfo(VkDeviceGroupCommandBufferBeginInfo obj, const std::string& s, bool commaNeeded=true) {
15090      PRINT_SPACE
15091      _OUT << "{" << std::endl;
15092      INDENT(4);
15093
15094      print_VkStructureType(obj.sType, "sType", 1);
15095
15096       if (obj.pNext) {
15097          dumpPNextChain(obj.pNext);
15098       } else {
15099          PRINT_SPACE
15100          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15101      }
15102
15103      print_uint32_t(obj.deviceMask, "deviceMask", 0);
15104
15105      INDENT(-4);
15106      PRINT_SPACE
15107      if (commaNeeded)
15108          _OUT << "}," << std::endl;
15109      else
15110          _OUT << "}" << std::endl;
15111 }
15112 static void print_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo * obj, const std::string& s, bool commaNeeded=true) {
15113      PRINT_SPACE
15114      _OUT << "{" << std::endl;
15115      INDENT(4);
15116
15117      print_VkStructureType(obj->sType, "sType", 1);
15118
15119       if (obj->pNext) {
15120          dumpPNextChain(obj->pNext);
15121       } else {
15122          PRINT_SPACE
15123          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15124      }
15125
15126      print_uint32_t(obj->deviceMask, "deviceMask", 0);
15127
15128      INDENT(-4);
15129      PRINT_SPACE
15130      if (commaNeeded)
15131          _OUT << "}," << std::endl;
15132      else
15133          _OUT << "}" << std::endl;
15134 }
15135
15136 static void print_VkDeviceGroupSubmitInfo(VkDeviceGroupSubmitInfo obj, const std::string& s, bool commaNeeded=true) {
15137      PRINT_SPACE
15138      _OUT << "{" << std::endl;
15139      INDENT(4);
15140
15141      print_VkStructureType(obj.sType, "sType", 1);
15142
15143       if (obj.pNext) {
15144          dumpPNextChain(obj.pNext);
15145       } else {
15146          PRINT_SPACE
15147          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15148      }
15149
15150      print_uint32_t(obj.waitSemaphoreCount, "waitSemaphoreCount", 1);
15151
15152      PRINT_SPACE
15153      _OUT << "\"pWaitSemaphoreDeviceIndices\":" << std::endl;
15154      PRINT_SPACE
15155      if (obj.pWaitSemaphoreDeviceIndices) {
15156        _OUT << "[" << std::endl;
15157        for (unsigned int i = 0; i < obj.waitSemaphoreCount; i++) {
15158            bool isCommaNeeded = (i+1) != obj.waitSemaphoreCount;
15159            print_uint32_t(obj.pWaitSemaphoreDeviceIndices[i], "", isCommaNeeded);
15160        }
15161        PRINT_SPACE
15162        _OUT << "]" << "," << std::endl;
15163      } else {
15164        _OUT << "\"NULL\"" << "," << std::endl;
15165      }
15166
15167      print_uint32_t(obj.commandBufferCount, "commandBufferCount", 1);
15168
15169      PRINT_SPACE
15170      _OUT << "\"pCommandBufferDeviceMasks\":" << std::endl;
15171      PRINT_SPACE
15172      if (obj.pCommandBufferDeviceMasks) {
15173        _OUT << "[" << std::endl;
15174        for (unsigned int i = 0; i < obj.commandBufferCount; i++) {
15175            bool isCommaNeeded = (i+1) != obj.commandBufferCount;
15176            print_uint32_t(obj.pCommandBufferDeviceMasks[i], "", isCommaNeeded);
15177        }
15178        PRINT_SPACE
15179        _OUT << "]" << "," << std::endl;
15180      } else {
15181        _OUT << "\"NULL\"" << "," << std::endl;
15182      }
15183
15184      print_uint32_t(obj.signalSemaphoreCount, "signalSemaphoreCount", 1);
15185
15186      PRINT_SPACE
15187      _OUT << "\"pSignalSemaphoreDeviceIndices\":" << std::endl;
15188      PRINT_SPACE
15189      if (obj.pSignalSemaphoreDeviceIndices) {
15190        _OUT << "[" << std::endl;
15191        for (unsigned int i = 0; i < obj.signalSemaphoreCount; i++) {
15192            bool isCommaNeeded = (i+1) != obj.signalSemaphoreCount;
15193            print_uint32_t(obj.pSignalSemaphoreDeviceIndices[i], "", isCommaNeeded);
15194        }
15195        PRINT_SPACE
15196        _OUT << "]" << "" << std::endl;
15197      } else {
15198        _OUT << "\"NULL\"" << "" << std::endl;
15199      }
15200
15201      INDENT(-4);
15202      PRINT_SPACE
15203      if (commaNeeded)
15204          _OUT << "}," << std::endl;
15205      else
15206          _OUT << "}" << std::endl;
15207 }
15208 static void print_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo * obj, const std::string& s, bool commaNeeded=true) {
15209      PRINT_SPACE
15210      _OUT << "{" << std::endl;
15211      INDENT(4);
15212
15213      print_VkStructureType(obj->sType, "sType", 1);
15214
15215       if (obj->pNext) {
15216          dumpPNextChain(obj->pNext);
15217       } else {
15218          PRINT_SPACE
15219          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15220      }
15221
15222      print_uint32_t(obj->waitSemaphoreCount, "waitSemaphoreCount", 1);
15223
15224      PRINT_SPACE
15225      _OUT << "\"pWaitSemaphoreDeviceIndices\":" << std::endl;
15226      PRINT_SPACE
15227      if (obj->pWaitSemaphoreDeviceIndices) {
15228        _OUT << "[" << std::endl;
15229        for (unsigned int i = 0; i < obj->waitSemaphoreCount; i++) {
15230            bool isCommaNeeded = (i+1) != obj->waitSemaphoreCount;
15231            print_uint32_t(obj->pWaitSemaphoreDeviceIndices[i], "", isCommaNeeded);
15232        }
15233        PRINT_SPACE
15234        _OUT << "]" << "," << std::endl;
15235      } else {
15236        _OUT << "\"NULL\"" << "," << std::endl;
15237      }
15238
15239      print_uint32_t(obj->commandBufferCount, "commandBufferCount", 1);
15240
15241      PRINT_SPACE
15242      _OUT << "\"pCommandBufferDeviceMasks\":" << std::endl;
15243      PRINT_SPACE
15244      if (obj->pCommandBufferDeviceMasks) {
15245        _OUT << "[" << std::endl;
15246        for (unsigned int i = 0; i < obj->commandBufferCount; i++) {
15247            bool isCommaNeeded = (i+1) != obj->commandBufferCount;
15248            print_uint32_t(obj->pCommandBufferDeviceMasks[i], "", isCommaNeeded);
15249        }
15250        PRINT_SPACE
15251        _OUT << "]" << "," << std::endl;
15252      } else {
15253        _OUT << "\"NULL\"" << "," << std::endl;
15254      }
15255
15256      print_uint32_t(obj->signalSemaphoreCount, "signalSemaphoreCount", 1);
15257
15258      PRINT_SPACE
15259      _OUT << "\"pSignalSemaphoreDeviceIndices\":" << std::endl;
15260      PRINT_SPACE
15261      if (obj->pSignalSemaphoreDeviceIndices) {
15262        _OUT << "[" << std::endl;
15263        for (unsigned int i = 0; i < obj->signalSemaphoreCount; i++) {
15264            bool isCommaNeeded = (i+1) != obj->signalSemaphoreCount;
15265            print_uint32_t(obj->pSignalSemaphoreDeviceIndices[i], "", isCommaNeeded);
15266        }
15267        PRINT_SPACE
15268        _OUT << "]" << "" << std::endl;
15269      } else {
15270        _OUT << "\"NULL\"" << "" << std::endl;
15271      }
15272
15273      INDENT(-4);
15274      PRINT_SPACE
15275      if (commaNeeded)
15276          _OUT << "}," << std::endl;
15277      else
15278          _OUT << "}" << std::endl;
15279 }
15280
15281 static void print_VkBindBufferMemoryDeviceGroupInfo(VkBindBufferMemoryDeviceGroupInfo obj, const std::string& s, bool commaNeeded=true) {
15282      PRINT_SPACE
15283      _OUT << "{" << std::endl;
15284      INDENT(4);
15285
15286      print_VkStructureType(obj.sType, "sType", 1);
15287
15288       if (obj.pNext) {
15289          dumpPNextChain(obj.pNext);
15290       } else {
15291          PRINT_SPACE
15292          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15293      }
15294
15295      print_uint32_t(obj.deviceIndexCount, "deviceIndexCount", 1);
15296
15297      PRINT_SPACE
15298      _OUT << "\"pDeviceIndices\":" << std::endl;
15299      PRINT_SPACE
15300      if (obj.pDeviceIndices) {
15301        _OUT << "[" << std::endl;
15302        for (unsigned int i = 0; i < obj.deviceIndexCount; i++) {
15303            bool isCommaNeeded = (i+1) != obj.deviceIndexCount;
15304            print_uint32_t(obj.pDeviceIndices[i], "", isCommaNeeded);
15305        }
15306        PRINT_SPACE
15307        _OUT << "]" << "" << std::endl;
15308      } else {
15309        _OUT << "\"NULL\"" << "" << std::endl;
15310      }
15311
15312      INDENT(-4);
15313      PRINT_SPACE
15314      if (commaNeeded)
15315          _OUT << "}," << std::endl;
15316      else
15317          _OUT << "}" << std::endl;
15318 }
15319 static void print_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo * obj, const std::string& s, bool commaNeeded=true) {
15320      PRINT_SPACE
15321      _OUT << "{" << std::endl;
15322      INDENT(4);
15323
15324      print_VkStructureType(obj->sType, "sType", 1);
15325
15326       if (obj->pNext) {
15327          dumpPNextChain(obj->pNext);
15328       } else {
15329          PRINT_SPACE
15330          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15331      }
15332
15333      print_uint32_t(obj->deviceIndexCount, "deviceIndexCount", 1);
15334
15335      PRINT_SPACE
15336      _OUT << "\"pDeviceIndices\":" << std::endl;
15337      PRINT_SPACE
15338      if (obj->pDeviceIndices) {
15339        _OUT << "[" << std::endl;
15340        for (unsigned int i = 0; i < obj->deviceIndexCount; i++) {
15341            bool isCommaNeeded = (i+1) != obj->deviceIndexCount;
15342            print_uint32_t(obj->pDeviceIndices[i], "", isCommaNeeded);
15343        }
15344        PRINT_SPACE
15345        _OUT << "]" << "" << std::endl;
15346      } else {
15347        _OUT << "\"NULL\"" << "" << std::endl;
15348      }
15349
15350      INDENT(-4);
15351      PRINT_SPACE
15352      if (commaNeeded)
15353          _OUT << "}," << std::endl;
15354      else
15355          _OUT << "}" << std::endl;
15356 }
15357
15358 static void print_VkBindImageMemoryDeviceGroupInfo(VkBindImageMemoryDeviceGroupInfo obj, const std::string& s, bool commaNeeded=true) {
15359      PRINT_SPACE
15360      _OUT << "{" << std::endl;
15361      INDENT(4);
15362
15363      print_VkStructureType(obj.sType, "sType", 1);
15364
15365       if (obj.pNext) {
15366          dumpPNextChain(obj.pNext);
15367       } else {
15368          PRINT_SPACE
15369          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15370      }
15371
15372      print_uint32_t(obj.deviceIndexCount, "deviceIndexCount", 1);
15373
15374      PRINT_SPACE
15375      _OUT << "\"pDeviceIndices\":" << std::endl;
15376      PRINT_SPACE
15377      if (obj.pDeviceIndices) {
15378        _OUT << "[" << std::endl;
15379        for (unsigned int i = 0; i < obj.deviceIndexCount; i++) {
15380            bool isCommaNeeded = (i+1) != obj.deviceIndexCount;
15381            print_uint32_t(obj.pDeviceIndices[i], "", isCommaNeeded);
15382        }
15383        PRINT_SPACE
15384        _OUT << "]" << "," << std::endl;
15385      } else {
15386        _OUT << "\"NULL\"" << "," << std::endl;
15387      }
15388
15389      print_uint32_t(obj.splitInstanceBindRegionCount, "splitInstanceBindRegionCount", 1);
15390
15391      PRINT_SPACE
15392      _OUT << "\"pSplitInstanceBindRegions\": " << std::endl;
15393      if (obj.pSplitInstanceBindRegions) {
15394          PRINT_SPACE
15395          _OUT << "[" << std::endl;
15396          for (unsigned int i = 0; i < obj.splitInstanceBindRegionCount; i++) {
15397            if (i+1 == obj.splitInstanceBindRegionCount)
15398                print_VkRect2D(obj.pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 0);
15399            else
15400                print_VkRect2D(obj.pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 1);
15401          }
15402          PRINT_SPACE
15403          _OUT << "]" << std::endl;
15404     }
15405      else
15406      {
15407          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
15408      }
15409
15410      INDENT(-4);
15411      PRINT_SPACE
15412      if (commaNeeded)
15413          _OUT << "}," << std::endl;
15414      else
15415          _OUT << "}" << std::endl;
15416 }
15417 static void print_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo * obj, const std::string& s, bool commaNeeded=true) {
15418      PRINT_SPACE
15419      _OUT << "{" << std::endl;
15420      INDENT(4);
15421
15422      print_VkStructureType(obj->sType, "sType", 1);
15423
15424       if (obj->pNext) {
15425          dumpPNextChain(obj->pNext);
15426       } else {
15427          PRINT_SPACE
15428          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15429      }
15430
15431      print_uint32_t(obj->deviceIndexCount, "deviceIndexCount", 1);
15432
15433      PRINT_SPACE
15434      _OUT << "\"pDeviceIndices\":" << std::endl;
15435      PRINT_SPACE
15436      if (obj->pDeviceIndices) {
15437        _OUT << "[" << std::endl;
15438        for (unsigned int i = 0; i < obj->deviceIndexCount; i++) {
15439            bool isCommaNeeded = (i+1) != obj->deviceIndexCount;
15440            print_uint32_t(obj->pDeviceIndices[i], "", isCommaNeeded);
15441        }
15442        PRINT_SPACE
15443        _OUT << "]" << "," << std::endl;
15444      } else {
15445        _OUT << "\"NULL\"" << "," << std::endl;
15446      }
15447
15448      print_uint32_t(obj->splitInstanceBindRegionCount, "splitInstanceBindRegionCount", 1);
15449
15450      PRINT_SPACE
15451      _OUT << "\"pSplitInstanceBindRegions\": " << std::endl;
15452      if (obj->pSplitInstanceBindRegions) {
15453          PRINT_SPACE
15454          _OUT << "[" << std::endl;
15455          for (unsigned int i = 0; i < obj->splitInstanceBindRegionCount; i++) {
15456            if (i+1 == obj->splitInstanceBindRegionCount)
15457                print_VkRect2D(obj->pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 0);
15458            else
15459                print_VkRect2D(obj->pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 1);
15460          }
15461          PRINT_SPACE
15462          _OUT << "]" << std::endl;
15463     }
15464      else
15465      {
15466          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
15467      }
15468
15469      INDENT(-4);
15470      PRINT_SPACE
15471      if (commaNeeded)
15472          _OUT << "}," << std::endl;
15473      else
15474          _OUT << "}" << std::endl;
15475 }
15476
15477 static void print_VkPhysicalDeviceGroupProperties(VkPhysicalDeviceGroupProperties obj, const std::string& s, bool commaNeeded=true) {
15478      PRINT_SPACE
15479      _OUT << "{" << std::endl;
15480      INDENT(4);
15481
15482      print_VkStructureType(obj.sType, "sType", 1);
15483
15484       if (obj.pNext) {
15485          dumpPNextChain(obj.pNext);
15486       } else {
15487          PRINT_SPACE
15488          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15489      }
15490
15491      print_uint32_t(obj.physicalDeviceCount, "physicalDeviceCount", 1);
15492
15493      PRINT_SPACE
15494      _OUT << "\"physicalDevices\":" << std::endl;
15495      PRINT_SPACE
15496      if (obj.physicalDevices) {
15497        _OUT << "[" << std::endl;
15498        for (unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) {
15499            std:: stringstream tmp;
15500            tmp << "physicalDevices" << "_" << i;
15501            bool isCommaNeeded = (i+1) != VK_MAX_DEVICE_GROUP_SIZE;
15502            print_VkPhysicalDevice(obj.physicalDevices[i], tmp.str(), isCommaNeeded);
15503        }
15504        PRINT_SPACE
15505        _OUT << "]" << "," << std::endl;
15506      } else {
15507        _OUT << "\"NULL\"" << "," << std::endl;
15508      }
15509
15510      print_VkBool32(obj.subsetAllocation, "subsetAllocation", 0);
15511
15512      INDENT(-4);
15513      PRINT_SPACE
15514      if (commaNeeded)
15515          _OUT << "}," << std::endl;
15516      else
15517          _OUT << "}" << std::endl;
15518 }
15519 static void print_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties * obj, const std::string& s, bool commaNeeded=true) {
15520      PRINT_SPACE
15521      _OUT << "{" << std::endl;
15522      INDENT(4);
15523
15524      print_VkStructureType(obj->sType, "sType", 1);
15525
15526       if (obj->pNext) {
15527          dumpPNextChain(obj->pNext);
15528       } else {
15529          PRINT_SPACE
15530          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15531      }
15532
15533      print_uint32_t(obj->physicalDeviceCount, "physicalDeviceCount", 1);
15534
15535      PRINT_SPACE
15536      _OUT << "\"physicalDevices\":" << std::endl;
15537      PRINT_SPACE
15538      if (obj->physicalDevices) {
15539        _OUT << "[" << std::endl;
15540        for (unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) {
15541            std:: stringstream tmp;
15542            tmp << "physicalDevices" << "_" << i;
15543            bool isCommaNeeded = (i+1) != VK_MAX_DEVICE_GROUP_SIZE;
15544            print_VkPhysicalDevice(obj->physicalDevices[i], tmp.str(), isCommaNeeded);
15545        }
15546        PRINT_SPACE
15547        _OUT << "]" << "," << std::endl;
15548      } else {
15549        _OUT << "\"NULL\"" << "," << std::endl;
15550      }
15551
15552      print_VkBool32(obj->subsetAllocation, "subsetAllocation", 0);
15553
15554      INDENT(-4);
15555      PRINT_SPACE
15556      if (commaNeeded)
15557          _OUT << "}," << std::endl;
15558      else
15559          _OUT << "}" << std::endl;
15560 }
15561
15562 static void print_VkDeviceGroupDeviceCreateInfo(VkDeviceGroupDeviceCreateInfo obj, const std::string& s, bool commaNeeded=true) {
15563      PRINT_SPACE
15564      _OUT << "{" << std::endl;
15565      INDENT(4);
15566
15567      print_VkStructureType(obj.sType, "sType", 1);
15568
15569       if (obj.pNext) {
15570          dumpPNextChain(obj.pNext);
15571       } else {
15572          PRINT_SPACE
15573          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15574      }
15575
15576      print_uint32_t(obj.physicalDeviceCount, "physicalDeviceCount", 1);
15577
15578      PRINT_SPACE
15579      _OUT << "\"pPhysicalDevices\":" << std::endl;
15580      PRINT_SPACE
15581      if (obj.pPhysicalDevices) {
15582        _OUT << "[" << std::endl;
15583        for (unsigned int i = 0; i < obj.physicalDeviceCount; i++) {
15584            std:: stringstream tmp;
15585            tmp << "pPhysicalDevices" << "_" << i;
15586            bool isCommaNeeded = (i+1) != obj.physicalDeviceCount;
15587            print_VkPhysicalDevice(obj.pPhysicalDevices[i], tmp.str(), isCommaNeeded);
15588        }
15589        PRINT_SPACE
15590        _OUT << "]" << "" << std::endl;
15591      } else {
15592        _OUT << "\"NULL\"" << "" << std::endl;
15593      }
15594
15595      INDENT(-4);
15596      PRINT_SPACE
15597      if (commaNeeded)
15598          _OUT << "}," << std::endl;
15599      else
15600          _OUT << "}" << std::endl;
15601 }
15602 static void print_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
15603      PRINT_SPACE
15604      _OUT << "{" << std::endl;
15605      INDENT(4);
15606
15607      print_VkStructureType(obj->sType, "sType", 1);
15608
15609       if (obj->pNext) {
15610          dumpPNextChain(obj->pNext);
15611       } else {
15612          PRINT_SPACE
15613          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15614      }
15615
15616      print_uint32_t(obj->physicalDeviceCount, "physicalDeviceCount", 1);
15617
15618      PRINT_SPACE
15619      _OUT << "\"pPhysicalDevices\":" << std::endl;
15620      PRINT_SPACE
15621      if (obj->pPhysicalDevices) {
15622        _OUT << "[" << std::endl;
15623        for (unsigned int i = 0; i < obj->physicalDeviceCount; i++) {
15624            std:: stringstream tmp;
15625            tmp << "pPhysicalDevices" << "_" << i;
15626            bool isCommaNeeded = (i+1) != obj->physicalDeviceCount;
15627            print_VkPhysicalDevice(obj->pPhysicalDevices[i], tmp.str(), isCommaNeeded);
15628        }
15629        PRINT_SPACE
15630        _OUT << "]" << "" << std::endl;
15631      } else {
15632        _OUT << "\"NULL\"" << "" << std::endl;
15633      }
15634
15635      INDENT(-4);
15636      PRINT_SPACE
15637      if (commaNeeded)
15638          _OUT << "}," << std::endl;
15639      else
15640          _OUT << "}" << std::endl;
15641 }
15642
15643 static void print_VkBufferMemoryRequirementsInfo2(VkBufferMemoryRequirementsInfo2 obj, const std::string& s, bool commaNeeded=true) {
15644      PRINT_SPACE
15645      _OUT << "{" << std::endl;
15646      INDENT(4);
15647
15648      print_VkStructureType(obj.sType, "sType", 1);
15649
15650       if (obj.pNext) {
15651          dumpPNextChain(obj.pNext);
15652       } else {
15653          PRINT_SPACE
15654          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15655      }
15656
15657      // CTS : required value
15658      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"" << std::endl;
15659
15660      INDENT(-4);
15661      PRINT_SPACE
15662      if (commaNeeded)
15663          _OUT << "}," << std::endl;
15664      else
15665          _OUT << "}" << std::endl;
15666 }
15667 static void print_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2 * obj, const std::string& s, bool commaNeeded=true) {
15668      PRINT_SPACE
15669      _OUT << "{" << std::endl;
15670      INDENT(4);
15671
15672      print_VkStructureType(obj->sType, "sType", 1);
15673
15674       if (obj->pNext) {
15675          dumpPNextChain(obj->pNext);
15676       } else {
15677          PRINT_SPACE
15678          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15679      }
15680
15681      // CTS : required value
15682      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"" << std::endl;
15683
15684      INDENT(-4);
15685      PRINT_SPACE
15686      if (commaNeeded)
15687          _OUT << "}," << std::endl;
15688      else
15689          _OUT << "}" << std::endl;
15690 }
15691
15692 static void print_VkImageMemoryRequirementsInfo2(VkImageMemoryRequirementsInfo2 obj, const std::string& s, bool commaNeeded=true) {
15693      PRINT_SPACE
15694      _OUT << "{" << std::endl;
15695      INDENT(4);
15696
15697      print_VkStructureType(obj.sType, "sType", 1);
15698
15699       if (obj.pNext) {
15700          dumpPNextChain(obj.pNext);
15701       } else {
15702          PRINT_SPACE
15703          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15704      }
15705
15706      // CTS : required value
15707      PRINT_SPACE    _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"" << std::endl;
15708
15709      INDENT(-4);
15710      PRINT_SPACE
15711      if (commaNeeded)
15712          _OUT << "}," << std::endl;
15713      else
15714          _OUT << "}" << std::endl;
15715 }
15716 static void print_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2 * obj, const std::string& s, bool commaNeeded=true) {
15717      PRINT_SPACE
15718      _OUT << "{" << std::endl;
15719      INDENT(4);
15720
15721      print_VkStructureType(obj->sType, "sType", 1);
15722
15723       if (obj->pNext) {
15724          dumpPNextChain(obj->pNext);
15725       } else {
15726          PRINT_SPACE
15727          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15728      }
15729
15730      // CTS : required value
15731      PRINT_SPACE    _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"" << std::endl;
15732
15733      INDENT(-4);
15734      PRINT_SPACE
15735      if (commaNeeded)
15736          _OUT << "}," << std::endl;
15737      else
15738          _OUT << "}" << std::endl;
15739 }
15740
15741 static void print_VkMemoryRequirements2(VkMemoryRequirements2 obj, const std::string& s, bool commaNeeded=true) {
15742      PRINT_SPACE
15743      _OUT << "{" << std::endl;
15744      INDENT(4);
15745
15746      print_VkStructureType(obj.sType, "sType", 1);
15747
15748       if (obj.pNext) {
15749          dumpPNextChain(obj.pNext);
15750       } else {
15751          PRINT_SPACE
15752          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15753      }
15754
15755      PRINT_SPACE
15756      _OUT << "\"memoryRequirements\": " << std::endl;
15757      {
15758            print_VkMemoryRequirements(obj.memoryRequirements, "memoryRequirements", 0);
15759      }
15760
15761      INDENT(-4);
15762      PRINT_SPACE
15763      if (commaNeeded)
15764          _OUT << "}," << std::endl;
15765      else
15766          _OUT << "}" << std::endl;
15767 }
15768 static void print_VkMemoryRequirements2(const VkMemoryRequirements2 * obj, const std::string& s, bool commaNeeded=true) {
15769      PRINT_SPACE
15770      _OUT << "{" << std::endl;
15771      INDENT(4);
15772
15773      print_VkStructureType(obj->sType, "sType", 1);
15774
15775       if (obj->pNext) {
15776          dumpPNextChain(obj->pNext);
15777       } else {
15778          PRINT_SPACE
15779          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15780      }
15781
15782      PRINT_SPACE
15783      _OUT << "\"memoryRequirements\": " << std::endl;
15784      {
15785            print_VkMemoryRequirements(obj->memoryRequirements, "memoryRequirements", 0);
15786      }
15787
15788      INDENT(-4);
15789      PRINT_SPACE
15790      if (commaNeeded)
15791          _OUT << "}," << std::endl;
15792      else
15793          _OUT << "}" << std::endl;
15794 }
15795
15796 static void print_VkPhysicalDeviceFeatures2(VkPhysicalDeviceFeatures2 obj, const std::string& s, bool commaNeeded=true) {
15797      PRINT_SPACE
15798      _OUT << "{" << std::endl;
15799      INDENT(4);
15800
15801      print_VkStructureType(obj.sType, "sType", 1);
15802
15803       if (obj.pNext) {
15804          dumpPNextChain(obj.pNext);
15805       } else {
15806          PRINT_SPACE
15807          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15808      }
15809
15810      PRINT_SPACE
15811      _OUT << "\"features\": " << std::endl;
15812      {
15813            print_VkPhysicalDeviceFeatures(obj.features, "features", 0);
15814      }
15815
15816      INDENT(-4);
15817      PRINT_SPACE
15818      if (commaNeeded)
15819          _OUT << "}," << std::endl;
15820      else
15821          _OUT << "}" << std::endl;
15822 }
15823 static void print_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 * obj, const std::string& s, bool commaNeeded=true) {
15824      PRINT_SPACE
15825      _OUT << "{" << std::endl;
15826      INDENT(4);
15827
15828      print_VkStructureType(obj->sType, "sType", 1);
15829
15830       if (obj->pNext) {
15831          dumpPNextChain(obj->pNext);
15832       } else {
15833          PRINT_SPACE
15834          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15835      }
15836
15837      PRINT_SPACE
15838      _OUT << "\"features\": " << std::endl;
15839      {
15840            print_VkPhysicalDeviceFeatures(obj->features, "features", 0);
15841      }
15842
15843      INDENT(-4);
15844      PRINT_SPACE
15845      if (commaNeeded)
15846          _OUT << "}," << std::endl;
15847      else
15848          _OUT << "}" << std::endl;
15849 }
15850
15851 static void print_VkPhysicalDeviceProperties2(VkPhysicalDeviceProperties2 obj, const std::string& s, bool commaNeeded=true) {
15852      PRINT_SPACE
15853      _OUT << "{" << std::endl;
15854      INDENT(4);
15855
15856      print_VkStructureType(obj.sType, "sType", 1);
15857
15858       if (obj.pNext) {
15859          dumpPNextChain(obj.pNext);
15860       } else {
15861          PRINT_SPACE
15862          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15863      }
15864
15865      PRINT_SPACE
15866      _OUT << "\"properties\": " << std::endl;
15867      {
15868            print_VkPhysicalDeviceProperties(obj.properties, "properties", 0);
15869      }
15870
15871      INDENT(-4);
15872      PRINT_SPACE
15873      if (commaNeeded)
15874          _OUT << "}," << std::endl;
15875      else
15876          _OUT << "}" << std::endl;
15877 }
15878 static void print_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 * obj, const std::string& s, bool commaNeeded=true) {
15879      PRINT_SPACE
15880      _OUT << "{" << std::endl;
15881      INDENT(4);
15882
15883      print_VkStructureType(obj->sType, "sType", 1);
15884
15885       if (obj->pNext) {
15886          dumpPNextChain(obj->pNext);
15887       } else {
15888          PRINT_SPACE
15889          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15890      }
15891
15892      PRINT_SPACE
15893      _OUT << "\"properties\": " << std::endl;
15894      {
15895            print_VkPhysicalDeviceProperties(obj->properties, "properties", 0);
15896      }
15897
15898      INDENT(-4);
15899      PRINT_SPACE
15900      if (commaNeeded)
15901          _OUT << "}," << std::endl;
15902      else
15903          _OUT << "}" << std::endl;
15904 }
15905
15906 static void print_VkFormatProperties2(VkFormatProperties2 obj, const std::string& s, bool commaNeeded=true) {
15907      PRINT_SPACE
15908      _OUT << "{" << std::endl;
15909      INDENT(4);
15910
15911      print_VkStructureType(obj.sType, "sType", 1);
15912
15913       if (obj.pNext) {
15914          dumpPNextChain(obj.pNext);
15915       } else {
15916          PRINT_SPACE
15917          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15918      }
15919
15920      PRINT_SPACE
15921      _OUT << "\"formatProperties\": " << std::endl;
15922      {
15923            print_VkFormatProperties(obj.formatProperties, "formatProperties", 0);
15924      }
15925
15926      INDENT(-4);
15927      PRINT_SPACE
15928      if (commaNeeded)
15929          _OUT << "}," << std::endl;
15930      else
15931          _OUT << "}" << std::endl;
15932 }
15933 static void print_VkFormatProperties2(const VkFormatProperties2 * obj, const std::string& s, bool commaNeeded=true) {
15934      PRINT_SPACE
15935      _OUT << "{" << std::endl;
15936      INDENT(4);
15937
15938      print_VkStructureType(obj->sType, "sType", 1);
15939
15940       if (obj->pNext) {
15941          dumpPNextChain(obj->pNext);
15942       } else {
15943          PRINT_SPACE
15944          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15945      }
15946
15947      PRINT_SPACE
15948      _OUT << "\"formatProperties\": " << std::endl;
15949      {
15950            print_VkFormatProperties(obj->formatProperties, "formatProperties", 0);
15951      }
15952
15953      INDENT(-4);
15954      PRINT_SPACE
15955      if (commaNeeded)
15956          _OUT << "}," << std::endl;
15957      else
15958          _OUT << "}" << std::endl;
15959 }
15960
15961 static void print_VkImageFormatProperties2(VkImageFormatProperties2 obj, const std::string& s, bool commaNeeded=true) {
15962      PRINT_SPACE
15963      _OUT << "{" << std::endl;
15964      INDENT(4);
15965
15966      print_VkStructureType(obj.sType, "sType", 1);
15967
15968       if (obj.pNext) {
15969          dumpPNextChain(obj.pNext);
15970       } else {
15971          PRINT_SPACE
15972          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
15973      }
15974
15975      PRINT_SPACE
15976      _OUT << "\"imageFormatProperties\": " << std::endl;
15977      {
15978            print_VkImageFormatProperties(obj.imageFormatProperties, "imageFormatProperties", 0);
15979      }
15980
15981      INDENT(-4);
15982      PRINT_SPACE
15983      if (commaNeeded)
15984          _OUT << "}," << std::endl;
15985      else
15986          _OUT << "}" << std::endl;
15987 }
15988 static void print_VkImageFormatProperties2(const VkImageFormatProperties2 * obj, const std::string& s, bool commaNeeded=true) {
15989      PRINT_SPACE
15990      _OUT << "{" << std::endl;
15991      INDENT(4);
15992
15993      print_VkStructureType(obj->sType, "sType", 1);
15994
15995       if (obj->pNext) {
15996          dumpPNextChain(obj->pNext);
15997       } else {
15998          PRINT_SPACE
15999          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16000      }
16001
16002      PRINT_SPACE
16003      _OUT << "\"imageFormatProperties\": " << std::endl;
16004      {
16005            print_VkImageFormatProperties(obj->imageFormatProperties, "imageFormatProperties", 0);
16006      }
16007
16008      INDENT(-4);
16009      PRINT_SPACE
16010      if (commaNeeded)
16011          _OUT << "}," << std::endl;
16012      else
16013          _OUT << "}" << std::endl;
16014 }
16015
16016 static void print_VkPhysicalDeviceImageFormatInfo2(VkPhysicalDeviceImageFormatInfo2 obj, const std::string& s, bool commaNeeded=true) {
16017      PRINT_SPACE
16018      _OUT << "{" << std::endl;
16019      INDENT(4);
16020
16021      print_VkStructureType(obj.sType, "sType", 1);
16022
16023       if (obj.pNext) {
16024          dumpPNextChain(obj.pNext);
16025       } else {
16026          PRINT_SPACE
16027          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16028      }
16029
16030      print_VkFormat(obj.format, "format", 1);
16031
16032      print_VkImageType(obj.type, "type", 1);
16033
16034      print_VkImageTiling(obj.tiling, "tiling", 1);
16035
16036      print_VkImageUsageFlags(obj.usage, "usage", 1);
16037
16038      print_VkImageCreateFlags(obj.flags, "flags", 0);
16039
16040      INDENT(-4);
16041      PRINT_SPACE
16042      if (commaNeeded)
16043          _OUT << "}," << std::endl;
16044      else
16045          _OUT << "}" << std::endl;
16046 }
16047 static void print_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 * obj, const std::string& s, bool commaNeeded=true) {
16048      PRINT_SPACE
16049      _OUT << "{" << std::endl;
16050      INDENT(4);
16051
16052      print_VkStructureType(obj->sType, "sType", 1);
16053
16054       if (obj->pNext) {
16055          dumpPNextChain(obj->pNext);
16056       } else {
16057          PRINT_SPACE
16058          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16059      }
16060
16061      print_VkFormat(obj->format, "format", 1);
16062
16063      print_VkImageType(obj->type, "type", 1);
16064
16065      print_VkImageTiling(obj->tiling, "tiling", 1);
16066
16067      print_VkImageUsageFlags(obj->usage, "usage", 1);
16068
16069      print_VkImageCreateFlags(obj->flags, "flags", 0);
16070
16071      INDENT(-4);
16072      PRINT_SPACE
16073      if (commaNeeded)
16074          _OUT << "}," << std::endl;
16075      else
16076          _OUT << "}" << std::endl;
16077 }
16078
16079 static void print_VkQueueFamilyProperties2(VkQueueFamilyProperties2 obj, const std::string& s, bool commaNeeded=true) {
16080      PRINT_SPACE
16081      _OUT << "{" << std::endl;
16082      INDENT(4);
16083
16084      print_VkStructureType(obj.sType, "sType", 1);
16085
16086       if (obj.pNext) {
16087          dumpPNextChain(obj.pNext);
16088       } else {
16089          PRINT_SPACE
16090          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16091      }
16092
16093      PRINT_SPACE
16094      _OUT << "\"queueFamilyProperties\": " << std::endl;
16095      {
16096            print_VkQueueFamilyProperties(obj.queueFamilyProperties, "queueFamilyProperties", 0);
16097      }
16098
16099      INDENT(-4);
16100      PRINT_SPACE
16101      if (commaNeeded)
16102          _OUT << "}," << std::endl;
16103      else
16104          _OUT << "}" << std::endl;
16105 }
16106 static void print_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 * obj, const std::string& s, bool commaNeeded=true) {
16107      PRINT_SPACE
16108      _OUT << "{" << std::endl;
16109      INDENT(4);
16110
16111      print_VkStructureType(obj->sType, "sType", 1);
16112
16113       if (obj->pNext) {
16114          dumpPNextChain(obj->pNext);
16115       } else {
16116          PRINT_SPACE
16117          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16118      }
16119
16120      PRINT_SPACE
16121      _OUT << "\"queueFamilyProperties\": " << std::endl;
16122      {
16123            print_VkQueueFamilyProperties(obj->queueFamilyProperties, "queueFamilyProperties", 0);
16124      }
16125
16126      INDENT(-4);
16127      PRINT_SPACE
16128      if (commaNeeded)
16129          _OUT << "}," << std::endl;
16130      else
16131          _OUT << "}" << std::endl;
16132 }
16133
16134 static void print_VkPhysicalDeviceMemoryProperties2(VkPhysicalDeviceMemoryProperties2 obj, const std::string& s, bool commaNeeded=true) {
16135      PRINT_SPACE
16136      _OUT << "{" << std::endl;
16137      INDENT(4);
16138
16139      print_VkStructureType(obj.sType, "sType", 1);
16140
16141       if (obj.pNext) {
16142          dumpPNextChain(obj.pNext);
16143       } else {
16144          PRINT_SPACE
16145          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16146      }
16147
16148      PRINT_SPACE
16149      _OUT << "\"memoryProperties\": " << std::endl;
16150      {
16151            print_VkPhysicalDeviceMemoryProperties(obj.memoryProperties, "memoryProperties", 0);
16152      }
16153
16154      INDENT(-4);
16155      PRINT_SPACE
16156      if (commaNeeded)
16157          _OUT << "}," << std::endl;
16158      else
16159          _OUT << "}" << std::endl;
16160 }
16161 static void print_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 * obj, const std::string& s, bool commaNeeded=true) {
16162      PRINT_SPACE
16163      _OUT << "{" << std::endl;
16164      INDENT(4);
16165
16166      print_VkStructureType(obj->sType, "sType", 1);
16167
16168       if (obj->pNext) {
16169          dumpPNextChain(obj->pNext);
16170       } else {
16171          PRINT_SPACE
16172          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16173      }
16174
16175      PRINT_SPACE
16176      _OUT << "\"memoryProperties\": " << std::endl;
16177      {
16178            print_VkPhysicalDeviceMemoryProperties(obj->memoryProperties, "memoryProperties", 0);
16179      }
16180
16181      INDENT(-4);
16182      PRINT_SPACE
16183      if (commaNeeded)
16184          _OUT << "}," << std::endl;
16185      else
16186          _OUT << "}" << std::endl;
16187 }
16188
16189 static void print_VkPhysicalDevicePointClippingProperties(VkPhysicalDevicePointClippingProperties obj, const std::string& s, bool commaNeeded=true) {
16190      PRINT_SPACE
16191      _OUT << "{" << std::endl;
16192      INDENT(4);
16193
16194      print_VkStructureType(obj.sType, "sType", 1);
16195
16196       if (obj.pNext) {
16197          dumpPNextChain(obj.pNext);
16198       } else {
16199          PRINT_SPACE
16200          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16201      }
16202
16203      print_VkPointClippingBehavior(obj.pointClippingBehavior, "pointClippingBehavior", 0);
16204
16205      INDENT(-4);
16206      PRINT_SPACE
16207      if (commaNeeded)
16208          _OUT << "}," << std::endl;
16209      else
16210          _OUT << "}" << std::endl;
16211 }
16212 static void print_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties * obj, const std::string& s, bool commaNeeded=true) {
16213      PRINT_SPACE
16214      _OUT << "{" << std::endl;
16215      INDENT(4);
16216
16217      print_VkStructureType(obj->sType, "sType", 1);
16218
16219       if (obj->pNext) {
16220          dumpPNextChain(obj->pNext);
16221       } else {
16222          PRINT_SPACE
16223          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16224      }
16225
16226      print_VkPointClippingBehavior(obj->pointClippingBehavior, "pointClippingBehavior", 0);
16227
16228      INDENT(-4);
16229      PRINT_SPACE
16230      if (commaNeeded)
16231          _OUT << "}," << std::endl;
16232      else
16233          _OUT << "}" << std::endl;
16234 }
16235
16236 static void print_VkInputAttachmentAspectReference(VkInputAttachmentAspectReference obj, const std::string& s, bool commaNeeded=true) {
16237      PRINT_SPACE
16238      _OUT << "{" << std::endl;
16239      INDENT(4);
16240
16241      print_uint32_t(obj.subpass, "subpass", 1);
16242
16243      print_uint32_t(obj.inputAttachmentIndex, "inputAttachmentIndex", 1);
16244
16245      print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 0);
16246
16247      INDENT(-4);
16248      PRINT_SPACE
16249      if (commaNeeded)
16250          _OUT << "}," << std::endl;
16251      else
16252          _OUT << "}" << std::endl;
16253 }
16254 static void print_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference * obj, const std::string& s, bool commaNeeded=true) {
16255      PRINT_SPACE
16256      _OUT << "{" << std::endl;
16257      INDENT(4);
16258
16259      print_uint32_t(obj->subpass, "subpass", 1);
16260
16261      print_uint32_t(obj->inputAttachmentIndex, "inputAttachmentIndex", 1);
16262
16263      print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 0);
16264
16265      INDENT(-4);
16266      PRINT_SPACE
16267      if (commaNeeded)
16268          _OUT << "}," << std::endl;
16269      else
16270          _OUT << "}" << std::endl;
16271 }
16272
16273 static void print_VkRenderPassInputAttachmentAspectCreateInfo(VkRenderPassInputAttachmentAspectCreateInfo obj, const std::string& s, bool commaNeeded=true) {
16274      PRINT_SPACE
16275      _OUT << "{" << std::endl;
16276      INDENT(4);
16277
16278      print_VkStructureType(obj.sType, "sType", 1);
16279
16280       if (obj.pNext) {
16281          dumpPNextChain(obj.pNext);
16282       } else {
16283          PRINT_SPACE
16284          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16285      }
16286
16287      print_uint32_t(obj.aspectReferenceCount, "aspectReferenceCount", 1);
16288
16289      PRINT_SPACE
16290      _OUT << "\"pAspectReferences\": " << std::endl;
16291      if (obj.pAspectReferences) {
16292          PRINT_SPACE
16293          _OUT << "[" << std::endl;
16294          for (unsigned int i = 0; i < obj.aspectReferenceCount; i++) {
16295            if (i+1 == obj.aspectReferenceCount)
16296                print_VkInputAttachmentAspectReference(obj.pAspectReferences[i], "pAspectReferences", 0);
16297            else
16298                print_VkInputAttachmentAspectReference(obj.pAspectReferences[i], "pAspectReferences", 1);
16299          }
16300          PRINT_SPACE
16301          _OUT << "]" << std::endl;
16302     }
16303      else
16304      {
16305          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
16306      }
16307
16308      INDENT(-4);
16309      PRINT_SPACE
16310      if (commaNeeded)
16311          _OUT << "}," << std::endl;
16312      else
16313          _OUT << "}" << std::endl;
16314 }
16315 static void print_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
16316      PRINT_SPACE
16317      _OUT << "{" << std::endl;
16318      INDENT(4);
16319
16320      print_VkStructureType(obj->sType, "sType", 1);
16321
16322       if (obj->pNext) {
16323          dumpPNextChain(obj->pNext);
16324       } else {
16325          PRINT_SPACE
16326          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16327      }
16328
16329      print_uint32_t(obj->aspectReferenceCount, "aspectReferenceCount", 1);
16330
16331      PRINT_SPACE
16332      _OUT << "\"pAspectReferences\": " << std::endl;
16333      if (obj->pAspectReferences) {
16334          PRINT_SPACE
16335          _OUT << "[" << std::endl;
16336          for (unsigned int i = 0; i < obj->aspectReferenceCount; i++) {
16337            if (i+1 == obj->aspectReferenceCount)
16338                print_VkInputAttachmentAspectReference(obj->pAspectReferences[i], "pAspectReferences", 0);
16339            else
16340                print_VkInputAttachmentAspectReference(obj->pAspectReferences[i], "pAspectReferences", 1);
16341          }
16342          PRINT_SPACE
16343          _OUT << "]" << std::endl;
16344     }
16345      else
16346      {
16347          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
16348      }
16349
16350      INDENT(-4);
16351      PRINT_SPACE
16352      if (commaNeeded)
16353          _OUT << "}," << std::endl;
16354      else
16355          _OUT << "}" << std::endl;
16356 }
16357
16358 static void print_VkImageViewUsageCreateInfo(VkImageViewUsageCreateInfo obj, const std::string& s, bool commaNeeded=true) {
16359      PRINT_SPACE
16360      _OUT << "{" << std::endl;
16361      INDENT(4);
16362
16363      print_VkStructureType(obj.sType, "sType", 1);
16364
16365       if (obj.pNext) {
16366          dumpPNextChain(obj.pNext);
16367       } else {
16368          PRINT_SPACE
16369          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16370      }
16371
16372      print_VkImageUsageFlags(obj.usage, "usage", 0);
16373
16374      INDENT(-4);
16375      PRINT_SPACE
16376      if (commaNeeded)
16377          _OUT << "}," << std::endl;
16378      else
16379          _OUT << "}" << std::endl;
16380 }
16381 static void print_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
16382      PRINT_SPACE
16383      _OUT << "{" << std::endl;
16384      INDENT(4);
16385
16386      print_VkStructureType(obj->sType, "sType", 1);
16387
16388       if (obj->pNext) {
16389          dumpPNextChain(obj->pNext);
16390       } else {
16391          PRINT_SPACE
16392          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16393      }
16394
16395      print_VkImageUsageFlags(obj->usage, "usage", 0);
16396
16397      INDENT(-4);
16398      PRINT_SPACE
16399      if (commaNeeded)
16400          _OUT << "}," << std::endl;
16401      else
16402          _OUT << "}" << std::endl;
16403 }
16404
16405 static void print_VkPipelineTessellationDomainOriginStateCreateInfo(VkPipelineTessellationDomainOriginStateCreateInfo obj, const std::string& s, bool commaNeeded=true) {
16406      PRINT_SPACE
16407      _OUT << "{" << std::endl;
16408      INDENT(4);
16409
16410      print_VkStructureType(obj.sType, "sType", 1);
16411
16412       if (obj.pNext) {
16413          dumpPNextChain(obj.pNext);
16414       } else {
16415          PRINT_SPACE
16416          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16417      }
16418
16419      print_VkTessellationDomainOrigin(obj.domainOrigin, "domainOrigin", 0);
16420
16421      INDENT(-4);
16422      PRINT_SPACE
16423      if (commaNeeded)
16424          _OUT << "}," << std::endl;
16425      else
16426          _OUT << "}" << std::endl;
16427 }
16428 static void print_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
16429      PRINT_SPACE
16430      _OUT << "{" << std::endl;
16431      INDENT(4);
16432
16433      print_VkStructureType(obj->sType, "sType", 1);
16434
16435       if (obj->pNext) {
16436          dumpPNextChain(obj->pNext);
16437       } else {
16438          PRINT_SPACE
16439          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16440      }
16441
16442      print_VkTessellationDomainOrigin(obj->domainOrigin, "domainOrigin", 0);
16443
16444      INDENT(-4);
16445      PRINT_SPACE
16446      if (commaNeeded)
16447          _OUT << "}," << std::endl;
16448      else
16449          _OUT << "}" << std::endl;
16450 }
16451
16452 static void print_VkRenderPassMultiviewCreateInfo(VkRenderPassMultiviewCreateInfo obj, const std::string& s, bool commaNeeded=true) {
16453      PRINT_SPACE
16454      _OUT << "{" << std::endl;
16455      INDENT(4);
16456
16457      print_VkStructureType(obj.sType, "sType", 1);
16458
16459       if (obj.pNext) {
16460          dumpPNextChain(obj.pNext);
16461       } else {
16462          PRINT_SPACE
16463          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16464      }
16465
16466      print_uint32_t(obj.subpassCount, "subpassCount", 1);
16467
16468      PRINT_SPACE
16469      _OUT << "\"pViewMasks\":" << std::endl;
16470      PRINT_SPACE
16471      if (obj.pViewMasks) {
16472        _OUT << "[" << std::endl;
16473        for (unsigned int i = 0; i < obj.subpassCount; i++) {
16474            bool isCommaNeeded = (i+1) != obj.subpassCount;
16475            print_uint32_t(obj.pViewMasks[i], "", isCommaNeeded);
16476        }
16477        PRINT_SPACE
16478        _OUT << "]" << "," << std::endl;
16479      } else {
16480        _OUT << "\"NULL\"" << "," << std::endl;
16481      }
16482
16483      print_uint32_t(obj.dependencyCount, "dependencyCount", 1);
16484
16485      PRINT_SPACE
16486      _OUT << "\"pViewOffsets\":" << std::endl;
16487      PRINT_SPACE
16488      if (obj.pViewOffsets) {
16489        _OUT << "[" << std::endl;
16490        for (unsigned int i = 0; i < obj.dependencyCount; i++) {
16491            bool isCommaNeeded = (i+1) != obj.dependencyCount;
16492            print_int32_t(obj.pViewOffsets[i], "", isCommaNeeded);
16493        }
16494        PRINT_SPACE
16495        _OUT << "]" << "," << std::endl;
16496      } else {
16497        _OUT << "\"NULL\"" << "," << std::endl;
16498      }
16499
16500      print_uint32_t(obj.correlationMaskCount, "correlationMaskCount", 1);
16501
16502      PRINT_SPACE
16503      _OUT << "\"pCorrelationMasks\":" << std::endl;
16504      PRINT_SPACE
16505      if (obj.pCorrelationMasks) {
16506        _OUT << "[" << std::endl;
16507        for (unsigned int i = 0; i < obj.correlationMaskCount; i++) {
16508            bool isCommaNeeded = (i+1) != obj.correlationMaskCount;
16509            print_uint32_t(obj.pCorrelationMasks[i], "", isCommaNeeded);
16510        }
16511        PRINT_SPACE
16512        _OUT << "]" << "" << std::endl;
16513      } else {
16514        _OUT << "\"NULL\"" << "" << std::endl;
16515      }
16516
16517      INDENT(-4);
16518      PRINT_SPACE
16519      if (commaNeeded)
16520          _OUT << "}," << std::endl;
16521      else
16522          _OUT << "}" << std::endl;
16523 }
16524 static void print_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
16525      PRINT_SPACE
16526      _OUT << "{" << std::endl;
16527      INDENT(4);
16528
16529      print_VkStructureType(obj->sType, "sType", 1);
16530
16531       if (obj->pNext) {
16532          dumpPNextChain(obj->pNext);
16533       } else {
16534          PRINT_SPACE
16535          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16536      }
16537
16538      print_uint32_t(obj->subpassCount, "subpassCount", 1);
16539
16540      PRINT_SPACE
16541      _OUT << "\"pViewMasks\":" << std::endl;
16542      PRINT_SPACE
16543      if (obj->pViewMasks) {
16544        _OUT << "[" << std::endl;
16545        for (unsigned int i = 0; i < obj->subpassCount; i++) {
16546            bool isCommaNeeded = (i+1) != obj->subpassCount;
16547            print_uint32_t(obj->pViewMasks[i], "", isCommaNeeded);
16548        }
16549        PRINT_SPACE
16550        _OUT << "]" << "," << std::endl;
16551      } else {
16552        _OUT << "\"NULL\"" << "," << std::endl;
16553      }
16554
16555      print_uint32_t(obj->dependencyCount, "dependencyCount", 1);
16556
16557      PRINT_SPACE
16558      _OUT << "\"pViewOffsets\":" << std::endl;
16559      PRINT_SPACE
16560      if (obj->pViewOffsets) {
16561        _OUT << "[" << std::endl;
16562        for (unsigned int i = 0; i < obj->dependencyCount; i++) {
16563            bool isCommaNeeded = (i+1) != obj->dependencyCount;
16564            print_int32_t(obj->pViewOffsets[i], "", isCommaNeeded);
16565        }
16566        PRINT_SPACE
16567        _OUT << "]" << "," << std::endl;
16568      } else {
16569        _OUT << "\"NULL\"" << "," << std::endl;
16570      }
16571
16572      print_uint32_t(obj->correlationMaskCount, "correlationMaskCount", 1);
16573
16574      PRINT_SPACE
16575      _OUT << "\"pCorrelationMasks\":" << std::endl;
16576      PRINT_SPACE
16577      if (obj->pCorrelationMasks) {
16578        _OUT << "[" << std::endl;
16579        for (unsigned int i = 0; i < obj->correlationMaskCount; i++) {
16580            bool isCommaNeeded = (i+1) != obj->correlationMaskCount;
16581            print_uint32_t(obj->pCorrelationMasks[i], "", isCommaNeeded);
16582        }
16583        PRINT_SPACE
16584        _OUT << "]" << "" << std::endl;
16585      } else {
16586        _OUT << "\"NULL\"" << "" << std::endl;
16587      }
16588
16589      INDENT(-4);
16590      PRINT_SPACE
16591      if (commaNeeded)
16592          _OUT << "}," << std::endl;
16593      else
16594          _OUT << "}" << std::endl;
16595 }
16596
16597 static void print_VkPhysicalDeviceMultiviewFeatures(VkPhysicalDeviceMultiviewFeatures obj, const std::string& s, bool commaNeeded=true) {
16598      PRINT_SPACE
16599      _OUT << "{" << std::endl;
16600      INDENT(4);
16601
16602      print_VkStructureType(obj.sType, "sType", 1);
16603
16604       if (obj.pNext) {
16605          dumpPNextChain(obj.pNext);
16606       } else {
16607          PRINT_SPACE
16608          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16609      }
16610
16611      print_VkBool32(obj.multiview, "multiview", 1);
16612
16613      print_VkBool32(obj.multiviewGeometryShader, "multiviewGeometryShader", 1);
16614
16615      print_VkBool32(obj.multiviewTessellationShader, "multiviewTessellationShader", 0);
16616
16617      INDENT(-4);
16618      PRINT_SPACE
16619      if (commaNeeded)
16620          _OUT << "}," << std::endl;
16621      else
16622          _OUT << "}" << std::endl;
16623 }
16624 static void print_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures * obj, const std::string& s, bool commaNeeded=true) {
16625      PRINT_SPACE
16626      _OUT << "{" << std::endl;
16627      INDENT(4);
16628
16629      print_VkStructureType(obj->sType, "sType", 1);
16630
16631       if (obj->pNext) {
16632          dumpPNextChain(obj->pNext);
16633       } else {
16634          PRINT_SPACE
16635          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16636      }
16637
16638      print_VkBool32(obj->multiview, "multiview", 1);
16639
16640      print_VkBool32(obj->multiviewGeometryShader, "multiviewGeometryShader", 1);
16641
16642      print_VkBool32(obj->multiviewTessellationShader, "multiviewTessellationShader", 0);
16643
16644      INDENT(-4);
16645      PRINT_SPACE
16646      if (commaNeeded)
16647          _OUT << "}," << std::endl;
16648      else
16649          _OUT << "}" << std::endl;
16650 }
16651
16652 static void print_VkPhysicalDeviceMultiviewProperties(VkPhysicalDeviceMultiviewProperties obj, const std::string& s, bool commaNeeded=true) {
16653      PRINT_SPACE
16654      _OUT << "{" << std::endl;
16655      INDENT(4);
16656
16657      print_VkStructureType(obj.sType, "sType", 1);
16658
16659       if (obj.pNext) {
16660          dumpPNextChain(obj.pNext);
16661       } else {
16662          PRINT_SPACE
16663          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16664      }
16665
16666      print_uint32_t(obj.maxMultiviewViewCount, "maxMultiviewViewCount", 1);
16667
16668      print_uint32_t(obj.maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 0);
16669
16670      INDENT(-4);
16671      PRINT_SPACE
16672      if (commaNeeded)
16673          _OUT << "}," << std::endl;
16674      else
16675          _OUT << "}" << std::endl;
16676 }
16677 static void print_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties * obj, const std::string& s, bool commaNeeded=true) {
16678      PRINT_SPACE
16679      _OUT << "{" << std::endl;
16680      INDENT(4);
16681
16682      print_VkStructureType(obj->sType, "sType", 1);
16683
16684       if (obj->pNext) {
16685          dumpPNextChain(obj->pNext);
16686       } else {
16687          PRINT_SPACE
16688          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16689      }
16690
16691      print_uint32_t(obj->maxMultiviewViewCount, "maxMultiviewViewCount", 1);
16692
16693      print_uint32_t(obj->maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 0);
16694
16695      INDENT(-4);
16696      PRINT_SPACE
16697      if (commaNeeded)
16698          _OUT << "}," << std::endl;
16699      else
16700          _OUT << "}" << std::endl;
16701 }
16702
16703 static void print_VkPhysicalDeviceVariablePointersFeatures(VkPhysicalDeviceVariablePointersFeatures obj, const std::string& s, bool commaNeeded=true) {
16704      PRINT_SPACE
16705      _OUT << "{" << std::endl;
16706      INDENT(4);
16707
16708      print_VkStructureType(obj.sType, "sType", 1);
16709
16710       if (obj.pNext) {
16711          dumpPNextChain(obj.pNext);
16712       } else {
16713          PRINT_SPACE
16714          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16715      }
16716
16717      print_VkBool32(obj.variablePointersStorageBuffer, "variablePointersStorageBuffer", 1);
16718
16719      print_VkBool32(obj.variablePointers, "variablePointers", 0);
16720
16721      INDENT(-4);
16722      PRINT_SPACE
16723      if (commaNeeded)
16724          _OUT << "}," << std::endl;
16725      else
16726          _OUT << "}" << std::endl;
16727 }
16728 static void print_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures * obj, const std::string& s, bool commaNeeded=true) {
16729      PRINT_SPACE
16730      _OUT << "{" << std::endl;
16731      INDENT(4);
16732
16733      print_VkStructureType(obj->sType, "sType", 1);
16734
16735       if (obj->pNext) {
16736          dumpPNextChain(obj->pNext);
16737       } else {
16738          PRINT_SPACE
16739          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16740      }
16741
16742      print_VkBool32(obj->variablePointersStorageBuffer, "variablePointersStorageBuffer", 1);
16743
16744      print_VkBool32(obj->variablePointers, "variablePointers", 0);
16745
16746      INDENT(-4);
16747      PRINT_SPACE
16748      if (commaNeeded)
16749          _OUT << "}," << std::endl;
16750      else
16751          _OUT << "}" << std::endl;
16752 }
16753
16754 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures;
16755
16756 static void print_VkPhysicalDeviceProtectedMemoryFeatures(VkPhysicalDeviceProtectedMemoryFeatures obj, const std::string& s, bool commaNeeded=true) {
16757      PRINT_SPACE
16758      _OUT << "{" << std::endl;
16759      INDENT(4);
16760
16761      print_VkStructureType(obj.sType, "sType", 1);
16762
16763       if (obj.pNext) {
16764          dumpPNextChain(obj.pNext);
16765       } else {
16766          PRINT_SPACE
16767          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16768      }
16769
16770      print_VkBool32(obj.protectedMemory, "protectedMemory", 0);
16771
16772      INDENT(-4);
16773      PRINT_SPACE
16774      if (commaNeeded)
16775          _OUT << "}," << std::endl;
16776      else
16777          _OUT << "}" << std::endl;
16778 }
16779 static void print_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures * obj, const std::string& s, bool commaNeeded=true) {
16780      PRINT_SPACE
16781      _OUT << "{" << std::endl;
16782      INDENT(4);
16783
16784      print_VkStructureType(obj->sType, "sType", 1);
16785
16786       if (obj->pNext) {
16787          dumpPNextChain(obj->pNext);
16788       } else {
16789          PRINT_SPACE
16790          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16791      }
16792
16793      print_VkBool32(obj->protectedMemory, "protectedMemory", 0);
16794
16795      INDENT(-4);
16796      PRINT_SPACE
16797      if (commaNeeded)
16798          _OUT << "}," << std::endl;
16799      else
16800          _OUT << "}" << std::endl;
16801 }
16802
16803 static void print_VkPhysicalDeviceProtectedMemoryProperties(VkPhysicalDeviceProtectedMemoryProperties obj, const std::string& s, bool commaNeeded=true) {
16804      PRINT_SPACE
16805      _OUT << "{" << std::endl;
16806      INDENT(4);
16807
16808      print_VkStructureType(obj.sType, "sType", 1);
16809
16810       if (obj.pNext) {
16811          dumpPNextChain(obj.pNext);
16812       } else {
16813          PRINT_SPACE
16814          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16815      }
16816
16817      print_VkBool32(obj.protectedNoFault, "protectedNoFault", 0);
16818
16819      INDENT(-4);
16820      PRINT_SPACE
16821      if (commaNeeded)
16822          _OUT << "}," << std::endl;
16823      else
16824          _OUT << "}" << std::endl;
16825 }
16826 static void print_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties * obj, const std::string& s, bool commaNeeded=true) {
16827      PRINT_SPACE
16828      _OUT << "{" << std::endl;
16829      INDENT(4);
16830
16831      print_VkStructureType(obj->sType, "sType", 1);
16832
16833       if (obj->pNext) {
16834          dumpPNextChain(obj->pNext);
16835       } else {
16836          PRINT_SPACE
16837          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16838      }
16839
16840      print_VkBool32(obj->protectedNoFault, "protectedNoFault", 0);
16841
16842      INDENT(-4);
16843      PRINT_SPACE
16844      if (commaNeeded)
16845          _OUT << "}," << std::endl;
16846      else
16847          _OUT << "}" << std::endl;
16848 }
16849
16850 static void print_VkDeviceQueueInfo2(VkDeviceQueueInfo2 obj, const std::string& s, bool commaNeeded=true) {
16851      PRINT_SPACE
16852      _OUT << "{" << std::endl;
16853      INDENT(4);
16854
16855      print_VkStructureType(obj.sType, "sType", 1);
16856
16857       if (obj.pNext) {
16858          dumpPNextChain(obj.pNext);
16859       } else {
16860          PRINT_SPACE
16861          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16862      }
16863
16864      print_VkDeviceQueueCreateFlags(obj.flags, "flags", 1);
16865
16866      print_uint32_t(obj.queueFamilyIndex, "queueFamilyIndex", 1);
16867
16868      print_uint32_t(obj.queueIndex, "queueIndex", 0);
16869
16870      INDENT(-4);
16871      PRINT_SPACE
16872      if (commaNeeded)
16873          _OUT << "}," << std::endl;
16874      else
16875          _OUT << "}" << std::endl;
16876 }
16877 static void print_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 * obj, const std::string& s, bool commaNeeded=true) {
16878      PRINT_SPACE
16879      _OUT << "{" << std::endl;
16880      INDENT(4);
16881
16882      print_VkStructureType(obj->sType, "sType", 1);
16883
16884       if (obj->pNext) {
16885          dumpPNextChain(obj->pNext);
16886       } else {
16887          PRINT_SPACE
16888          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16889      }
16890
16891      print_VkDeviceQueueCreateFlags(obj->flags, "flags", 1);
16892
16893      print_uint32_t(obj->queueFamilyIndex, "queueFamilyIndex", 1);
16894
16895      print_uint32_t(obj->queueIndex, "queueIndex", 0);
16896
16897      INDENT(-4);
16898      PRINT_SPACE
16899      if (commaNeeded)
16900          _OUT << "}," << std::endl;
16901      else
16902          _OUT << "}" << std::endl;
16903 }
16904
16905 static void print_VkProtectedSubmitInfo(VkProtectedSubmitInfo obj, const std::string& s, bool commaNeeded=true) {
16906      PRINT_SPACE
16907      _OUT << "{" << std::endl;
16908      INDENT(4);
16909
16910      print_VkStructureType(obj.sType, "sType", 1);
16911
16912       if (obj.pNext) {
16913          dumpPNextChain(obj.pNext);
16914       } else {
16915          PRINT_SPACE
16916          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16917      }
16918
16919      print_VkBool32(obj.protectedSubmit, "protectedSubmit", 0);
16920
16921      INDENT(-4);
16922      PRINT_SPACE
16923      if (commaNeeded)
16924          _OUT << "}," << std::endl;
16925      else
16926          _OUT << "}" << std::endl;
16927 }
16928 static void print_VkProtectedSubmitInfo(const VkProtectedSubmitInfo * obj, const std::string& s, bool commaNeeded=true) {
16929      PRINT_SPACE
16930      _OUT << "{" << std::endl;
16931      INDENT(4);
16932
16933      print_VkStructureType(obj->sType, "sType", 1);
16934
16935       if (obj->pNext) {
16936          dumpPNextChain(obj->pNext);
16937       } else {
16938          PRINT_SPACE
16939          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16940      }
16941
16942      print_VkBool32(obj->protectedSubmit, "protectedSubmit", 0);
16943
16944      INDENT(-4);
16945      PRINT_SPACE
16946      if (commaNeeded)
16947          _OUT << "}," << std::endl;
16948      else
16949          _OUT << "}" << std::endl;
16950 }
16951
16952 static void print_VkSamplerYcbcrConversionCreateInfo(VkSamplerYcbcrConversionCreateInfo obj, const std::string& s, bool commaNeeded=true) {
16953      PRINT_SPACE
16954      _OUT << "{" << std::endl;
16955      INDENT(4);
16956
16957      print_VkStructureType(obj.sType, "sType", 1);
16958
16959       if (obj.pNext) {
16960          dumpPNextChain(obj.pNext);
16961       } else {
16962          PRINT_SPACE
16963          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
16964      }
16965
16966      print_VkFormat(obj.format, "format", 1);
16967
16968      print_VkSamplerYcbcrModelConversion(obj.ycbcrModel, "ycbcrModel", 1);
16969
16970      print_VkSamplerYcbcrRange(obj.ycbcrRange, "ycbcrRange", 1);
16971
16972      PRINT_SPACE
16973      _OUT << "\"components\": " << std::endl;
16974      {
16975            print_VkComponentMapping(obj.components, "components", 1);
16976      }
16977
16978      print_VkChromaLocation(obj.xChromaOffset, "xChromaOffset", 1);
16979
16980      print_VkChromaLocation(obj.yChromaOffset, "yChromaOffset", 1);
16981
16982      print_VkFilter(obj.chromaFilter, "chromaFilter", 1);
16983
16984      print_VkBool32(obj.forceExplicitReconstruction, "forceExplicitReconstruction", 0);
16985
16986      INDENT(-4);
16987      PRINT_SPACE
16988      if (commaNeeded)
16989          _OUT << "}," << std::endl;
16990      else
16991          _OUT << "}" << std::endl;
16992 }
16993 static void print_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
16994      PRINT_SPACE
16995      _OUT << "{" << std::endl;
16996      INDENT(4);
16997
16998      print_VkStructureType(obj->sType, "sType", 1);
16999
17000       if (obj->pNext) {
17001          dumpPNextChain(obj->pNext);
17002       } else {
17003          PRINT_SPACE
17004          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17005      }
17006
17007      print_VkFormat(obj->format, "format", 1);
17008
17009      print_VkSamplerYcbcrModelConversion(obj->ycbcrModel, "ycbcrModel", 1);
17010
17011      print_VkSamplerYcbcrRange(obj->ycbcrRange, "ycbcrRange", 1);
17012
17013      PRINT_SPACE
17014      _OUT << "\"components\": " << std::endl;
17015      {
17016            print_VkComponentMapping(obj->components, "components", 1);
17017      }
17018
17019      print_VkChromaLocation(obj->xChromaOffset, "xChromaOffset", 1);
17020
17021      print_VkChromaLocation(obj->yChromaOffset, "yChromaOffset", 1);
17022
17023      print_VkFilter(obj->chromaFilter, "chromaFilter", 1);
17024
17025      print_VkBool32(obj->forceExplicitReconstruction, "forceExplicitReconstruction", 0);
17026
17027      INDENT(-4);
17028      PRINT_SPACE
17029      if (commaNeeded)
17030          _OUT << "}," << std::endl;
17031      else
17032          _OUT << "}" << std::endl;
17033 }
17034
17035 static void print_VkSamplerYcbcrConversionInfo(VkSamplerYcbcrConversionInfo obj, const std::string& s, bool commaNeeded=true) {
17036      PRINT_SPACE
17037      _OUT << "{" << std::endl;
17038      INDENT(4);
17039
17040      print_VkStructureType(obj.sType, "sType", 1);
17041
17042       if (obj.pNext) {
17043          dumpPNextChain(obj.pNext);
17044       } else {
17045          PRINT_SPACE
17046          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17047      }
17048
17049      // CTS : required value
17050      PRINT_SPACE    _OUT << "\"" << "conversion" << "\"" << " : " << obj.conversion.getInternal() << std::endl;
17051
17052      INDENT(-4);
17053      PRINT_SPACE
17054      if (commaNeeded)
17055          _OUT << "}," << std::endl;
17056      else
17057          _OUT << "}" << std::endl;
17058 }
17059 static void print_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo * obj, const std::string& s, bool commaNeeded=true) {
17060      PRINT_SPACE
17061      _OUT << "{" << std::endl;
17062      INDENT(4);
17063
17064      print_VkStructureType(obj->sType, "sType", 1);
17065
17066       if (obj->pNext) {
17067          dumpPNextChain(obj->pNext);
17068       } else {
17069          PRINT_SPACE
17070          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17071      }
17072
17073      // CTS : required value
17074      PRINT_SPACE    _OUT << "\"" << "conversion" << "\"" << " : " << obj->conversion.getInternal() << std::endl;
17075
17076      INDENT(-4);
17077      PRINT_SPACE
17078      if (commaNeeded)
17079          _OUT << "}," << std::endl;
17080      else
17081          _OUT << "}" << std::endl;
17082 }
17083
17084 static void print_VkBindImagePlaneMemoryInfo(VkBindImagePlaneMemoryInfo obj, const std::string& s, bool commaNeeded=true) {
17085      PRINT_SPACE
17086      _OUT << "{" << std::endl;
17087      INDENT(4);
17088
17089      print_VkStructureType(obj.sType, "sType", 1);
17090
17091       if (obj.pNext) {
17092          dumpPNextChain(obj.pNext);
17093       } else {
17094          PRINT_SPACE
17095          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17096      }
17097
17098      print_VkImageAspectFlagBits(obj.planeAspect, "planeAspect", 0);
17099
17100      INDENT(-4);
17101      PRINT_SPACE
17102      if (commaNeeded)
17103          _OUT << "}," << std::endl;
17104      else
17105          _OUT << "}" << std::endl;
17106 }
17107 static void print_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo * obj, const std::string& s, bool commaNeeded=true) {
17108      PRINT_SPACE
17109      _OUT << "{" << std::endl;
17110      INDENT(4);
17111
17112      print_VkStructureType(obj->sType, "sType", 1);
17113
17114       if (obj->pNext) {
17115          dumpPNextChain(obj->pNext);
17116       } else {
17117          PRINT_SPACE
17118          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17119      }
17120
17121      print_VkImageAspectFlagBits(obj->planeAspect, "planeAspect", 0);
17122
17123      INDENT(-4);
17124      PRINT_SPACE
17125      if (commaNeeded)
17126          _OUT << "}," << std::endl;
17127      else
17128          _OUT << "}" << std::endl;
17129 }
17130
17131 static void print_VkImagePlaneMemoryRequirementsInfo(VkImagePlaneMemoryRequirementsInfo obj, const std::string& s, bool commaNeeded=true) {
17132      PRINT_SPACE
17133      _OUT << "{" << std::endl;
17134      INDENT(4);
17135
17136      print_VkStructureType(obj.sType, "sType", 1);
17137
17138       if (obj.pNext) {
17139          dumpPNextChain(obj.pNext);
17140       } else {
17141          PRINT_SPACE
17142          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17143      }
17144
17145      print_VkImageAspectFlagBits(obj.planeAspect, "planeAspect", 0);
17146
17147      INDENT(-4);
17148      PRINT_SPACE
17149      if (commaNeeded)
17150          _OUT << "}," << std::endl;
17151      else
17152          _OUT << "}" << std::endl;
17153 }
17154 static void print_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo * obj, const std::string& s, bool commaNeeded=true) {
17155      PRINT_SPACE
17156      _OUT << "{" << std::endl;
17157      INDENT(4);
17158
17159      print_VkStructureType(obj->sType, "sType", 1);
17160
17161       if (obj->pNext) {
17162          dumpPNextChain(obj->pNext);
17163       } else {
17164          PRINT_SPACE
17165          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17166      }
17167
17168      print_VkImageAspectFlagBits(obj->planeAspect, "planeAspect", 0);
17169
17170      INDENT(-4);
17171      PRINT_SPACE
17172      if (commaNeeded)
17173          _OUT << "}," << std::endl;
17174      else
17175          _OUT << "}" << std::endl;
17176 }
17177
17178 static void print_VkPhysicalDeviceSamplerYcbcrConversionFeatures(VkPhysicalDeviceSamplerYcbcrConversionFeatures obj, const std::string& s, bool commaNeeded=true) {
17179      PRINT_SPACE
17180      _OUT << "{" << std::endl;
17181      INDENT(4);
17182
17183      print_VkStructureType(obj.sType, "sType", 1);
17184
17185       if (obj.pNext) {
17186          dumpPNextChain(obj.pNext);
17187       } else {
17188          PRINT_SPACE
17189          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17190      }
17191
17192      print_VkBool32(obj.samplerYcbcrConversion, "samplerYcbcrConversion", 0);
17193
17194      INDENT(-4);
17195      PRINT_SPACE
17196      if (commaNeeded)
17197          _OUT << "}," << std::endl;
17198      else
17199          _OUT << "}" << std::endl;
17200 }
17201 static void print_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * obj, const std::string& s, bool commaNeeded=true) {
17202      PRINT_SPACE
17203      _OUT << "{" << std::endl;
17204      INDENT(4);
17205
17206      print_VkStructureType(obj->sType, "sType", 1);
17207
17208       if (obj->pNext) {
17209          dumpPNextChain(obj->pNext);
17210       } else {
17211          PRINT_SPACE
17212          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17213      }
17214
17215      print_VkBool32(obj->samplerYcbcrConversion, "samplerYcbcrConversion", 0);
17216
17217      INDENT(-4);
17218      PRINT_SPACE
17219      if (commaNeeded)
17220          _OUT << "}," << std::endl;
17221      else
17222          _OUT << "}" << std::endl;
17223 }
17224
17225 static void print_VkSamplerYcbcrConversionImageFormatProperties(VkSamplerYcbcrConversionImageFormatProperties obj, const std::string& s, bool commaNeeded=true) {
17226      PRINT_SPACE
17227      _OUT << "{" << std::endl;
17228      INDENT(4);
17229
17230      print_VkStructureType(obj.sType, "sType", 1);
17231
17232       if (obj.pNext) {
17233          dumpPNextChain(obj.pNext);
17234       } else {
17235          PRINT_SPACE
17236          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17237      }
17238
17239      print_uint32_t(obj.combinedImageSamplerDescriptorCount, "combinedImageSamplerDescriptorCount", 0);
17240
17241      INDENT(-4);
17242      PRINT_SPACE
17243      if (commaNeeded)
17244          _OUT << "}," << std::endl;
17245      else
17246          _OUT << "}" << std::endl;
17247 }
17248 static void print_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties * obj, const std::string& s, bool commaNeeded=true) {
17249      PRINT_SPACE
17250      _OUT << "{" << std::endl;
17251      INDENT(4);
17252
17253      print_VkStructureType(obj->sType, "sType", 1);
17254
17255       if (obj->pNext) {
17256          dumpPNextChain(obj->pNext);
17257       } else {
17258          PRINT_SPACE
17259          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17260      }
17261
17262      print_uint32_t(obj->combinedImageSamplerDescriptorCount, "combinedImageSamplerDescriptorCount", 0);
17263
17264      INDENT(-4);
17265      PRINT_SPACE
17266      if (commaNeeded)
17267          _OUT << "}," << std::endl;
17268      else
17269          _OUT << "}" << std::endl;
17270 }
17271
17272 static void print_VkExternalMemoryProperties(VkExternalMemoryProperties obj, const std::string& s, bool commaNeeded=true) {
17273      PRINT_SPACE
17274      _OUT << "{" << std::endl;
17275      INDENT(4);
17276
17277      print_VkExternalMemoryFeatureFlags(obj.externalMemoryFeatures, "externalMemoryFeatures", 1);
17278
17279      print_VkExternalMemoryHandleTypeFlags(obj.exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1);
17280
17281      print_VkExternalMemoryHandleTypeFlags(obj.compatibleHandleTypes, "compatibleHandleTypes", 0);
17282
17283      INDENT(-4);
17284      PRINT_SPACE
17285      if (commaNeeded)
17286          _OUT << "}," << std::endl;
17287      else
17288          _OUT << "}" << std::endl;
17289 }
17290 static void print_VkExternalMemoryProperties(const VkExternalMemoryProperties * obj, const std::string& s, bool commaNeeded=true) {
17291      PRINT_SPACE
17292      _OUT << "{" << std::endl;
17293      INDENT(4);
17294
17295      print_VkExternalMemoryFeatureFlags(obj->externalMemoryFeatures, "externalMemoryFeatures", 1);
17296
17297      print_VkExternalMemoryHandleTypeFlags(obj->exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1);
17298
17299      print_VkExternalMemoryHandleTypeFlags(obj->compatibleHandleTypes, "compatibleHandleTypes", 0);
17300
17301      INDENT(-4);
17302      PRINT_SPACE
17303      if (commaNeeded)
17304          _OUT << "}," << std::endl;
17305      else
17306          _OUT << "}" << std::endl;
17307 }
17308
17309 static void print_VkPhysicalDeviceExternalImageFormatInfo(VkPhysicalDeviceExternalImageFormatInfo obj, const std::string& s, bool commaNeeded=true) {
17310      PRINT_SPACE
17311      _OUT << "{" << std::endl;
17312      INDENT(4);
17313
17314      print_VkStructureType(obj.sType, "sType", 1);
17315
17316       if (obj.pNext) {
17317          dumpPNextChain(obj.pNext);
17318       } else {
17319          PRINT_SPACE
17320          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17321      }
17322
17323      print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 0);
17324
17325      INDENT(-4);
17326      PRINT_SPACE
17327      if (commaNeeded)
17328          _OUT << "}," << std::endl;
17329      else
17330          _OUT << "}" << std::endl;
17331 }
17332 static void print_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo * obj, const std::string& s, bool commaNeeded=true) {
17333      PRINT_SPACE
17334      _OUT << "{" << std::endl;
17335      INDENT(4);
17336
17337      print_VkStructureType(obj->sType, "sType", 1);
17338
17339       if (obj->pNext) {
17340          dumpPNextChain(obj->pNext);
17341       } else {
17342          PRINT_SPACE
17343          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17344      }
17345
17346      print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 0);
17347
17348      INDENT(-4);
17349      PRINT_SPACE
17350      if (commaNeeded)
17351          _OUT << "}," << std::endl;
17352      else
17353          _OUT << "}" << std::endl;
17354 }
17355
17356 static void print_VkExternalImageFormatProperties(VkExternalImageFormatProperties obj, const std::string& s, bool commaNeeded=true) {
17357      PRINT_SPACE
17358      _OUT << "{" << std::endl;
17359      INDENT(4);
17360
17361      print_VkStructureType(obj.sType, "sType", 1);
17362
17363       if (obj.pNext) {
17364          dumpPNextChain(obj.pNext);
17365       } else {
17366          PRINT_SPACE
17367          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17368      }
17369
17370      PRINT_SPACE
17371      _OUT << "\"externalMemoryProperties\": " << std::endl;
17372      {
17373            print_VkExternalMemoryProperties(obj.externalMemoryProperties, "externalMemoryProperties", 0);
17374      }
17375
17376      INDENT(-4);
17377      PRINT_SPACE
17378      if (commaNeeded)
17379          _OUT << "}," << std::endl;
17380      else
17381          _OUT << "}" << std::endl;
17382 }
17383 static void print_VkExternalImageFormatProperties(const VkExternalImageFormatProperties * obj, const std::string& s, bool commaNeeded=true) {
17384      PRINT_SPACE
17385      _OUT << "{" << std::endl;
17386      INDENT(4);
17387
17388      print_VkStructureType(obj->sType, "sType", 1);
17389
17390       if (obj->pNext) {
17391          dumpPNextChain(obj->pNext);
17392       } else {
17393          PRINT_SPACE
17394          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17395      }
17396
17397      PRINT_SPACE
17398      _OUT << "\"externalMemoryProperties\": " << std::endl;
17399      {
17400            print_VkExternalMemoryProperties(obj->externalMemoryProperties, "externalMemoryProperties", 0);
17401      }
17402
17403      INDENT(-4);
17404      PRINT_SPACE
17405      if (commaNeeded)
17406          _OUT << "}," << std::endl;
17407      else
17408          _OUT << "}" << std::endl;
17409 }
17410
17411 static void print_VkPhysicalDeviceExternalBufferInfo(VkPhysicalDeviceExternalBufferInfo obj, const std::string& s, bool commaNeeded=true) {
17412      PRINT_SPACE
17413      _OUT << "{" << std::endl;
17414      INDENT(4);
17415
17416      print_VkStructureType(obj.sType, "sType", 1);
17417
17418       if (obj.pNext) {
17419          dumpPNextChain(obj.pNext);
17420       } else {
17421          PRINT_SPACE
17422          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17423      }
17424
17425      print_VkBufferCreateFlags(obj.flags, "flags", 1);
17426
17427      print_VkBufferUsageFlags(obj.usage, "usage", 1);
17428
17429      print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 0);
17430
17431      INDENT(-4);
17432      PRINT_SPACE
17433      if (commaNeeded)
17434          _OUT << "}," << std::endl;
17435      else
17436          _OUT << "}" << std::endl;
17437 }
17438 static void print_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo * obj, const std::string& s, bool commaNeeded=true) {
17439      PRINT_SPACE
17440      _OUT << "{" << std::endl;
17441      INDENT(4);
17442
17443      print_VkStructureType(obj->sType, "sType", 1);
17444
17445       if (obj->pNext) {
17446          dumpPNextChain(obj->pNext);
17447       } else {
17448          PRINT_SPACE
17449          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17450      }
17451
17452      print_VkBufferCreateFlags(obj->flags, "flags", 1);
17453
17454      print_VkBufferUsageFlags(obj->usage, "usage", 1);
17455
17456      print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 0);
17457
17458      INDENT(-4);
17459      PRINT_SPACE
17460      if (commaNeeded)
17461          _OUT << "}," << std::endl;
17462      else
17463          _OUT << "}" << std::endl;
17464 }
17465
17466 static void print_VkExternalBufferProperties(VkExternalBufferProperties obj, const std::string& s, bool commaNeeded=true) {
17467      PRINT_SPACE
17468      _OUT << "{" << std::endl;
17469      INDENT(4);
17470
17471      print_VkStructureType(obj.sType, "sType", 1);
17472
17473       if (obj.pNext) {
17474          dumpPNextChain(obj.pNext);
17475       } else {
17476          PRINT_SPACE
17477          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17478      }
17479
17480      PRINT_SPACE
17481      _OUT << "\"externalMemoryProperties\": " << std::endl;
17482      {
17483            print_VkExternalMemoryProperties(obj.externalMemoryProperties, "externalMemoryProperties", 0);
17484      }
17485
17486      INDENT(-4);
17487      PRINT_SPACE
17488      if (commaNeeded)
17489          _OUT << "}," << std::endl;
17490      else
17491          _OUT << "}" << std::endl;
17492 }
17493 static void print_VkExternalBufferProperties(const VkExternalBufferProperties * obj, const std::string& s, bool commaNeeded=true) {
17494      PRINT_SPACE
17495      _OUT << "{" << std::endl;
17496      INDENT(4);
17497
17498      print_VkStructureType(obj->sType, "sType", 1);
17499
17500       if (obj->pNext) {
17501          dumpPNextChain(obj->pNext);
17502       } else {
17503          PRINT_SPACE
17504          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17505      }
17506
17507      PRINT_SPACE
17508      _OUT << "\"externalMemoryProperties\": " << std::endl;
17509      {
17510            print_VkExternalMemoryProperties(obj->externalMemoryProperties, "externalMemoryProperties", 0);
17511      }
17512
17513      INDENT(-4);
17514      PRINT_SPACE
17515      if (commaNeeded)
17516          _OUT << "}," << std::endl;
17517      else
17518          _OUT << "}" << std::endl;
17519 }
17520
17521 static void print_VkPhysicalDeviceIDProperties(VkPhysicalDeviceIDProperties obj, const std::string& s, bool commaNeeded=true) {
17522      PRINT_SPACE
17523      _OUT << "{" << std::endl;
17524      INDENT(4);
17525
17526      print_VkStructureType(obj.sType, "sType", 1);
17527
17528       if (obj.pNext) {
17529          dumpPNextChain(obj.pNext);
17530       } else {
17531          PRINT_SPACE
17532          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17533      }
17534
17535      PRINT_SPACE
17536      _OUT << "\"deviceUUID\":" << std::endl;
17537      PRINT_SPACE
17538      if (obj.deviceUUID) {
17539        _OUT << "[" << std::endl;
17540        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
17541            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
17542            print_uint8_t(obj.deviceUUID[i], "", isCommaNeeded);
17543        }
17544        PRINT_SPACE
17545        _OUT << "]" << "," << std::endl;
17546      } else {
17547        _OUT << "\"NULL\"" << "," << std::endl;
17548      }
17549
17550      PRINT_SPACE
17551      _OUT << "\"driverUUID\":" << std::endl;
17552      PRINT_SPACE
17553      if (obj.driverUUID) {
17554        _OUT << "[" << std::endl;
17555        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
17556            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
17557            print_uint8_t(obj.driverUUID[i], "", isCommaNeeded);
17558        }
17559        PRINT_SPACE
17560        _OUT << "]" << "," << std::endl;
17561      } else {
17562        _OUT << "\"NULL\"" << "," << std::endl;
17563      }
17564
17565      PRINT_SPACE
17566      _OUT << "\"deviceLUID\":" << std::endl;
17567      PRINT_SPACE
17568      if (obj.deviceLUID) {
17569        _OUT << "[" << std::endl;
17570        for (unsigned int i = 0; i < VK_LUID_SIZE; i++) {
17571            bool isCommaNeeded = (i+1) != VK_LUID_SIZE;
17572            print_uint8_t(obj.deviceLUID[i], "", isCommaNeeded);
17573        }
17574        PRINT_SPACE
17575        _OUT << "]" << "," << std::endl;
17576      } else {
17577        _OUT << "\"NULL\"" << "," << std::endl;
17578      }
17579
17580      print_uint32_t(obj.deviceNodeMask, "deviceNodeMask", 1);
17581
17582      print_VkBool32(obj.deviceLUIDValid, "deviceLUIDValid", 0);
17583
17584      INDENT(-4);
17585      PRINT_SPACE
17586      if (commaNeeded)
17587          _OUT << "}," << std::endl;
17588      else
17589          _OUT << "}" << std::endl;
17590 }
17591 static void print_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties * obj, const std::string& s, bool commaNeeded=true) {
17592      PRINT_SPACE
17593      _OUT << "{" << std::endl;
17594      INDENT(4);
17595
17596      print_VkStructureType(obj->sType, "sType", 1);
17597
17598       if (obj->pNext) {
17599          dumpPNextChain(obj->pNext);
17600       } else {
17601          PRINT_SPACE
17602          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17603      }
17604
17605      PRINT_SPACE
17606      _OUT << "\"deviceUUID\":" << std::endl;
17607      PRINT_SPACE
17608      if (obj->deviceUUID) {
17609        _OUT << "[" << std::endl;
17610        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
17611            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
17612            print_uint8_t(obj->deviceUUID[i], "", isCommaNeeded);
17613        }
17614        PRINT_SPACE
17615        _OUT << "]" << "," << std::endl;
17616      } else {
17617        _OUT << "\"NULL\"" << "," << std::endl;
17618      }
17619
17620      PRINT_SPACE
17621      _OUT << "\"driverUUID\":" << std::endl;
17622      PRINT_SPACE
17623      if (obj->driverUUID) {
17624        _OUT << "[" << std::endl;
17625        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
17626            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
17627            print_uint8_t(obj->driverUUID[i], "", isCommaNeeded);
17628        }
17629        PRINT_SPACE
17630        _OUT << "]" << "," << std::endl;
17631      } else {
17632        _OUT << "\"NULL\"" << "," << std::endl;
17633      }
17634
17635      PRINT_SPACE
17636      _OUT << "\"deviceLUID\":" << std::endl;
17637      PRINT_SPACE
17638      if (obj->deviceLUID) {
17639        _OUT << "[" << std::endl;
17640        for (unsigned int i = 0; i < VK_LUID_SIZE; i++) {
17641            bool isCommaNeeded = (i+1) != VK_LUID_SIZE;
17642            print_uint8_t(obj->deviceLUID[i], "", isCommaNeeded);
17643        }
17644        PRINT_SPACE
17645        _OUT << "]" << "," << std::endl;
17646      } else {
17647        _OUT << "\"NULL\"" << "," << std::endl;
17648      }
17649
17650      print_uint32_t(obj->deviceNodeMask, "deviceNodeMask", 1);
17651
17652      print_VkBool32(obj->deviceLUIDValid, "deviceLUIDValid", 0);
17653
17654      INDENT(-4);
17655      PRINT_SPACE
17656      if (commaNeeded)
17657          _OUT << "}," << std::endl;
17658      else
17659          _OUT << "}" << std::endl;
17660 }
17661
17662 static void print_VkExternalMemoryImageCreateInfo(VkExternalMemoryImageCreateInfo obj, const std::string& s, bool commaNeeded=true) {
17663      PRINT_SPACE
17664      _OUT << "{" << std::endl;
17665      INDENT(4);
17666
17667      print_VkStructureType(obj.sType, "sType", 1);
17668
17669       if (obj.pNext) {
17670          dumpPNextChain(obj.pNext);
17671       } else {
17672          PRINT_SPACE
17673          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17674      }
17675
17676      print_VkExternalMemoryHandleTypeFlags(obj.handleTypes, "handleTypes", 0);
17677
17678      INDENT(-4);
17679      PRINT_SPACE
17680      if (commaNeeded)
17681          _OUT << "}," << std::endl;
17682      else
17683          _OUT << "}" << std::endl;
17684 }
17685 static void print_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
17686      PRINT_SPACE
17687      _OUT << "{" << std::endl;
17688      INDENT(4);
17689
17690      print_VkStructureType(obj->sType, "sType", 1);
17691
17692       if (obj->pNext) {
17693          dumpPNextChain(obj->pNext);
17694       } else {
17695          PRINT_SPACE
17696          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17697      }
17698
17699      print_VkExternalMemoryHandleTypeFlags(obj->handleTypes, "handleTypes", 0);
17700
17701      INDENT(-4);
17702      PRINT_SPACE
17703      if (commaNeeded)
17704          _OUT << "}," << std::endl;
17705      else
17706          _OUT << "}" << std::endl;
17707 }
17708
17709 static void print_VkExternalMemoryBufferCreateInfo(VkExternalMemoryBufferCreateInfo obj, const std::string& s, bool commaNeeded=true) {
17710      PRINT_SPACE
17711      _OUT << "{" << std::endl;
17712      INDENT(4);
17713
17714      print_VkStructureType(obj.sType, "sType", 1);
17715
17716       if (obj.pNext) {
17717          dumpPNextChain(obj.pNext);
17718       } else {
17719          PRINT_SPACE
17720          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17721      }
17722
17723      print_VkExternalMemoryHandleTypeFlags(obj.handleTypes, "handleTypes", 0);
17724
17725      INDENT(-4);
17726      PRINT_SPACE
17727      if (commaNeeded)
17728          _OUT << "}," << std::endl;
17729      else
17730          _OUT << "}" << std::endl;
17731 }
17732 static void print_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
17733      PRINT_SPACE
17734      _OUT << "{" << std::endl;
17735      INDENT(4);
17736
17737      print_VkStructureType(obj->sType, "sType", 1);
17738
17739       if (obj->pNext) {
17740          dumpPNextChain(obj->pNext);
17741       } else {
17742          PRINT_SPACE
17743          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17744      }
17745
17746      print_VkExternalMemoryHandleTypeFlags(obj->handleTypes, "handleTypes", 0);
17747
17748      INDENT(-4);
17749      PRINT_SPACE
17750      if (commaNeeded)
17751          _OUT << "}," << std::endl;
17752      else
17753          _OUT << "}" << std::endl;
17754 }
17755
17756 static void print_VkExportMemoryAllocateInfo(VkExportMemoryAllocateInfo obj, const std::string& s, bool commaNeeded=true) {
17757      PRINT_SPACE
17758      _OUT << "{" << std::endl;
17759      INDENT(4);
17760
17761      print_VkStructureType(obj.sType, "sType", 1);
17762
17763       if (obj.pNext) {
17764          dumpPNextChain(obj.pNext);
17765       } else {
17766          PRINT_SPACE
17767          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17768      }
17769
17770      print_VkExternalMemoryHandleTypeFlags(obj.handleTypes, "handleTypes", 0);
17771
17772      INDENT(-4);
17773      PRINT_SPACE
17774      if (commaNeeded)
17775          _OUT << "}," << std::endl;
17776      else
17777          _OUT << "}" << std::endl;
17778 }
17779 static void print_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo * obj, const std::string& s, bool commaNeeded=true) {
17780      PRINT_SPACE
17781      _OUT << "{" << std::endl;
17782      INDENT(4);
17783
17784      print_VkStructureType(obj->sType, "sType", 1);
17785
17786       if (obj->pNext) {
17787          dumpPNextChain(obj->pNext);
17788       } else {
17789          PRINT_SPACE
17790          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17791      }
17792
17793      print_VkExternalMemoryHandleTypeFlags(obj->handleTypes, "handleTypes", 0);
17794
17795      INDENT(-4);
17796      PRINT_SPACE
17797      if (commaNeeded)
17798          _OUT << "}," << std::endl;
17799      else
17800          _OUT << "}" << std::endl;
17801 }
17802
17803 static void print_VkPhysicalDeviceExternalFenceInfo(VkPhysicalDeviceExternalFenceInfo obj, const std::string& s, bool commaNeeded=true) {
17804      PRINT_SPACE
17805      _OUT << "{" << std::endl;
17806      INDENT(4);
17807
17808      print_VkStructureType(obj.sType, "sType", 1);
17809
17810       if (obj.pNext) {
17811          dumpPNextChain(obj.pNext);
17812       } else {
17813          PRINT_SPACE
17814          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17815      }
17816
17817      print_VkExternalFenceHandleTypeFlagBits(obj.handleType, "handleType", 0);
17818
17819      INDENT(-4);
17820      PRINT_SPACE
17821      if (commaNeeded)
17822          _OUT << "}," << std::endl;
17823      else
17824          _OUT << "}" << std::endl;
17825 }
17826 static void print_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo * obj, const std::string& s, bool commaNeeded=true) {
17827      PRINT_SPACE
17828      _OUT << "{" << std::endl;
17829      INDENT(4);
17830
17831      print_VkStructureType(obj->sType, "sType", 1);
17832
17833       if (obj->pNext) {
17834          dumpPNextChain(obj->pNext);
17835       } else {
17836          PRINT_SPACE
17837          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17838      }
17839
17840      print_VkExternalFenceHandleTypeFlagBits(obj->handleType, "handleType", 0);
17841
17842      INDENT(-4);
17843      PRINT_SPACE
17844      if (commaNeeded)
17845          _OUT << "}," << std::endl;
17846      else
17847          _OUT << "}" << std::endl;
17848 }
17849
17850 static void print_VkExternalFenceProperties(VkExternalFenceProperties obj, const std::string& s, bool commaNeeded=true) {
17851      PRINT_SPACE
17852      _OUT << "{" << std::endl;
17853      INDENT(4);
17854
17855      print_VkStructureType(obj.sType, "sType", 1);
17856
17857       if (obj.pNext) {
17858          dumpPNextChain(obj.pNext);
17859       } else {
17860          PRINT_SPACE
17861          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17862      }
17863
17864      print_VkExternalFenceHandleTypeFlags(obj.exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1);
17865
17866      print_VkExternalFenceHandleTypeFlags(obj.compatibleHandleTypes, "compatibleHandleTypes", 1);
17867
17868      print_VkExternalFenceFeatureFlags(obj.externalFenceFeatures, "externalFenceFeatures", 0);
17869
17870      INDENT(-4);
17871      PRINT_SPACE
17872      if (commaNeeded)
17873          _OUT << "}," << std::endl;
17874      else
17875          _OUT << "}" << std::endl;
17876 }
17877 static void print_VkExternalFenceProperties(const VkExternalFenceProperties * obj, const std::string& s, bool commaNeeded=true) {
17878      PRINT_SPACE
17879      _OUT << "{" << std::endl;
17880      INDENT(4);
17881
17882      print_VkStructureType(obj->sType, "sType", 1);
17883
17884       if (obj->pNext) {
17885          dumpPNextChain(obj->pNext);
17886       } else {
17887          PRINT_SPACE
17888          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17889      }
17890
17891      print_VkExternalFenceHandleTypeFlags(obj->exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1);
17892
17893      print_VkExternalFenceHandleTypeFlags(obj->compatibleHandleTypes, "compatibleHandleTypes", 1);
17894
17895      print_VkExternalFenceFeatureFlags(obj->externalFenceFeatures, "externalFenceFeatures", 0);
17896
17897      INDENT(-4);
17898      PRINT_SPACE
17899      if (commaNeeded)
17900          _OUT << "}," << std::endl;
17901      else
17902          _OUT << "}" << std::endl;
17903 }
17904
17905 static void print_VkExportFenceCreateInfo(VkExportFenceCreateInfo obj, const std::string& s, bool commaNeeded=true) {
17906      PRINT_SPACE
17907      _OUT << "{" << std::endl;
17908      INDENT(4);
17909
17910      print_VkStructureType(obj.sType, "sType", 1);
17911
17912       if (obj.pNext) {
17913          dumpPNextChain(obj.pNext);
17914       } else {
17915          PRINT_SPACE
17916          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17917      }
17918
17919      print_VkExternalFenceHandleTypeFlags(obj.handleTypes, "handleTypes", 0);
17920
17921      INDENT(-4);
17922      PRINT_SPACE
17923      if (commaNeeded)
17924          _OUT << "}," << std::endl;
17925      else
17926          _OUT << "}" << std::endl;
17927 }
17928 static void print_VkExportFenceCreateInfo(const VkExportFenceCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
17929      PRINT_SPACE
17930      _OUT << "{" << std::endl;
17931      INDENT(4);
17932
17933      print_VkStructureType(obj->sType, "sType", 1);
17934
17935       if (obj->pNext) {
17936          dumpPNextChain(obj->pNext);
17937       } else {
17938          PRINT_SPACE
17939          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17940      }
17941
17942      print_VkExternalFenceHandleTypeFlags(obj->handleTypes, "handleTypes", 0);
17943
17944      INDENT(-4);
17945      PRINT_SPACE
17946      if (commaNeeded)
17947          _OUT << "}," << std::endl;
17948      else
17949          _OUT << "}" << std::endl;
17950 }
17951
17952 static void print_VkExportSemaphoreCreateInfo(VkExportSemaphoreCreateInfo obj, const std::string& s, bool commaNeeded=true) {
17953      PRINT_SPACE
17954      _OUT << "{" << std::endl;
17955      INDENT(4);
17956
17957      print_VkStructureType(obj.sType, "sType", 1);
17958
17959       if (obj.pNext) {
17960          dumpPNextChain(obj.pNext);
17961       } else {
17962          PRINT_SPACE
17963          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17964      }
17965
17966      print_VkExternalSemaphoreHandleTypeFlags(obj.handleTypes, "handleTypes", 0);
17967
17968      INDENT(-4);
17969      PRINT_SPACE
17970      if (commaNeeded)
17971          _OUT << "}," << std::endl;
17972      else
17973          _OUT << "}" << std::endl;
17974 }
17975 static void print_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
17976      PRINT_SPACE
17977      _OUT << "{" << std::endl;
17978      INDENT(4);
17979
17980      print_VkStructureType(obj->sType, "sType", 1);
17981
17982       if (obj->pNext) {
17983          dumpPNextChain(obj->pNext);
17984       } else {
17985          PRINT_SPACE
17986          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
17987      }
17988
17989      print_VkExternalSemaphoreHandleTypeFlags(obj->handleTypes, "handleTypes", 0);
17990
17991      INDENT(-4);
17992      PRINT_SPACE
17993      if (commaNeeded)
17994          _OUT << "}," << std::endl;
17995      else
17996          _OUT << "}" << std::endl;
17997 }
17998
17999 static void print_VkPhysicalDeviceExternalSemaphoreInfo(VkPhysicalDeviceExternalSemaphoreInfo obj, const std::string& s, bool commaNeeded=true) {
18000      PRINT_SPACE
18001      _OUT << "{" << std::endl;
18002      INDENT(4);
18003
18004      print_VkStructureType(obj.sType, "sType", 1);
18005
18006       if (obj.pNext) {
18007          dumpPNextChain(obj.pNext);
18008       } else {
18009          PRINT_SPACE
18010          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18011      }
18012
18013      print_VkExternalSemaphoreHandleTypeFlagBits(obj.handleType, "handleType", 0);
18014
18015      INDENT(-4);
18016      PRINT_SPACE
18017      if (commaNeeded)
18018          _OUT << "}," << std::endl;
18019      else
18020          _OUT << "}" << std::endl;
18021 }
18022 static void print_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo * obj, const std::string& s, bool commaNeeded=true) {
18023      PRINT_SPACE
18024      _OUT << "{" << std::endl;
18025      INDENT(4);
18026
18027      print_VkStructureType(obj->sType, "sType", 1);
18028
18029       if (obj->pNext) {
18030          dumpPNextChain(obj->pNext);
18031       } else {
18032          PRINT_SPACE
18033          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18034      }
18035
18036      print_VkExternalSemaphoreHandleTypeFlagBits(obj->handleType, "handleType", 0);
18037
18038      INDENT(-4);
18039      PRINT_SPACE
18040      if (commaNeeded)
18041          _OUT << "}," << std::endl;
18042      else
18043          _OUT << "}" << std::endl;
18044 }
18045
18046 static void print_VkExternalSemaphoreProperties(VkExternalSemaphoreProperties obj, const std::string& s, bool commaNeeded=true) {
18047      PRINT_SPACE
18048      _OUT << "{" << std::endl;
18049      INDENT(4);
18050
18051      print_VkStructureType(obj.sType, "sType", 1);
18052
18053       if (obj.pNext) {
18054          dumpPNextChain(obj.pNext);
18055       } else {
18056          PRINT_SPACE
18057          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18058      }
18059
18060      print_VkExternalSemaphoreHandleTypeFlags(obj.exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1);
18061
18062      print_VkExternalSemaphoreHandleTypeFlags(obj.compatibleHandleTypes, "compatibleHandleTypes", 1);
18063
18064      print_VkExternalSemaphoreFeatureFlags(obj.externalSemaphoreFeatures, "externalSemaphoreFeatures", 0);
18065
18066      INDENT(-4);
18067      PRINT_SPACE
18068      if (commaNeeded)
18069          _OUT << "}," << std::endl;
18070      else
18071          _OUT << "}" << std::endl;
18072 }
18073 static void print_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties * obj, const std::string& s, bool commaNeeded=true) {
18074      PRINT_SPACE
18075      _OUT << "{" << std::endl;
18076      INDENT(4);
18077
18078      print_VkStructureType(obj->sType, "sType", 1);
18079
18080       if (obj->pNext) {
18081          dumpPNextChain(obj->pNext);
18082       } else {
18083          PRINT_SPACE
18084          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18085      }
18086
18087      print_VkExternalSemaphoreHandleTypeFlags(obj->exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1);
18088
18089      print_VkExternalSemaphoreHandleTypeFlags(obj->compatibleHandleTypes, "compatibleHandleTypes", 1);
18090
18091      print_VkExternalSemaphoreFeatureFlags(obj->externalSemaphoreFeatures, "externalSemaphoreFeatures", 0);
18092
18093      INDENT(-4);
18094      PRINT_SPACE
18095      if (commaNeeded)
18096          _OUT << "}," << std::endl;
18097      else
18098          _OUT << "}" << std::endl;
18099 }
18100
18101 static void print_VkPhysicalDeviceMaintenance3Properties(VkPhysicalDeviceMaintenance3Properties obj, const std::string& s, bool commaNeeded=true) {
18102      PRINT_SPACE
18103      _OUT << "{" << std::endl;
18104      INDENT(4);
18105
18106      print_VkStructureType(obj.sType, "sType", 1);
18107
18108       if (obj.pNext) {
18109          dumpPNextChain(obj.pNext);
18110       } else {
18111          PRINT_SPACE
18112          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18113      }
18114
18115      print_uint32_t(obj.maxPerSetDescriptors, "maxPerSetDescriptors", 1);
18116
18117      print_VkDeviceSize(obj.maxMemoryAllocationSize, "maxMemoryAllocationSize", 0);
18118
18119      INDENT(-4);
18120      PRINT_SPACE
18121      if (commaNeeded)
18122          _OUT << "}," << std::endl;
18123      else
18124          _OUT << "}" << std::endl;
18125 }
18126 static void print_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties * obj, const std::string& s, bool commaNeeded=true) {
18127      PRINT_SPACE
18128      _OUT << "{" << std::endl;
18129      INDENT(4);
18130
18131      print_VkStructureType(obj->sType, "sType", 1);
18132
18133       if (obj->pNext) {
18134          dumpPNextChain(obj->pNext);
18135       } else {
18136          PRINT_SPACE
18137          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18138      }
18139
18140      print_uint32_t(obj->maxPerSetDescriptors, "maxPerSetDescriptors", 1);
18141
18142      print_VkDeviceSize(obj->maxMemoryAllocationSize, "maxMemoryAllocationSize", 0);
18143
18144      INDENT(-4);
18145      PRINT_SPACE
18146      if (commaNeeded)
18147          _OUT << "}," << std::endl;
18148      else
18149          _OUT << "}" << std::endl;
18150 }
18151
18152 static void print_VkDescriptorSetLayoutSupport(VkDescriptorSetLayoutSupport obj, const std::string& s, bool commaNeeded=true) {
18153      PRINT_SPACE
18154      _OUT << "{" << std::endl;
18155      INDENT(4);
18156
18157      print_VkStructureType(obj.sType, "sType", 1);
18158
18159       if (obj.pNext) {
18160          dumpPNextChain(obj.pNext);
18161       } else {
18162          PRINT_SPACE
18163          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18164      }
18165
18166      print_VkBool32(obj.supported, "supported", 0);
18167
18168      INDENT(-4);
18169      PRINT_SPACE
18170      if (commaNeeded)
18171          _OUT << "}," << std::endl;
18172      else
18173          _OUT << "}" << std::endl;
18174 }
18175 static void print_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport * obj, const std::string& s, bool commaNeeded=true) {
18176      PRINT_SPACE
18177      _OUT << "{" << std::endl;
18178      INDENT(4);
18179
18180      print_VkStructureType(obj->sType, "sType", 1);
18181
18182       if (obj->pNext) {
18183          dumpPNextChain(obj->pNext);
18184       } else {
18185          PRINT_SPACE
18186          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18187      }
18188
18189      print_VkBool32(obj->supported, "supported", 0);
18190
18191      INDENT(-4);
18192      PRINT_SPACE
18193      if (commaNeeded)
18194          _OUT << "}," << std::endl;
18195      else
18196          _OUT << "}" << std::endl;
18197 }
18198
18199 static void print_VkPhysicalDeviceShaderDrawParametersFeatures(VkPhysicalDeviceShaderDrawParametersFeatures obj, const std::string& s, bool commaNeeded=true) {
18200      PRINT_SPACE
18201      _OUT << "{" << std::endl;
18202      INDENT(4);
18203
18204      print_VkStructureType(obj.sType, "sType", 1);
18205
18206       if (obj.pNext) {
18207          dumpPNextChain(obj.pNext);
18208       } else {
18209          PRINT_SPACE
18210          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18211      }
18212
18213      print_VkBool32(obj.shaderDrawParameters, "shaderDrawParameters", 0);
18214
18215      INDENT(-4);
18216      PRINT_SPACE
18217      if (commaNeeded)
18218          _OUT << "}," << std::endl;
18219      else
18220          _OUT << "}" << std::endl;
18221 }
18222 static void print_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures * obj, const std::string& s, bool commaNeeded=true) {
18223      PRINT_SPACE
18224      _OUT << "{" << std::endl;
18225      INDENT(4);
18226
18227      print_VkStructureType(obj->sType, "sType", 1);
18228
18229       if (obj->pNext) {
18230          dumpPNextChain(obj->pNext);
18231       } else {
18232          PRINT_SPACE
18233          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18234      }
18235
18236      print_VkBool32(obj->shaderDrawParameters, "shaderDrawParameters", 0);
18237
18238      INDENT(-4);
18239      PRINT_SPACE
18240      if (commaNeeded)
18241          _OUT << "}," << std::endl;
18242      else
18243          _OUT << "}" << std::endl;
18244 }
18245
18246 typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures;
18247
18248 static std::map<deUint64, std::string> VkDriverId_map = {
18249     std::make_pair(1, "VK_DRIVER_ID_AMD_PROPRIETARY"),
18250     std::make_pair(2, "VK_DRIVER_ID_AMD_OPEN_SOURCE"),
18251     std::make_pair(3, "VK_DRIVER_ID_MESA_RADV"),
18252     std::make_pair(4, "VK_DRIVER_ID_NVIDIA_PROPRIETARY"),
18253     std::make_pair(5, "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS"),
18254     std::make_pair(6, "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA"),
18255     std::make_pair(7, "VK_DRIVER_ID_IMAGINATION_PROPRIETARY"),
18256     std::make_pair(8, "VK_DRIVER_ID_QUALCOMM_PROPRIETARY"),
18257     std::make_pair(9, "VK_DRIVER_ID_ARM_PROPRIETARY"),
18258     std::make_pair(10, "VK_DRIVER_ID_GOOGLE_SWIFTSHADER"),
18259     std::make_pair(11, "VK_DRIVER_ID_GGP_PROPRIETARY"),
18260     std::make_pair(12, "VK_DRIVER_ID_BROADCOM_PROPRIETARY"),
18261     std::make_pair(13, "VK_DRIVER_ID_MESA_LLVMPIPE"),
18262     std::make_pair(14, "VK_DRIVER_ID_MOLTENVK"),
18263     std::make_pair(15, "VK_DRIVER_ID_COREAVI_PROPRIETARY"),
18264     std::make_pair(16, "VK_DRIVER_ID_JUICE_PROPRIETARY"),
18265     std::make_pair(17, "VK_DRIVER_ID_VERISILICON_PROPRIETARY"),
18266     std::make_pair(18, "VK_DRIVER_ID_MESA_TURNIP"),
18267     std::make_pair(19, "VK_DRIVER_ID_MESA_V3DV"),
18268     std::make_pair(20, "VK_DRIVER_ID_MESA_PANVK"),
18269     std::make_pair(21, "VK_DRIVER_ID_SAMSUNG_PROPRIETARY"),
18270 };
18271 static void print_VkDriverId(VkDriverId obj, const std::string& str, bool commaNeeded=true) {
18272      PRINT_SPACE
18273      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18274      if (commaNeeded)
18275          _OUT << "\"" <<  VkDriverId_map[obj] << "\"," << std::endl;
18276      else
18277          _OUT << "\"" << VkDriverId_map[obj] << "\"" << std::endl;
18278 }
18279 static void print_VkDriverId(const VkDriverId * obj, const std::string& str, bool commaNeeded=true) {
18280      PRINT_SPACE
18281      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18282      if (commaNeeded)
18283          _OUT << "\"" <<  VkDriverId_map[*obj] << "\"," << std::endl;
18284      else
18285          _OUT << "\"" << VkDriverId_map[*obj] << "\"" << std::endl;
18286 }
18287
18288 static std::map<deUint64, std::string> VkShaderFloatControlsIndependence_map = {
18289     std::make_pair(0, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY"),
18290     std::make_pair(1, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL"),
18291     std::make_pair(2, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE"),
18292 };
18293 static void print_VkShaderFloatControlsIndependence(VkShaderFloatControlsIndependence obj, const std::string& str, bool commaNeeded=true) {
18294      PRINT_SPACE
18295      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18296      if (commaNeeded)
18297          _OUT << "\"" <<  VkShaderFloatControlsIndependence_map[obj] << "\"," << std::endl;
18298      else
18299          _OUT << "\"" << VkShaderFloatControlsIndependence_map[obj] << "\"" << std::endl;
18300 }
18301 static void print_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence * obj, const std::string& str, bool commaNeeded=true) {
18302      PRINT_SPACE
18303      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18304      if (commaNeeded)
18305          _OUT << "\"" <<  VkShaderFloatControlsIndependence_map[*obj] << "\"," << std::endl;
18306      else
18307          _OUT << "\"" << VkShaderFloatControlsIndependence_map[*obj] << "\"" << std::endl;
18308 }
18309
18310 static std::map<deUint64, std::string> VkResolveModeFlagBits_map = {
18311     std::make_pair(0, "VK_RESOLVE_MODE_NONE"),
18312     std::make_pair(1ULL << 0, "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT"),
18313     std::make_pair(1ULL << 1, "VK_RESOLVE_MODE_AVERAGE_BIT"),
18314     std::make_pair(1ULL << 2, "VK_RESOLVE_MODE_MIN_BIT"),
18315     std::make_pair(1ULL << 3, "VK_RESOLVE_MODE_MAX_BIT"),
18316 };
18317 static void print_VkResolveModeFlagBits(VkResolveModeFlagBits obj, const std::string& str, bool commaNeeded=true) {
18318      PRINT_SPACE
18319      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18320      if (commaNeeded)
18321          _OUT << "\"" <<  VkResolveModeFlagBits_map[obj] << "\"," << std::endl;
18322      else
18323          _OUT << "\"" << VkResolveModeFlagBits_map[obj] << "\"" << std::endl;
18324 }
18325 static void print_VkResolveModeFlagBits(const VkResolveModeFlagBits * obj, const std::string& str, bool commaNeeded=true) {
18326      PRINT_SPACE
18327      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18328      if (commaNeeded)
18329          _OUT << "\"" <<  VkResolveModeFlagBits_map[*obj] << "\"," << std::endl;
18330      else
18331          _OUT << "\"" << VkResolveModeFlagBits_map[*obj] << "\"" << std::endl;
18332 }
18333
18334 static std::map<deUint64, std::string> VkDescriptorBindingFlagBits_map = {
18335     std::make_pair(1ULL << 0, "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT"),
18336     std::make_pair(1ULL << 1, "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT"),
18337     std::make_pair(1ULL << 2, "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT"),
18338     std::make_pair(1ULL << 3, "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT"),
18339     std::make_pair(1ULL << 4, "VK_DESCRIPTOR_BINDING_RESERVED_4_BIT_QCOM"),
18340 };
18341 static void print_VkDescriptorBindingFlagBits(VkDescriptorBindingFlagBits obj, const std::string& str, bool commaNeeded=true) {
18342      PRINT_SPACE
18343      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18344      if (commaNeeded)
18345          _OUT << "\"" <<  VkDescriptorBindingFlagBits_map[obj] << "\"," << std::endl;
18346      else
18347          _OUT << "\"" << VkDescriptorBindingFlagBits_map[obj] << "\"" << std::endl;
18348 }
18349 static void print_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits * obj, const std::string& str, bool commaNeeded=true) {
18350      PRINT_SPACE
18351      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18352      if (commaNeeded)
18353          _OUT << "\"" <<  VkDescriptorBindingFlagBits_map[*obj] << "\"," << std::endl;
18354      else
18355          _OUT << "\"" << VkDescriptorBindingFlagBits_map[*obj] << "\"" << std::endl;
18356 }
18357
18358 static std::map<deUint64, std::string> VkSamplerReductionMode_map = {
18359     std::make_pair(0, "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE"),
18360     std::make_pair(1, "VK_SAMPLER_REDUCTION_MODE_MIN"),
18361     std::make_pair(2, "VK_SAMPLER_REDUCTION_MODE_MAX"),
18362 };
18363 static void print_VkSamplerReductionMode(VkSamplerReductionMode obj, const std::string& str, bool commaNeeded=true) {
18364      PRINT_SPACE
18365      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18366      if (commaNeeded)
18367          _OUT << "\"" <<  VkSamplerReductionMode_map[obj] << "\"," << std::endl;
18368      else
18369          _OUT << "\"" << VkSamplerReductionMode_map[obj] << "\"" << std::endl;
18370 }
18371 static void print_VkSamplerReductionMode(const VkSamplerReductionMode * obj, const std::string& str, bool commaNeeded=true) {
18372      PRINT_SPACE
18373      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18374      if (commaNeeded)
18375          _OUT << "\"" <<  VkSamplerReductionMode_map[*obj] << "\"," << std::endl;
18376      else
18377          _OUT << "\"" << VkSamplerReductionMode_map[*obj] << "\"" << std::endl;
18378 }
18379
18380 static std::map<deUint64, std::string> VkSemaphoreType_map = {
18381     std::make_pair(0, "VK_SEMAPHORE_TYPE_BINARY"),
18382     std::make_pair(1, "VK_SEMAPHORE_TYPE_TIMELINE"),
18383 };
18384 static void print_VkSemaphoreType(VkSemaphoreType obj, const std::string& str, bool commaNeeded=true) {
18385      PRINT_SPACE
18386      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18387      if (commaNeeded)
18388          _OUT << "\"" <<  VkSemaphoreType_map[obj] << "\"," << std::endl;
18389      else
18390          _OUT << "\"" << VkSemaphoreType_map[obj] << "\"" << std::endl;
18391 }
18392 static void print_VkSemaphoreType(const VkSemaphoreType * obj, const std::string& str, bool commaNeeded=true) {
18393      PRINT_SPACE
18394      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18395      if (commaNeeded)
18396          _OUT << "\"" <<  VkSemaphoreType_map[*obj] << "\"," << std::endl;
18397      else
18398          _OUT << "\"" << VkSemaphoreType_map[*obj] << "\"" << std::endl;
18399 }
18400
18401 static std::map<deUint64, std::string> VkSemaphoreWaitFlagBits_map = {
18402     std::make_pair(1ULL << 0, "VK_SEMAPHORE_WAIT_ANY_BIT"),
18403 };
18404 static void print_VkSemaphoreWaitFlagBits(VkSemaphoreWaitFlagBits obj, const std::string& str, bool commaNeeded=true) {
18405      PRINT_SPACE
18406      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18407      if (commaNeeded)
18408          _OUT << "\"" <<  VkSemaphoreWaitFlagBits_map[obj] << "\"," << std::endl;
18409      else
18410          _OUT << "\"" << VkSemaphoreWaitFlagBits_map[obj] << "\"" << std::endl;
18411 }
18412 static void print_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits * obj, const std::string& str, bool commaNeeded=true) {
18413      PRINT_SPACE
18414      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18415      if (commaNeeded)
18416          _OUT << "\"" <<  VkSemaphoreWaitFlagBits_map[*obj] << "\"," << std::endl;
18417      else
18418          _OUT << "\"" << VkSemaphoreWaitFlagBits_map[*obj] << "\"" << std::endl;
18419 }
18420
18421 static void print_VkResolveModeFlags(VkResolveModeFlags obj, const std::string& str, bool commaNeeded=true) {
18422      PRINT_SPACE
18423      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18424      const int max_bits = 64; // We don't expect the number to be larger.
18425      std::bitset<max_bits> b(obj);
18426      _OUT << "\"";
18427      if (obj == 0) _OUT << "0";
18428      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
18429          if (b[i] == 1) {
18430              bitCount++;
18431              if (bitCount < b.count())
18432                  _OUT << VkResolveModeFlagBits_map[1ULL<<i] << " | ";
18433              else
18434                  _OUT << VkResolveModeFlagBits_map[1ULL<<i];
18435          }
18436      }
18437      if (commaNeeded)
18438        _OUT << "\"" << ",";
18439      else
18440        _OUT << "\""<< "";
18441      _OUT << std::endl;
18442 }
18443 static void print_VkResolveModeFlags(const VkResolveModeFlags * obj, const std::string& str, bool commaNeeded=true) {
18444      PRINT_SPACE
18445      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18446      const int max_bits = 64; // We don't expect the number to be larger.
18447      std::bitset<max_bits> b(obj);
18448      _OUT << "\"";
18449      if (obj == 0) _OUT << "0";
18450      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
18451          if (b[i] == 1) {
18452              bitCount++;
18453              if (bitCount < b.count())
18454                  _OUT << VkResolveModeFlagBits_map[1ULL<<i] << " | ";
18455              else
18456                  _OUT << VkResolveModeFlagBits_map[1ULL<<i];
18457          }
18458      }
18459      if (commaNeeded)
18460        _OUT << "\"" << ",";
18461      else
18462        _OUT << "\""<< "";
18463      _OUT << std::endl;
18464 }
18465
18466 static void print_VkDescriptorBindingFlags(VkDescriptorBindingFlags obj, const std::string& str, bool commaNeeded=true) {
18467      PRINT_SPACE
18468      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18469      const int max_bits = 64; // We don't expect the number to be larger.
18470      std::bitset<max_bits> b(obj);
18471      _OUT << "\"";
18472      if (obj == 0) _OUT << "0";
18473      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
18474          if (b[i] == 1) {
18475              bitCount++;
18476              if (bitCount < b.count())
18477                  _OUT << VkDescriptorBindingFlagBits_map[1ULL<<i] << " | ";
18478              else
18479                  _OUT << VkDescriptorBindingFlagBits_map[1ULL<<i];
18480          }
18481      }
18482      if (commaNeeded)
18483        _OUT << "\"" << ",";
18484      else
18485        _OUT << "\""<< "";
18486      _OUT << std::endl;
18487 }
18488 static void print_VkDescriptorBindingFlags(const VkDescriptorBindingFlags * obj, const std::string& str, bool commaNeeded=true) {
18489      PRINT_SPACE
18490      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18491      const int max_bits = 64; // We don't expect the number to be larger.
18492      std::bitset<max_bits> b(obj);
18493      _OUT << "\"";
18494      if (obj == 0) _OUT << "0";
18495      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
18496          if (b[i] == 1) {
18497              bitCount++;
18498              if (bitCount < b.count())
18499                  _OUT << VkDescriptorBindingFlagBits_map[1ULL<<i] << " | ";
18500              else
18501                  _OUT << VkDescriptorBindingFlagBits_map[1ULL<<i];
18502          }
18503      }
18504      if (commaNeeded)
18505        _OUT << "\"" << ",";
18506      else
18507        _OUT << "\""<< "";
18508      _OUT << std::endl;
18509 }
18510
18511 static void print_VkSemaphoreWaitFlags(VkSemaphoreWaitFlags obj, const std::string& str, bool commaNeeded=true) {
18512      PRINT_SPACE
18513      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18514      const int max_bits = 64; // We don't expect the number to be larger.
18515      std::bitset<max_bits> b(obj);
18516      _OUT << "\"";
18517      if (obj == 0) _OUT << "0";
18518      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
18519          if (b[i] == 1) {
18520              bitCount++;
18521              if (bitCount < b.count())
18522                  _OUT << VkSemaphoreWaitFlagBits_map[1ULL<<i] << " | ";
18523              else
18524                  _OUT << VkSemaphoreWaitFlagBits_map[1ULL<<i];
18525          }
18526      }
18527      if (commaNeeded)
18528        _OUT << "\"" << ",";
18529      else
18530        _OUT << "\""<< "";
18531      _OUT << std::endl;
18532 }
18533 static void print_VkSemaphoreWaitFlags(const VkSemaphoreWaitFlags * obj, const std::string& str, bool commaNeeded=true) {
18534      PRINT_SPACE
18535      if (str != "") _OUT << "\"" << str << "\"" << " : ";
18536      const int max_bits = 64; // We don't expect the number to be larger.
18537      std::bitset<max_bits> b(obj);
18538      _OUT << "\"";
18539      if (obj == 0) _OUT << "0";
18540      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
18541          if (b[i] == 1) {
18542              bitCount++;
18543              if (bitCount < b.count())
18544                  _OUT << VkSemaphoreWaitFlagBits_map[1ULL<<i] << " | ";
18545              else
18546                  _OUT << VkSemaphoreWaitFlagBits_map[1ULL<<i];
18547          }
18548      }
18549      if (commaNeeded)
18550        _OUT << "\"" << ",";
18551      else
18552        _OUT << "\""<< "";
18553      _OUT << std::endl;
18554 }
18555
18556 static void print_VkPhysicalDeviceVulkan11Features(VkPhysicalDeviceVulkan11Features obj, const std::string& s, bool commaNeeded=true) {
18557      PRINT_SPACE
18558      _OUT << "{" << std::endl;
18559      INDENT(4);
18560
18561      print_VkStructureType(obj.sType, "sType", 1);
18562
18563       if (obj.pNext) {
18564          dumpPNextChain(obj.pNext);
18565       } else {
18566          PRINT_SPACE
18567          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18568      }
18569
18570      print_VkBool32(obj.storageBuffer16BitAccess, "storageBuffer16BitAccess", 1);
18571
18572      print_VkBool32(obj.uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1);
18573
18574      print_VkBool32(obj.storagePushConstant16, "storagePushConstant16", 1);
18575
18576      print_VkBool32(obj.storageInputOutput16, "storageInputOutput16", 1);
18577
18578      print_VkBool32(obj.multiview, "multiview", 1);
18579
18580      print_VkBool32(obj.multiviewGeometryShader, "multiviewGeometryShader", 1);
18581
18582      print_VkBool32(obj.multiviewTessellationShader, "multiviewTessellationShader", 1);
18583
18584      print_VkBool32(obj.variablePointersStorageBuffer, "variablePointersStorageBuffer", 1);
18585
18586      print_VkBool32(obj.variablePointers, "variablePointers", 1);
18587
18588      print_VkBool32(obj.protectedMemory, "protectedMemory", 1);
18589
18590      print_VkBool32(obj.samplerYcbcrConversion, "samplerYcbcrConversion", 1);
18591
18592      print_VkBool32(obj.shaderDrawParameters, "shaderDrawParameters", 0);
18593
18594      INDENT(-4);
18595      PRINT_SPACE
18596      if (commaNeeded)
18597          _OUT << "}," << std::endl;
18598      else
18599          _OUT << "}" << std::endl;
18600 }
18601 static void print_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features * obj, const std::string& s, bool commaNeeded=true) {
18602      PRINT_SPACE
18603      _OUT << "{" << std::endl;
18604      INDENT(4);
18605
18606      print_VkStructureType(obj->sType, "sType", 1);
18607
18608       if (obj->pNext) {
18609          dumpPNextChain(obj->pNext);
18610       } else {
18611          PRINT_SPACE
18612          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18613      }
18614
18615      print_VkBool32(obj->storageBuffer16BitAccess, "storageBuffer16BitAccess", 1);
18616
18617      print_VkBool32(obj->uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1);
18618
18619      print_VkBool32(obj->storagePushConstant16, "storagePushConstant16", 1);
18620
18621      print_VkBool32(obj->storageInputOutput16, "storageInputOutput16", 1);
18622
18623      print_VkBool32(obj->multiview, "multiview", 1);
18624
18625      print_VkBool32(obj->multiviewGeometryShader, "multiviewGeometryShader", 1);
18626
18627      print_VkBool32(obj->multiviewTessellationShader, "multiviewTessellationShader", 1);
18628
18629      print_VkBool32(obj->variablePointersStorageBuffer, "variablePointersStorageBuffer", 1);
18630
18631      print_VkBool32(obj->variablePointers, "variablePointers", 1);
18632
18633      print_VkBool32(obj->protectedMemory, "protectedMemory", 1);
18634
18635      print_VkBool32(obj->samplerYcbcrConversion, "samplerYcbcrConversion", 1);
18636
18637      print_VkBool32(obj->shaderDrawParameters, "shaderDrawParameters", 0);
18638
18639      INDENT(-4);
18640      PRINT_SPACE
18641      if (commaNeeded)
18642          _OUT << "}," << std::endl;
18643      else
18644          _OUT << "}" << std::endl;
18645 }
18646
18647 static void print_VkPhysicalDeviceVulkan11Properties(VkPhysicalDeviceVulkan11Properties obj, const std::string& s, bool commaNeeded=true) {
18648      PRINT_SPACE
18649      _OUT << "{" << std::endl;
18650      INDENT(4);
18651
18652      print_VkStructureType(obj.sType, "sType", 1);
18653
18654       if (obj.pNext) {
18655          dumpPNextChain(obj.pNext);
18656       } else {
18657          PRINT_SPACE
18658          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18659      }
18660
18661      PRINT_SPACE
18662      _OUT << "\"deviceUUID\":" << std::endl;
18663      PRINT_SPACE
18664      if (obj.deviceUUID) {
18665        _OUT << "[" << std::endl;
18666        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
18667            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
18668            print_uint8_t(obj.deviceUUID[i], "", isCommaNeeded);
18669        }
18670        PRINT_SPACE
18671        _OUT << "]" << "," << std::endl;
18672      } else {
18673        _OUT << "\"NULL\"" << "," << std::endl;
18674      }
18675
18676      PRINT_SPACE
18677      _OUT << "\"driverUUID\":" << std::endl;
18678      PRINT_SPACE
18679      if (obj.driverUUID) {
18680        _OUT << "[" << std::endl;
18681        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
18682            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
18683            print_uint8_t(obj.driverUUID[i], "", isCommaNeeded);
18684        }
18685        PRINT_SPACE
18686        _OUT << "]" << "," << std::endl;
18687      } else {
18688        _OUT << "\"NULL\"" << "," << std::endl;
18689      }
18690
18691      PRINT_SPACE
18692      _OUT << "\"deviceLUID\":" << std::endl;
18693      PRINT_SPACE
18694      if (obj.deviceLUID) {
18695        _OUT << "[" << std::endl;
18696        for (unsigned int i = 0; i < VK_LUID_SIZE; i++) {
18697            bool isCommaNeeded = (i+1) != VK_LUID_SIZE;
18698            print_uint8_t(obj.deviceLUID[i], "", isCommaNeeded);
18699        }
18700        PRINT_SPACE
18701        _OUT << "]" << "," << std::endl;
18702      } else {
18703        _OUT << "\"NULL\"" << "," << std::endl;
18704      }
18705
18706      print_uint32_t(obj.deviceNodeMask, "deviceNodeMask", 1);
18707
18708      print_VkBool32(obj.deviceLUIDValid, "deviceLUIDValid", 1);
18709
18710      print_uint32_t(obj.subgroupSize, "subgroupSize", 1);
18711
18712      print_VkShaderStageFlags(obj.subgroupSupportedStages, "subgroupSupportedStages", 1);
18713
18714      print_VkSubgroupFeatureFlags(obj.subgroupSupportedOperations, "subgroupSupportedOperations", 1);
18715
18716      print_VkBool32(obj.subgroupQuadOperationsInAllStages, "subgroupQuadOperationsInAllStages", 1);
18717
18718      print_VkPointClippingBehavior(obj.pointClippingBehavior, "pointClippingBehavior", 1);
18719
18720      print_uint32_t(obj.maxMultiviewViewCount, "maxMultiviewViewCount", 1);
18721
18722      print_uint32_t(obj.maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 1);
18723
18724      print_VkBool32(obj.protectedNoFault, "protectedNoFault", 1);
18725
18726      print_uint32_t(obj.maxPerSetDescriptors, "maxPerSetDescriptors", 1);
18727
18728      print_VkDeviceSize(obj.maxMemoryAllocationSize, "maxMemoryAllocationSize", 0);
18729
18730      INDENT(-4);
18731      PRINT_SPACE
18732      if (commaNeeded)
18733          _OUT << "}," << std::endl;
18734      else
18735          _OUT << "}" << std::endl;
18736 }
18737 static void print_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties * obj, const std::string& s, bool commaNeeded=true) {
18738      PRINT_SPACE
18739      _OUT << "{" << std::endl;
18740      INDENT(4);
18741
18742      print_VkStructureType(obj->sType, "sType", 1);
18743
18744       if (obj->pNext) {
18745          dumpPNextChain(obj->pNext);
18746       } else {
18747          PRINT_SPACE
18748          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18749      }
18750
18751      PRINT_SPACE
18752      _OUT << "\"deviceUUID\":" << std::endl;
18753      PRINT_SPACE
18754      if (obj->deviceUUID) {
18755        _OUT << "[" << std::endl;
18756        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
18757            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
18758            print_uint8_t(obj->deviceUUID[i], "", isCommaNeeded);
18759        }
18760        PRINT_SPACE
18761        _OUT << "]" << "," << std::endl;
18762      } else {
18763        _OUT << "\"NULL\"" << "," << std::endl;
18764      }
18765
18766      PRINT_SPACE
18767      _OUT << "\"driverUUID\":" << std::endl;
18768      PRINT_SPACE
18769      if (obj->driverUUID) {
18770        _OUT << "[" << std::endl;
18771        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
18772            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
18773            print_uint8_t(obj->driverUUID[i], "", isCommaNeeded);
18774        }
18775        PRINT_SPACE
18776        _OUT << "]" << "," << std::endl;
18777      } else {
18778        _OUT << "\"NULL\"" << "," << std::endl;
18779      }
18780
18781      PRINT_SPACE
18782      _OUT << "\"deviceLUID\":" << std::endl;
18783      PRINT_SPACE
18784      if (obj->deviceLUID) {
18785        _OUT << "[" << std::endl;
18786        for (unsigned int i = 0; i < VK_LUID_SIZE; i++) {
18787            bool isCommaNeeded = (i+1) != VK_LUID_SIZE;
18788            print_uint8_t(obj->deviceLUID[i], "", isCommaNeeded);
18789        }
18790        PRINT_SPACE
18791        _OUT << "]" << "," << std::endl;
18792      } else {
18793        _OUT << "\"NULL\"" << "," << std::endl;
18794      }
18795
18796      print_uint32_t(obj->deviceNodeMask, "deviceNodeMask", 1);
18797
18798      print_VkBool32(obj->deviceLUIDValid, "deviceLUIDValid", 1);
18799
18800      print_uint32_t(obj->subgroupSize, "subgroupSize", 1);
18801
18802      print_VkShaderStageFlags(obj->subgroupSupportedStages, "subgroupSupportedStages", 1);
18803
18804      print_VkSubgroupFeatureFlags(obj->subgroupSupportedOperations, "subgroupSupportedOperations", 1);
18805
18806      print_VkBool32(obj->subgroupQuadOperationsInAllStages, "subgroupQuadOperationsInAllStages", 1);
18807
18808      print_VkPointClippingBehavior(obj->pointClippingBehavior, "pointClippingBehavior", 1);
18809
18810      print_uint32_t(obj->maxMultiviewViewCount, "maxMultiviewViewCount", 1);
18811
18812      print_uint32_t(obj->maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 1);
18813
18814      print_VkBool32(obj->protectedNoFault, "protectedNoFault", 1);
18815
18816      print_uint32_t(obj->maxPerSetDescriptors, "maxPerSetDescriptors", 1);
18817
18818      print_VkDeviceSize(obj->maxMemoryAllocationSize, "maxMemoryAllocationSize", 0);
18819
18820      INDENT(-4);
18821      PRINT_SPACE
18822      if (commaNeeded)
18823          _OUT << "}," << std::endl;
18824      else
18825          _OUT << "}" << std::endl;
18826 }
18827
18828 static void print_VkPhysicalDeviceVulkan12Features(VkPhysicalDeviceVulkan12Features obj, const std::string& s, bool commaNeeded=true) {
18829      PRINT_SPACE
18830      _OUT << "{" << std::endl;
18831      INDENT(4);
18832
18833      print_VkStructureType(obj.sType, "sType", 1);
18834
18835       if (obj.pNext) {
18836          dumpPNextChain(obj.pNext);
18837       } else {
18838          PRINT_SPACE
18839          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18840      }
18841
18842      print_VkBool32(obj.samplerMirrorClampToEdge, "samplerMirrorClampToEdge", 1);
18843
18844      print_VkBool32(obj.drawIndirectCount, "drawIndirectCount", 1);
18845
18846      print_VkBool32(obj.storageBuffer8BitAccess, "storageBuffer8BitAccess", 1);
18847
18848      print_VkBool32(obj.uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1);
18849
18850      print_VkBool32(obj.storagePushConstant8, "storagePushConstant8", 1);
18851
18852      print_VkBool32(obj.shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1);
18853
18854      print_VkBool32(obj.shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 1);
18855
18856      print_VkBool32(obj.shaderFloat16, "shaderFloat16", 1);
18857
18858      print_VkBool32(obj.shaderInt8, "shaderInt8", 1);
18859
18860      print_VkBool32(obj.descriptorIndexing, "descriptorIndexing", 1);
18861
18862      print_VkBool32(obj.shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1);
18863
18864      print_VkBool32(obj.shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing", 1);
18865
18866      print_VkBool32(obj.shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing", 1);
18867
18868      print_VkBool32(obj.shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1);
18869
18870      print_VkBool32(obj.shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1);
18871
18872      print_VkBool32(obj.shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1);
18873
18874      print_VkBool32(obj.shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1);
18875
18876      print_VkBool32(obj.shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing", 1);
18877
18878      print_VkBool32(obj.shaderUniformTexelBufferArrayNonUniformIndexing, "shaderUniformTexelBufferArrayNonUniformIndexing", 1);
18879
18880      print_VkBool32(obj.shaderStorageTexelBufferArrayNonUniformIndexing, "shaderStorageTexelBufferArrayNonUniformIndexing", 1);
18881
18882      print_VkBool32(obj.descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind", 1);
18883
18884      print_VkBool32(obj.descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind", 1);
18885
18886      print_VkBool32(obj.descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind", 1);
18887
18888      print_VkBool32(obj.descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind", 1);
18889
18890      print_VkBool32(obj.descriptorBindingUniformTexelBufferUpdateAfterBind, "descriptorBindingUniformTexelBufferUpdateAfterBind", 1);
18891
18892      print_VkBool32(obj.descriptorBindingStorageTexelBufferUpdateAfterBind, "descriptorBindingStorageTexelBufferUpdateAfterBind", 1);
18893
18894      print_VkBool32(obj.descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1);
18895
18896      print_VkBool32(obj.descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1);
18897
18898      print_VkBool32(obj.descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1);
18899
18900      print_VkBool32(obj.runtimeDescriptorArray, "runtimeDescriptorArray", 1);
18901
18902      print_VkBool32(obj.samplerFilterMinmax, "samplerFilterMinmax", 1);
18903
18904      print_VkBool32(obj.scalarBlockLayout, "scalarBlockLayout", 1);
18905
18906      print_VkBool32(obj.imagelessFramebuffer, "imagelessFramebuffer", 1);
18907
18908      print_VkBool32(obj.uniformBufferStandardLayout, "uniformBufferStandardLayout", 1);
18909
18910      print_VkBool32(obj.shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 1);
18911
18912      print_VkBool32(obj.separateDepthStencilLayouts, "separateDepthStencilLayouts", 1);
18913
18914      print_VkBool32(obj.hostQueryReset, "hostQueryReset", 1);
18915
18916      print_VkBool32(obj.timelineSemaphore, "timelineSemaphore", 1);
18917
18918      print_VkBool32(obj.bufferDeviceAddress, "bufferDeviceAddress", 1);
18919
18920      print_VkBool32(obj.bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1);
18921
18922      print_VkBool32(obj.bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 1);
18923
18924      print_VkBool32(obj.vulkanMemoryModel, "vulkanMemoryModel", 1);
18925
18926      print_VkBool32(obj.vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1);
18927
18928      print_VkBool32(obj.vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains", 1);
18929
18930      print_VkBool32(obj.shaderOutputViewportIndex, "shaderOutputViewportIndex", 1);
18931
18932      print_VkBool32(obj.shaderOutputLayer, "shaderOutputLayer", 1);
18933
18934      print_VkBool32(obj.subgroupBroadcastDynamicId, "subgroupBroadcastDynamicId", 0);
18935
18936      INDENT(-4);
18937      PRINT_SPACE
18938      if (commaNeeded)
18939          _OUT << "}," << std::endl;
18940      else
18941          _OUT << "}" << std::endl;
18942 }
18943 static void print_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features * obj, const std::string& s, bool commaNeeded=true) {
18944      PRINT_SPACE
18945      _OUT << "{" << std::endl;
18946      INDENT(4);
18947
18948      print_VkStructureType(obj->sType, "sType", 1);
18949
18950       if (obj->pNext) {
18951          dumpPNextChain(obj->pNext);
18952       } else {
18953          PRINT_SPACE
18954          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
18955      }
18956
18957      print_VkBool32(obj->samplerMirrorClampToEdge, "samplerMirrorClampToEdge", 1);
18958
18959      print_VkBool32(obj->drawIndirectCount, "drawIndirectCount", 1);
18960
18961      print_VkBool32(obj->storageBuffer8BitAccess, "storageBuffer8BitAccess", 1);
18962
18963      print_VkBool32(obj->uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1);
18964
18965      print_VkBool32(obj->storagePushConstant8, "storagePushConstant8", 1);
18966
18967      print_VkBool32(obj->shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1);
18968
18969      print_VkBool32(obj->shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 1);
18970
18971      print_VkBool32(obj->shaderFloat16, "shaderFloat16", 1);
18972
18973      print_VkBool32(obj->shaderInt8, "shaderInt8", 1);
18974
18975      print_VkBool32(obj->descriptorIndexing, "descriptorIndexing", 1);
18976
18977      print_VkBool32(obj->shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1);
18978
18979      print_VkBool32(obj->shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing", 1);
18980
18981      print_VkBool32(obj->shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing", 1);
18982
18983      print_VkBool32(obj->shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1);
18984
18985      print_VkBool32(obj->shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1);
18986
18987      print_VkBool32(obj->shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1);
18988
18989      print_VkBool32(obj->shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1);
18990
18991      print_VkBool32(obj->shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing", 1);
18992
18993      print_VkBool32(obj->shaderUniformTexelBufferArrayNonUniformIndexing, "shaderUniformTexelBufferArrayNonUniformIndexing", 1);
18994
18995      print_VkBool32(obj->shaderStorageTexelBufferArrayNonUniformIndexing, "shaderStorageTexelBufferArrayNonUniformIndexing", 1);
18996
18997      print_VkBool32(obj->descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind", 1);
18998
18999      print_VkBool32(obj->descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind", 1);
19000
19001      print_VkBool32(obj->descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind", 1);
19002
19003      print_VkBool32(obj->descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind", 1);
19004
19005      print_VkBool32(obj->descriptorBindingUniformTexelBufferUpdateAfterBind, "descriptorBindingUniformTexelBufferUpdateAfterBind", 1);
19006
19007      print_VkBool32(obj->descriptorBindingStorageTexelBufferUpdateAfterBind, "descriptorBindingStorageTexelBufferUpdateAfterBind", 1);
19008
19009      print_VkBool32(obj->descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1);
19010
19011      print_VkBool32(obj->descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1);
19012
19013      print_VkBool32(obj->descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1);
19014
19015      print_VkBool32(obj->runtimeDescriptorArray, "runtimeDescriptorArray", 1);
19016
19017      print_VkBool32(obj->samplerFilterMinmax, "samplerFilterMinmax", 1);
19018
19019      print_VkBool32(obj->scalarBlockLayout, "scalarBlockLayout", 1);
19020
19021      print_VkBool32(obj->imagelessFramebuffer, "imagelessFramebuffer", 1);
19022
19023      print_VkBool32(obj->uniformBufferStandardLayout, "uniformBufferStandardLayout", 1);
19024
19025      print_VkBool32(obj->shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 1);
19026
19027      print_VkBool32(obj->separateDepthStencilLayouts, "separateDepthStencilLayouts", 1);
19028
19029      print_VkBool32(obj->hostQueryReset, "hostQueryReset", 1);
19030
19031      print_VkBool32(obj->timelineSemaphore, "timelineSemaphore", 1);
19032
19033      print_VkBool32(obj->bufferDeviceAddress, "bufferDeviceAddress", 1);
19034
19035      print_VkBool32(obj->bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1);
19036
19037      print_VkBool32(obj->bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 1);
19038
19039      print_VkBool32(obj->vulkanMemoryModel, "vulkanMemoryModel", 1);
19040
19041      print_VkBool32(obj->vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1);
19042
19043      print_VkBool32(obj->vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains", 1);
19044
19045      print_VkBool32(obj->shaderOutputViewportIndex, "shaderOutputViewportIndex", 1);
19046
19047      print_VkBool32(obj->shaderOutputLayer, "shaderOutputLayer", 1);
19048
19049      print_VkBool32(obj->subgroupBroadcastDynamicId, "subgroupBroadcastDynamicId", 0);
19050
19051      INDENT(-4);
19052      PRINT_SPACE
19053      if (commaNeeded)
19054          _OUT << "}," << std::endl;
19055      else
19056          _OUT << "}" << std::endl;
19057 }
19058
19059 static void print_VkConformanceVersion(VkConformanceVersion obj, const std::string& s, bool commaNeeded=true) {
19060      PRINT_SPACE
19061      _OUT << "{" << std::endl;
19062      INDENT(4);
19063
19064      print_uint8_t(obj.major, "major", 1);
19065
19066      print_uint8_t(obj.minor, "minor", 1);
19067
19068      print_uint8_t(obj.subminor, "subminor", 1);
19069
19070      print_uint8_t(obj.patch, "patch", 0);
19071
19072      INDENT(-4);
19073      PRINT_SPACE
19074      if (commaNeeded)
19075          _OUT << "}," << std::endl;
19076      else
19077          _OUT << "}" << std::endl;
19078 }
19079 static void print_VkConformanceVersion(const VkConformanceVersion * obj, const std::string& s, bool commaNeeded=true) {
19080      PRINT_SPACE
19081      _OUT << "{" << std::endl;
19082      INDENT(4);
19083
19084      print_uint8_t(obj->major, "major", 1);
19085
19086      print_uint8_t(obj->minor, "minor", 1);
19087
19088      print_uint8_t(obj->subminor, "subminor", 1);
19089
19090      print_uint8_t(obj->patch, "patch", 0);
19091
19092      INDENT(-4);
19093      PRINT_SPACE
19094      if (commaNeeded)
19095          _OUT << "}," << std::endl;
19096      else
19097          _OUT << "}" << std::endl;
19098 }
19099
19100 static void print_VkPhysicalDeviceVulkan12Properties(VkPhysicalDeviceVulkan12Properties obj, const std::string& s, bool commaNeeded=true) {
19101      PRINT_SPACE
19102      _OUT << "{" << std::endl;
19103      INDENT(4);
19104
19105      print_VkStructureType(obj.sType, "sType", 1);
19106
19107       if (obj.pNext) {
19108          dumpPNextChain(obj.pNext);
19109       } else {
19110          PRINT_SPACE
19111          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19112      }
19113
19114      print_VkDriverId(obj.driverID, "driverID", 1);
19115
19116      PRINT_SPACE
19117      _OUT << "\"driverName\":" << std::endl;
19118      PRINT_SPACE
19119      if (obj.driverName) {
19120        _OUT << "[" << std::endl;
19121        for (unsigned int i = 0; i < VK_MAX_DRIVER_NAME_SIZE; i++) {
19122            bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_NAME_SIZE;
19123            print_char(obj.driverName[i], "", isCommaNeeded);
19124        }
19125        PRINT_SPACE
19126        _OUT << "]" << "," << std::endl;
19127      } else {
19128        _OUT << "\"NULL\"" << "," << std::endl;
19129      }
19130
19131      PRINT_SPACE
19132      _OUT << "\"driverInfo\":" << std::endl;
19133      PRINT_SPACE
19134      if (obj.driverInfo) {
19135        _OUT << "[" << std::endl;
19136        for (unsigned int i = 0; i < VK_MAX_DRIVER_INFO_SIZE; i++) {
19137            bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_INFO_SIZE;
19138            print_char(obj.driverInfo[i], "", isCommaNeeded);
19139        }
19140        PRINT_SPACE
19141        _OUT << "]" << "," << std::endl;
19142      } else {
19143        _OUT << "\"NULL\"" << "," << std::endl;
19144      }
19145
19146      PRINT_SPACE
19147      _OUT << "\"conformanceVersion\": " << std::endl;
19148      {
19149            print_VkConformanceVersion(obj.conformanceVersion, "conformanceVersion", 1);
19150      }
19151
19152      print_VkShaderFloatControlsIndependence(obj.denormBehaviorIndependence, "denormBehaviorIndependence", 1);
19153
19154      print_VkShaderFloatControlsIndependence(obj.roundingModeIndependence, "roundingModeIndependence", 1);
19155
19156      print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1);
19157
19158      print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1);
19159
19160      print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1);
19161
19162      print_VkBool32(obj.shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1);
19163
19164      print_VkBool32(obj.shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1);
19165
19166      print_VkBool32(obj.shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1);
19167
19168      print_VkBool32(obj.shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1);
19169
19170      print_VkBool32(obj.shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1);
19171
19172      print_VkBool32(obj.shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1);
19173
19174      print_VkBool32(obj.shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1);
19175
19176      print_VkBool32(obj.shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1);
19177
19178      print_VkBool32(obj.shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1);
19179
19180      print_VkBool32(obj.shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1);
19181
19182      print_VkBool32(obj.shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1);
19183
19184      print_VkBool32(obj.shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 1);
19185
19186      print_uint32_t(obj.maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1);
19187
19188      print_VkBool32(obj.shaderUniformBufferArrayNonUniformIndexingNative, "shaderUniformBufferArrayNonUniformIndexingNative", 1);
19189
19190      print_VkBool32(obj.shaderSampledImageArrayNonUniformIndexingNative, "shaderSampledImageArrayNonUniformIndexingNative", 1);
19191
19192      print_VkBool32(obj.shaderStorageBufferArrayNonUniformIndexingNative, "shaderStorageBufferArrayNonUniformIndexingNative", 1);
19193
19194      print_VkBool32(obj.shaderStorageImageArrayNonUniformIndexingNative, "shaderStorageImageArrayNonUniformIndexingNative", 1);
19195
19196      print_VkBool32(obj.shaderInputAttachmentArrayNonUniformIndexingNative, "shaderInputAttachmentArrayNonUniformIndexingNative", 1);
19197
19198      print_VkBool32(obj.robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1);
19199
19200      print_VkBool32(obj.quadDivergentImplicitLod, "quadDivergentImplicitLod", 1);
19201
19202      print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers", 1);
19203
19204      print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers, "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1);
19205
19206      print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers, "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1);
19207
19208      print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindSampledImages, "maxPerStageDescriptorUpdateAfterBindSampledImages", 1);
19209
19210      print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindStorageImages, "maxPerStageDescriptorUpdateAfterBindStorageImages", 1);
19211
19212      print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindInputAttachments, "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1);
19213
19214      print_uint32_t(obj.maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1);
19215
19216      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1);
19217
19218      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers", 1);
19219
19220      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1);
19221
19222      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers", 1);
19223
19224      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1);
19225
19226      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages", 1);
19227
19228      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages", 1);
19229
19230      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindInputAttachments, "maxDescriptorSetUpdateAfterBindInputAttachments", 1);
19231
19232      print_VkResolveModeFlags(obj.supportedDepthResolveModes, "supportedDepthResolveModes", 1);
19233
19234      print_VkResolveModeFlags(obj.supportedStencilResolveModes, "supportedStencilResolveModes", 1);
19235
19236      print_VkBool32(obj.independentResolveNone, "independentResolveNone", 1);
19237
19238      print_VkBool32(obj.independentResolve, "independentResolve", 1);
19239
19240      print_VkBool32(obj.filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1);
19241
19242      print_VkBool32(obj.filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 1);
19243
19244      print_uint64_t(obj.maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 1);
19245
19246      print_VkSampleCountFlags(obj.framebufferIntegerColorSampleCounts, "framebufferIntegerColorSampleCounts", 0);
19247
19248      INDENT(-4);
19249      PRINT_SPACE
19250      if (commaNeeded)
19251          _OUT << "}," << std::endl;
19252      else
19253          _OUT << "}" << std::endl;
19254 }
19255 static void print_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties * obj, const std::string& s, bool commaNeeded=true) {
19256      PRINT_SPACE
19257      _OUT << "{" << std::endl;
19258      INDENT(4);
19259
19260      print_VkStructureType(obj->sType, "sType", 1);
19261
19262       if (obj->pNext) {
19263          dumpPNextChain(obj->pNext);
19264       } else {
19265          PRINT_SPACE
19266          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19267      }
19268
19269      print_VkDriverId(obj->driverID, "driverID", 1);
19270
19271      PRINT_SPACE
19272      _OUT << "\"driverName\":" << std::endl;
19273      PRINT_SPACE
19274      if (obj->driverName) {
19275        _OUT << "[" << std::endl;
19276        for (unsigned int i = 0; i < VK_MAX_DRIVER_NAME_SIZE; i++) {
19277            bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_NAME_SIZE;
19278            print_char(obj->driverName[i], "", isCommaNeeded);
19279        }
19280        PRINT_SPACE
19281        _OUT << "]" << "," << std::endl;
19282      } else {
19283        _OUT << "\"NULL\"" << "," << std::endl;
19284      }
19285
19286      PRINT_SPACE
19287      _OUT << "\"driverInfo\":" << std::endl;
19288      PRINT_SPACE
19289      if (obj->driverInfo) {
19290        _OUT << "[" << std::endl;
19291        for (unsigned int i = 0; i < VK_MAX_DRIVER_INFO_SIZE; i++) {
19292            bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_INFO_SIZE;
19293            print_char(obj->driverInfo[i], "", isCommaNeeded);
19294        }
19295        PRINT_SPACE
19296        _OUT << "]" << "," << std::endl;
19297      } else {
19298        _OUT << "\"NULL\"" << "," << std::endl;
19299      }
19300
19301      PRINT_SPACE
19302      _OUT << "\"conformanceVersion\": " << std::endl;
19303      {
19304            print_VkConformanceVersion(obj->conformanceVersion, "conformanceVersion", 1);
19305      }
19306
19307      print_VkShaderFloatControlsIndependence(obj->denormBehaviorIndependence, "denormBehaviorIndependence", 1);
19308
19309      print_VkShaderFloatControlsIndependence(obj->roundingModeIndependence, "roundingModeIndependence", 1);
19310
19311      print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1);
19312
19313      print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1);
19314
19315      print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1);
19316
19317      print_VkBool32(obj->shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1);
19318
19319      print_VkBool32(obj->shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1);
19320
19321      print_VkBool32(obj->shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1);
19322
19323      print_VkBool32(obj->shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1);
19324
19325      print_VkBool32(obj->shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1);
19326
19327      print_VkBool32(obj->shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1);
19328
19329      print_VkBool32(obj->shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1);
19330
19331      print_VkBool32(obj->shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1);
19332
19333      print_VkBool32(obj->shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1);
19334
19335      print_VkBool32(obj->shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1);
19336
19337      print_VkBool32(obj->shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1);
19338
19339      print_VkBool32(obj->shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 1);
19340
19341      print_uint32_t(obj->maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1);
19342
19343      print_VkBool32(obj->shaderUniformBufferArrayNonUniformIndexingNative, "shaderUniformBufferArrayNonUniformIndexingNative", 1);
19344
19345      print_VkBool32(obj->shaderSampledImageArrayNonUniformIndexingNative, "shaderSampledImageArrayNonUniformIndexingNative", 1);
19346
19347      print_VkBool32(obj->shaderStorageBufferArrayNonUniformIndexingNative, "shaderStorageBufferArrayNonUniformIndexingNative", 1);
19348
19349      print_VkBool32(obj->shaderStorageImageArrayNonUniformIndexingNative, "shaderStorageImageArrayNonUniformIndexingNative", 1);
19350
19351      print_VkBool32(obj->shaderInputAttachmentArrayNonUniformIndexingNative, "shaderInputAttachmentArrayNonUniformIndexingNative", 1);
19352
19353      print_VkBool32(obj->robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1);
19354
19355      print_VkBool32(obj->quadDivergentImplicitLod, "quadDivergentImplicitLod", 1);
19356
19357      print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers", 1);
19358
19359      print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindUniformBuffers, "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1);
19360
19361      print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindStorageBuffers, "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1);
19362
19363      print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindSampledImages, "maxPerStageDescriptorUpdateAfterBindSampledImages", 1);
19364
19365      print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindStorageImages, "maxPerStageDescriptorUpdateAfterBindStorageImages", 1);
19366
19367      print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindInputAttachments, "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1);
19368
19369      print_uint32_t(obj->maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1);
19370
19371      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1);
19372
19373      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers", 1);
19374
19375      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1);
19376
19377      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers", 1);
19378
19379      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1);
19380
19381      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages", 1);
19382
19383      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages", 1);
19384
19385      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindInputAttachments, "maxDescriptorSetUpdateAfterBindInputAttachments", 1);
19386
19387      print_VkResolveModeFlags(obj->supportedDepthResolveModes, "supportedDepthResolveModes", 1);
19388
19389      print_VkResolveModeFlags(obj->supportedStencilResolveModes, "supportedStencilResolveModes", 1);
19390
19391      print_VkBool32(obj->independentResolveNone, "independentResolveNone", 1);
19392
19393      print_VkBool32(obj->independentResolve, "independentResolve", 1);
19394
19395      print_VkBool32(obj->filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1);
19396
19397      print_VkBool32(obj->filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 1);
19398
19399      print_uint64_t(obj->maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 1);
19400
19401      print_VkSampleCountFlags(obj->framebufferIntegerColorSampleCounts, "framebufferIntegerColorSampleCounts", 0);
19402
19403      INDENT(-4);
19404      PRINT_SPACE
19405      if (commaNeeded)
19406          _OUT << "}," << std::endl;
19407      else
19408          _OUT << "}" << std::endl;
19409 }
19410
19411 static void print_VkImageFormatListCreateInfo(VkImageFormatListCreateInfo obj, const std::string& s, bool commaNeeded=true) {
19412      PRINT_SPACE
19413      _OUT << "{" << std::endl;
19414      INDENT(4);
19415
19416      print_VkStructureType(obj.sType, "sType", 1);
19417
19418       if (obj.pNext) {
19419          dumpPNextChain(obj.pNext);
19420       } else {
19421          PRINT_SPACE
19422          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19423      }
19424
19425      print_uint32_t(obj.viewFormatCount, "viewFormatCount", 1);
19426
19427      PRINT_SPACE
19428      _OUT << "\"pViewFormats\":" << std::endl;
19429      PRINT_SPACE
19430      if (obj.pViewFormats) {
19431        _OUT << "[" << std::endl;
19432        for (unsigned int i = 0; i < obj.viewFormatCount; i++) {
19433            bool isCommaNeeded = (i+1) != obj.viewFormatCount;
19434            print_VkFormat(obj.pViewFormats[i], "", isCommaNeeded);
19435        }
19436        PRINT_SPACE
19437        _OUT << "]" << "" << std::endl;
19438      } else {
19439        _OUT << "\"NULL\"" << "" << std::endl;
19440      }
19441
19442      INDENT(-4);
19443      PRINT_SPACE
19444      if (commaNeeded)
19445          _OUT << "}," << std::endl;
19446      else
19447          _OUT << "}" << std::endl;
19448 }
19449 static void print_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
19450      PRINT_SPACE
19451      _OUT << "{" << std::endl;
19452      INDENT(4);
19453
19454      print_VkStructureType(obj->sType, "sType", 1);
19455
19456       if (obj->pNext) {
19457          dumpPNextChain(obj->pNext);
19458       } else {
19459          PRINT_SPACE
19460          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19461      }
19462
19463      print_uint32_t(obj->viewFormatCount, "viewFormatCount", 1);
19464
19465      PRINT_SPACE
19466      _OUT << "\"pViewFormats\":" << std::endl;
19467      PRINT_SPACE
19468      if (obj->pViewFormats) {
19469        _OUT << "[" << std::endl;
19470        for (unsigned int i = 0; i < obj->viewFormatCount; i++) {
19471            bool isCommaNeeded = (i+1) != obj->viewFormatCount;
19472            print_VkFormat(obj->pViewFormats[i], "", isCommaNeeded);
19473        }
19474        PRINT_SPACE
19475        _OUT << "]" << "" << std::endl;
19476      } else {
19477        _OUT << "\"NULL\"" << "" << std::endl;
19478      }
19479
19480      INDENT(-4);
19481      PRINT_SPACE
19482      if (commaNeeded)
19483          _OUT << "}," << std::endl;
19484      else
19485          _OUT << "}" << std::endl;
19486 }
19487
19488 static void print_VkAttachmentDescription2(VkAttachmentDescription2 obj, const std::string& s, bool commaNeeded=true) {
19489      PRINT_SPACE
19490      _OUT << "{" << std::endl;
19491      INDENT(4);
19492
19493      print_VkStructureType(obj.sType, "sType", 1);
19494
19495       if (obj.pNext) {
19496          dumpPNextChain(obj.pNext);
19497       } else {
19498          PRINT_SPACE
19499          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19500      }
19501
19502      print_VkAttachmentDescriptionFlags(obj.flags, "flags", 1);
19503
19504      print_VkFormat(obj.format, "format", 1);
19505
19506      print_VkSampleCountFlagBits(obj.samples, "samples", 1);
19507
19508      print_VkAttachmentLoadOp(obj.loadOp, "loadOp", 1);
19509
19510      print_VkAttachmentStoreOp(obj.storeOp, "storeOp", 1);
19511
19512      print_VkAttachmentLoadOp(obj.stencilLoadOp, "stencilLoadOp", 1);
19513
19514      print_VkAttachmentStoreOp(obj.stencilStoreOp, "stencilStoreOp", 1);
19515
19516      print_VkImageLayout(obj.initialLayout, "initialLayout", 1);
19517
19518      print_VkImageLayout(obj.finalLayout, "finalLayout", 0);
19519
19520      INDENT(-4);
19521      PRINT_SPACE
19522      if (commaNeeded)
19523          _OUT << "}," << std::endl;
19524      else
19525          _OUT << "}" << std::endl;
19526 }
19527 static void print_VkAttachmentDescription2(const VkAttachmentDescription2 * obj, const std::string& s, bool commaNeeded=true) {
19528      PRINT_SPACE
19529      _OUT << "{" << std::endl;
19530      INDENT(4);
19531
19532      print_VkStructureType(obj->sType, "sType", 1);
19533
19534       if (obj->pNext) {
19535          dumpPNextChain(obj->pNext);
19536       } else {
19537          PRINT_SPACE
19538          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19539      }
19540
19541      print_VkAttachmentDescriptionFlags(obj->flags, "flags", 1);
19542
19543      print_VkFormat(obj->format, "format", 1);
19544
19545      print_VkSampleCountFlagBits(obj->samples, "samples", 1);
19546
19547      print_VkAttachmentLoadOp(obj->loadOp, "loadOp", 1);
19548
19549      print_VkAttachmentStoreOp(obj->storeOp, "storeOp", 1);
19550
19551      print_VkAttachmentLoadOp(obj->stencilLoadOp, "stencilLoadOp", 1);
19552
19553      print_VkAttachmentStoreOp(obj->stencilStoreOp, "stencilStoreOp", 1);
19554
19555      print_VkImageLayout(obj->initialLayout, "initialLayout", 1);
19556
19557      print_VkImageLayout(obj->finalLayout, "finalLayout", 0);
19558
19559      INDENT(-4);
19560      PRINT_SPACE
19561      if (commaNeeded)
19562          _OUT << "}," << std::endl;
19563      else
19564          _OUT << "}" << std::endl;
19565 }
19566
19567 static void print_VkAttachmentReference2(VkAttachmentReference2 obj, const std::string& s, bool commaNeeded=true) {
19568      PRINT_SPACE
19569      _OUT << "{" << std::endl;
19570      INDENT(4);
19571
19572      print_VkStructureType(obj.sType, "sType", 1);
19573
19574       if (obj.pNext) {
19575          dumpPNextChain(obj.pNext);
19576       } else {
19577          PRINT_SPACE
19578          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19579      }
19580
19581      print_uint32_t(obj.attachment, "attachment", 1);
19582
19583      print_VkImageLayout(obj.layout, "layout", 1);
19584
19585      print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 0);
19586
19587      INDENT(-4);
19588      PRINT_SPACE
19589      if (commaNeeded)
19590          _OUT << "}," << std::endl;
19591      else
19592          _OUT << "}" << std::endl;
19593 }
19594 static void print_VkAttachmentReference2(const VkAttachmentReference2 * obj, const std::string& s, bool commaNeeded=true) {
19595      PRINT_SPACE
19596      _OUT << "{" << std::endl;
19597      INDENT(4);
19598
19599      print_VkStructureType(obj->sType, "sType", 1);
19600
19601       if (obj->pNext) {
19602          dumpPNextChain(obj->pNext);
19603       } else {
19604          PRINT_SPACE
19605          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19606      }
19607
19608      print_uint32_t(obj->attachment, "attachment", 1);
19609
19610      print_VkImageLayout(obj->layout, "layout", 1);
19611
19612      print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 0);
19613
19614      INDENT(-4);
19615      PRINT_SPACE
19616      if (commaNeeded)
19617          _OUT << "}," << std::endl;
19618      else
19619          _OUT << "}" << std::endl;
19620 }
19621
19622 static void print_VkSubpassDescription2(VkSubpassDescription2 obj, const std::string& s, bool commaNeeded=true) {
19623      PRINT_SPACE
19624      _OUT << "{" << std::endl;
19625      INDENT(4);
19626
19627      print_VkStructureType(obj.sType, "sType", 1);
19628
19629       if (obj.pNext) {
19630          dumpPNextChain(obj.pNext);
19631       } else {
19632          PRINT_SPACE
19633          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19634      }
19635
19636      print_VkSubpassDescriptionFlags(obj.flags, "flags", 1);
19637
19638      print_VkPipelineBindPoint(obj.pipelineBindPoint, "pipelineBindPoint", 1);
19639
19640      print_uint32_t(obj.viewMask, "viewMask", 1);
19641
19642      print_uint32_t(obj.inputAttachmentCount, "inputAttachmentCount", 1);
19643
19644      PRINT_SPACE
19645      _OUT << "\"pInputAttachments\": " << std::endl;
19646      if (obj.pInputAttachments) {
19647          PRINT_SPACE
19648          _OUT << "[" << std::endl;
19649          for (unsigned int i = 0; i < obj.inputAttachmentCount; i++) {
19650            if (i+1 == obj.inputAttachmentCount)
19651                print_VkAttachmentReference2(obj.pInputAttachments[i], "pInputAttachments", 0);
19652            else
19653                print_VkAttachmentReference2(obj.pInputAttachments[i], "pInputAttachments", 1);
19654          }
19655          PRINT_SPACE
19656          _OUT << "]," << std::endl;
19657     }
19658      else
19659      {
19660          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
19661      }
19662
19663      print_uint32_t(obj.colorAttachmentCount, "colorAttachmentCount", 1);
19664
19665      PRINT_SPACE
19666      _OUT << "\"pColorAttachments\": " << std::endl;
19667      if (obj.pColorAttachments) {
19668          PRINT_SPACE
19669          _OUT << "[" << std::endl;
19670          for (unsigned int i = 0; i < obj.colorAttachmentCount; i++) {
19671            if (i+1 == obj.colorAttachmentCount)
19672                print_VkAttachmentReference2(obj.pColorAttachments[i], "pColorAttachments", 0);
19673            else
19674                print_VkAttachmentReference2(obj.pColorAttachments[i], "pColorAttachments", 1);
19675          }
19676          PRINT_SPACE
19677          _OUT << "]," << std::endl;
19678     }
19679      else
19680      {
19681          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
19682      }
19683
19684      PRINT_SPACE
19685      _OUT << "\"pResolveAttachments\": " << std::endl;
19686      if (obj.pResolveAttachments) {
19687          PRINT_SPACE
19688          _OUT << "[" << std::endl;
19689          for (unsigned int i = 0; i < obj.colorAttachmentCount; i++) {
19690            if (i+1 == obj.colorAttachmentCount)
19691                print_VkAttachmentReference2(obj.pResolveAttachments[i], "pResolveAttachments", 0);
19692            else
19693                print_VkAttachmentReference2(obj.pResolveAttachments[i], "pResolveAttachments", 1);
19694          }
19695          PRINT_SPACE
19696          _OUT << "]," << std::endl;
19697     }
19698      else
19699      {
19700          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
19701      }
19702
19703      PRINT_SPACE
19704      _OUT << "\"pDepthStencilAttachment\": " << std::endl;
19705      if (obj.pDepthStencilAttachment) {
19706            print_VkAttachmentReference2(obj.pDepthStencilAttachment, "pDepthStencilAttachment", 1);
19707      }
19708      else
19709      {
19710          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
19711      }
19712
19713      print_uint32_t(obj.preserveAttachmentCount, "preserveAttachmentCount", 1);
19714
19715      PRINT_SPACE
19716      _OUT << "\"pPreserveAttachments\":" << std::endl;
19717      PRINT_SPACE
19718      if (obj.pPreserveAttachments) {
19719        _OUT << "[" << std::endl;
19720        for (unsigned int i = 0; i < obj.preserveAttachmentCount; i++) {
19721            bool isCommaNeeded = (i+1) != obj.preserveAttachmentCount;
19722            print_uint32_t(obj.pPreserveAttachments[i], "", isCommaNeeded);
19723        }
19724        PRINT_SPACE
19725        _OUT << "]" << "" << std::endl;
19726      } else {
19727        _OUT << "\"NULL\"" << "" << std::endl;
19728      }
19729
19730      INDENT(-4);
19731      PRINT_SPACE
19732      if (commaNeeded)
19733          _OUT << "}," << std::endl;
19734      else
19735          _OUT << "}" << std::endl;
19736 }
19737 static void print_VkSubpassDescription2(const VkSubpassDescription2 * obj, const std::string& s, bool commaNeeded=true) {
19738      PRINT_SPACE
19739      _OUT << "{" << std::endl;
19740      INDENT(4);
19741
19742      print_VkStructureType(obj->sType, "sType", 1);
19743
19744       if (obj->pNext) {
19745          dumpPNextChain(obj->pNext);
19746       } else {
19747          PRINT_SPACE
19748          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19749      }
19750
19751      print_VkSubpassDescriptionFlags(obj->flags, "flags", 1);
19752
19753      print_VkPipelineBindPoint(obj->pipelineBindPoint, "pipelineBindPoint", 1);
19754
19755      print_uint32_t(obj->viewMask, "viewMask", 1);
19756
19757      print_uint32_t(obj->inputAttachmentCount, "inputAttachmentCount", 1);
19758
19759      PRINT_SPACE
19760      _OUT << "\"pInputAttachments\": " << std::endl;
19761      if (obj->pInputAttachments) {
19762          PRINT_SPACE
19763          _OUT << "[" << std::endl;
19764          for (unsigned int i = 0; i < obj->inputAttachmentCount; i++) {
19765            if (i+1 == obj->inputAttachmentCount)
19766                print_VkAttachmentReference2(obj->pInputAttachments[i], "pInputAttachments", 0);
19767            else
19768                print_VkAttachmentReference2(obj->pInputAttachments[i], "pInputAttachments", 1);
19769          }
19770          PRINT_SPACE
19771          _OUT << "]," << std::endl;
19772     }
19773      else
19774      {
19775          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
19776      }
19777
19778      print_uint32_t(obj->colorAttachmentCount, "colorAttachmentCount", 1);
19779
19780      PRINT_SPACE
19781      _OUT << "\"pColorAttachments\": " << std::endl;
19782      if (obj->pColorAttachments) {
19783          PRINT_SPACE
19784          _OUT << "[" << std::endl;
19785          for (unsigned int i = 0; i < obj->colorAttachmentCount; i++) {
19786            if (i+1 == obj->colorAttachmentCount)
19787                print_VkAttachmentReference2(obj->pColorAttachments[i], "pColorAttachments", 0);
19788            else
19789                print_VkAttachmentReference2(obj->pColorAttachments[i], "pColorAttachments", 1);
19790          }
19791          PRINT_SPACE
19792          _OUT << "]," << std::endl;
19793     }
19794      else
19795      {
19796          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
19797      }
19798
19799      PRINT_SPACE
19800      _OUT << "\"pResolveAttachments\": " << std::endl;
19801      if (obj->pResolveAttachments) {
19802          PRINT_SPACE
19803          _OUT << "[" << std::endl;
19804          for (unsigned int i = 0; i < obj->colorAttachmentCount; i++) {
19805            if (i+1 == obj->colorAttachmentCount)
19806                print_VkAttachmentReference2(obj->pResolveAttachments[i], "pResolveAttachments", 0);
19807            else
19808                print_VkAttachmentReference2(obj->pResolveAttachments[i], "pResolveAttachments", 1);
19809          }
19810          PRINT_SPACE
19811          _OUT << "]," << std::endl;
19812     }
19813      else
19814      {
19815          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
19816      }
19817
19818      PRINT_SPACE
19819      _OUT << "\"pDepthStencilAttachment\": " << std::endl;
19820      if (obj->pDepthStencilAttachment) {
19821            print_VkAttachmentReference2(obj->pDepthStencilAttachment, "pDepthStencilAttachment", 1);
19822      }
19823      else
19824      {
19825          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
19826      }
19827
19828      print_uint32_t(obj->preserveAttachmentCount, "preserveAttachmentCount", 1);
19829
19830      PRINT_SPACE
19831      _OUT << "\"pPreserveAttachments\":" << std::endl;
19832      PRINT_SPACE
19833      if (obj->pPreserveAttachments) {
19834        _OUT << "[" << std::endl;
19835        for (unsigned int i = 0; i < obj->preserveAttachmentCount; i++) {
19836            bool isCommaNeeded = (i+1) != obj->preserveAttachmentCount;
19837            print_uint32_t(obj->pPreserveAttachments[i], "", isCommaNeeded);
19838        }
19839        PRINT_SPACE
19840        _OUT << "]" << "" << std::endl;
19841      } else {
19842        _OUT << "\"NULL\"" << "" << std::endl;
19843      }
19844
19845      INDENT(-4);
19846      PRINT_SPACE
19847      if (commaNeeded)
19848          _OUT << "}," << std::endl;
19849      else
19850          _OUT << "}" << std::endl;
19851 }
19852
19853 static void print_VkSubpassDependency2(VkSubpassDependency2 obj, const std::string& s, bool commaNeeded=true) {
19854      PRINT_SPACE
19855      _OUT << "{" << std::endl;
19856      INDENT(4);
19857
19858      print_VkStructureType(obj.sType, "sType", 1);
19859
19860       if (obj.pNext) {
19861          dumpPNextChain(obj.pNext);
19862       } else {
19863          PRINT_SPACE
19864          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19865      }
19866
19867      print_uint32_t(obj.srcSubpass, "srcSubpass", 1);
19868
19869      print_uint32_t(obj.dstSubpass, "dstSubpass", 1);
19870
19871      print_VkPipelineStageFlags(obj.srcStageMask, "srcStageMask", 1);
19872
19873      print_VkPipelineStageFlags(obj.dstStageMask, "dstStageMask", 1);
19874
19875      print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1);
19876
19877      print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 1);
19878
19879      print_VkDependencyFlags(obj.dependencyFlags, "dependencyFlags", 1);
19880
19881      print_int32_t(obj.viewOffset, "viewOffset", 0);
19882
19883      INDENT(-4);
19884      PRINT_SPACE
19885      if (commaNeeded)
19886          _OUT << "}," << std::endl;
19887      else
19888          _OUT << "}" << std::endl;
19889 }
19890 static void print_VkSubpassDependency2(const VkSubpassDependency2 * obj, const std::string& s, bool commaNeeded=true) {
19891      PRINT_SPACE
19892      _OUT << "{" << std::endl;
19893      INDENT(4);
19894
19895      print_VkStructureType(obj->sType, "sType", 1);
19896
19897       if (obj->pNext) {
19898          dumpPNextChain(obj->pNext);
19899       } else {
19900          PRINT_SPACE
19901          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19902      }
19903
19904      print_uint32_t(obj->srcSubpass, "srcSubpass", 1);
19905
19906      print_uint32_t(obj->dstSubpass, "dstSubpass", 1);
19907
19908      print_VkPipelineStageFlags(obj->srcStageMask, "srcStageMask", 1);
19909
19910      print_VkPipelineStageFlags(obj->dstStageMask, "dstStageMask", 1);
19911
19912      print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1);
19913
19914      print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 1);
19915
19916      print_VkDependencyFlags(obj->dependencyFlags, "dependencyFlags", 1);
19917
19918      print_int32_t(obj->viewOffset, "viewOffset", 0);
19919
19920      INDENT(-4);
19921      PRINT_SPACE
19922      if (commaNeeded)
19923          _OUT << "}," << std::endl;
19924      else
19925          _OUT << "}" << std::endl;
19926 }
19927
19928 static void print_VkRenderPassCreateInfo2(VkRenderPassCreateInfo2 obj, const std::string& s, bool commaNeeded=true) {
19929      PRINT_SPACE
19930      _OUT << "{" << std::endl;
19931      INDENT(4);
19932
19933      print_VkStructureType(obj.sType, "sType", 1);
19934
19935       if (obj.pNext) {
19936          dumpPNextChain(obj.pNext);
19937       } else {
19938          PRINT_SPACE
19939          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
19940      }
19941
19942      print_VkRenderPassCreateFlags(obj.flags, "flags", 1);
19943
19944      print_uint32_t(obj.attachmentCount, "attachmentCount", 1);
19945
19946      PRINT_SPACE
19947      _OUT << "\"pAttachments\": " << std::endl;
19948      if (obj.pAttachments) {
19949          PRINT_SPACE
19950          _OUT << "[" << std::endl;
19951          for (unsigned int i = 0; i < obj.attachmentCount; i++) {
19952            if (i+1 == obj.attachmentCount)
19953                print_VkAttachmentDescription2(obj.pAttachments[i], "pAttachments", 0);
19954            else
19955                print_VkAttachmentDescription2(obj.pAttachments[i], "pAttachments", 1);
19956          }
19957          PRINT_SPACE
19958          _OUT << "]," << std::endl;
19959     }
19960      else
19961      {
19962          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
19963      }
19964
19965      print_uint32_t(obj.subpassCount, "subpassCount", 1);
19966
19967      PRINT_SPACE
19968      _OUT << "\"pSubpasses\": " << std::endl;
19969      if (obj.pSubpasses) {
19970          PRINT_SPACE
19971          _OUT << "[" << std::endl;
19972          for (unsigned int i = 0; i < obj.subpassCount; i++) {
19973            if (i+1 == obj.subpassCount)
19974                print_VkSubpassDescription2(obj.pSubpasses[i], "pSubpasses", 0);
19975            else
19976                print_VkSubpassDescription2(obj.pSubpasses[i], "pSubpasses", 1);
19977          }
19978          PRINT_SPACE
19979          _OUT << "]," << std::endl;
19980     }
19981      else
19982      {
19983          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
19984      }
19985
19986      print_uint32_t(obj.dependencyCount, "dependencyCount", 1);
19987
19988      PRINT_SPACE
19989      _OUT << "\"pDependencies\": " << std::endl;
19990      if (obj.pDependencies) {
19991          PRINT_SPACE
19992          _OUT << "[" << std::endl;
19993          for (unsigned int i = 0; i < obj.dependencyCount; i++) {
19994            if (i+1 == obj.dependencyCount)
19995                print_VkSubpassDependency2(obj.pDependencies[i], "pDependencies", 0);
19996            else
19997                print_VkSubpassDependency2(obj.pDependencies[i], "pDependencies", 1);
19998          }
19999          PRINT_SPACE
20000          _OUT << "]," << std::endl;
20001     }
20002      else
20003      {
20004          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
20005      }
20006
20007      print_uint32_t(obj.correlatedViewMaskCount, "correlatedViewMaskCount", 1);
20008
20009      PRINT_SPACE
20010      _OUT << "\"pCorrelatedViewMasks\":" << std::endl;
20011      PRINT_SPACE
20012      if (obj.pCorrelatedViewMasks) {
20013        _OUT << "[" << std::endl;
20014        for (unsigned int i = 0; i < obj.correlatedViewMaskCount; i++) {
20015            bool isCommaNeeded = (i+1) != obj.correlatedViewMaskCount;
20016            print_uint32_t(obj.pCorrelatedViewMasks[i], "", isCommaNeeded);
20017        }
20018        PRINT_SPACE
20019        _OUT << "]" << "" << std::endl;
20020      } else {
20021        _OUT << "\"NULL\"" << "" << std::endl;
20022      }
20023
20024      INDENT(-4);
20025      PRINT_SPACE
20026      if (commaNeeded)
20027          _OUT << "}," << std::endl;
20028      else
20029          _OUT << "}" << std::endl;
20030 }
20031 static void print_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2 * obj, const std::string& s, bool commaNeeded=true) {
20032      PRINT_SPACE
20033      _OUT << "{" << std::endl;
20034      INDENT(4);
20035
20036      print_VkStructureType(obj->sType, "sType", 1);
20037
20038       if (obj->pNext) {
20039          dumpPNextChain(obj->pNext);
20040       } else {
20041          PRINT_SPACE
20042          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20043      }
20044
20045      print_VkRenderPassCreateFlags(obj->flags, "flags", 1);
20046
20047      print_uint32_t(obj->attachmentCount, "attachmentCount", 1);
20048
20049      PRINT_SPACE
20050      _OUT << "\"pAttachments\": " << std::endl;
20051      if (obj->pAttachments) {
20052          PRINT_SPACE
20053          _OUT << "[" << std::endl;
20054          for (unsigned int i = 0; i < obj->attachmentCount; i++) {
20055            if (i+1 == obj->attachmentCount)
20056                print_VkAttachmentDescription2(obj->pAttachments[i], "pAttachments", 0);
20057            else
20058                print_VkAttachmentDescription2(obj->pAttachments[i], "pAttachments", 1);
20059          }
20060          PRINT_SPACE
20061          _OUT << "]," << std::endl;
20062     }
20063      else
20064      {
20065          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
20066      }
20067
20068      print_uint32_t(obj->subpassCount, "subpassCount", 1);
20069
20070      PRINT_SPACE
20071      _OUT << "\"pSubpasses\": " << std::endl;
20072      if (obj->pSubpasses) {
20073          PRINT_SPACE
20074          _OUT << "[" << std::endl;
20075          for (unsigned int i = 0; i < obj->subpassCount; i++) {
20076            if (i+1 == obj->subpassCount)
20077                print_VkSubpassDescription2(obj->pSubpasses[i], "pSubpasses", 0);
20078            else
20079                print_VkSubpassDescription2(obj->pSubpasses[i], "pSubpasses", 1);
20080          }
20081          PRINT_SPACE
20082          _OUT << "]," << std::endl;
20083     }
20084      else
20085      {
20086          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
20087      }
20088
20089      print_uint32_t(obj->dependencyCount, "dependencyCount", 1);
20090
20091      PRINT_SPACE
20092      _OUT << "\"pDependencies\": " << std::endl;
20093      if (obj->pDependencies) {
20094          PRINT_SPACE
20095          _OUT << "[" << std::endl;
20096          for (unsigned int i = 0; i < obj->dependencyCount; i++) {
20097            if (i+1 == obj->dependencyCount)
20098                print_VkSubpassDependency2(obj->pDependencies[i], "pDependencies", 0);
20099            else
20100                print_VkSubpassDependency2(obj->pDependencies[i], "pDependencies", 1);
20101          }
20102          PRINT_SPACE
20103          _OUT << "]," << std::endl;
20104     }
20105      else
20106      {
20107          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
20108      }
20109
20110      print_uint32_t(obj->correlatedViewMaskCount, "correlatedViewMaskCount", 1);
20111
20112      PRINT_SPACE
20113      _OUT << "\"pCorrelatedViewMasks\":" << std::endl;
20114      PRINT_SPACE
20115      if (obj->pCorrelatedViewMasks) {
20116        _OUT << "[" << std::endl;
20117        for (unsigned int i = 0; i < obj->correlatedViewMaskCount; i++) {
20118            bool isCommaNeeded = (i+1) != obj->correlatedViewMaskCount;
20119            print_uint32_t(obj->pCorrelatedViewMasks[i], "", isCommaNeeded);
20120        }
20121        PRINT_SPACE
20122        _OUT << "]" << "" << std::endl;
20123      } else {
20124        _OUT << "\"NULL\"" << "" << std::endl;
20125      }
20126
20127      INDENT(-4);
20128      PRINT_SPACE
20129      if (commaNeeded)
20130          _OUT << "}," << std::endl;
20131      else
20132          _OUT << "}" << std::endl;
20133 }
20134
20135 static void print_VkSubpassBeginInfo(VkSubpassBeginInfo obj, const std::string& s, bool commaNeeded=true) {
20136      PRINT_SPACE
20137      _OUT << "{" << std::endl;
20138      INDENT(4);
20139
20140      print_VkStructureType(obj.sType, "sType", 1);
20141
20142       if (obj.pNext) {
20143          dumpPNextChain(obj.pNext);
20144       } else {
20145          PRINT_SPACE
20146          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20147      }
20148
20149      print_VkSubpassContents(obj.contents, "contents", 0);
20150
20151      INDENT(-4);
20152      PRINT_SPACE
20153      if (commaNeeded)
20154          _OUT << "}," << std::endl;
20155      else
20156          _OUT << "}" << std::endl;
20157 }
20158 static void print_VkSubpassBeginInfo(const VkSubpassBeginInfo * obj, const std::string& s, bool commaNeeded=true) {
20159      PRINT_SPACE
20160      _OUT << "{" << std::endl;
20161      INDENT(4);
20162
20163      print_VkStructureType(obj->sType, "sType", 1);
20164
20165       if (obj->pNext) {
20166          dumpPNextChain(obj->pNext);
20167       } else {
20168          PRINT_SPACE
20169          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20170      }
20171
20172      print_VkSubpassContents(obj->contents, "contents", 0);
20173
20174      INDENT(-4);
20175      PRINT_SPACE
20176      if (commaNeeded)
20177          _OUT << "}," << std::endl;
20178      else
20179          _OUT << "}" << std::endl;
20180 }
20181
20182 static void print_VkSubpassEndInfo(VkSubpassEndInfo obj, const std::string& s, bool commaNeeded=true) {
20183      PRINT_SPACE
20184      _OUT << "{" << std::endl;
20185      INDENT(4);
20186
20187      print_VkStructureType(obj.sType, "sType", 1);
20188
20189       if (obj.pNext) {
20190          dumpPNextChain(obj.pNext);
20191       } else {
20192          PRINT_SPACE
20193          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20194      }
20195
20196      INDENT(-4);
20197      PRINT_SPACE
20198      if (commaNeeded)
20199          _OUT << "}," << std::endl;
20200      else
20201          _OUT << "}" << std::endl;
20202 }
20203 static void print_VkSubpassEndInfo(const VkSubpassEndInfo * obj, const std::string& s, bool commaNeeded=true) {
20204      PRINT_SPACE
20205      _OUT << "{" << std::endl;
20206      INDENT(4);
20207
20208      print_VkStructureType(obj->sType, "sType", 1);
20209
20210       if (obj->pNext) {
20211          dumpPNextChain(obj->pNext);
20212       } else {
20213          PRINT_SPACE
20214          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20215      }
20216
20217      INDENT(-4);
20218      PRINT_SPACE
20219      if (commaNeeded)
20220          _OUT << "}," << std::endl;
20221      else
20222          _OUT << "}" << std::endl;
20223 }
20224
20225 static void print_VkPhysicalDevice8BitStorageFeatures(VkPhysicalDevice8BitStorageFeatures obj, const std::string& s, bool commaNeeded=true) {
20226      PRINT_SPACE
20227      _OUT << "{" << std::endl;
20228      INDENT(4);
20229
20230      print_VkStructureType(obj.sType, "sType", 1);
20231
20232       if (obj.pNext) {
20233          dumpPNextChain(obj.pNext);
20234       } else {
20235          PRINT_SPACE
20236          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20237      }
20238
20239      print_VkBool32(obj.storageBuffer8BitAccess, "storageBuffer8BitAccess", 1);
20240
20241      print_VkBool32(obj.uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1);
20242
20243      print_VkBool32(obj.storagePushConstant8, "storagePushConstant8", 0);
20244
20245      INDENT(-4);
20246      PRINT_SPACE
20247      if (commaNeeded)
20248          _OUT << "}," << std::endl;
20249      else
20250          _OUT << "}" << std::endl;
20251 }
20252 static void print_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures * obj, const std::string& s, bool commaNeeded=true) {
20253      PRINT_SPACE
20254      _OUT << "{" << std::endl;
20255      INDENT(4);
20256
20257      print_VkStructureType(obj->sType, "sType", 1);
20258
20259       if (obj->pNext) {
20260          dumpPNextChain(obj->pNext);
20261       } else {
20262          PRINT_SPACE
20263          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20264      }
20265
20266      print_VkBool32(obj->storageBuffer8BitAccess, "storageBuffer8BitAccess", 1);
20267
20268      print_VkBool32(obj->uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1);
20269
20270      print_VkBool32(obj->storagePushConstant8, "storagePushConstant8", 0);
20271
20272      INDENT(-4);
20273      PRINT_SPACE
20274      if (commaNeeded)
20275          _OUT << "}," << std::endl;
20276      else
20277          _OUT << "}" << std::endl;
20278 }
20279
20280 static void print_VkPhysicalDeviceDriverProperties(VkPhysicalDeviceDriverProperties obj, const std::string& s, bool commaNeeded=true) {
20281      PRINT_SPACE
20282      _OUT << "{" << std::endl;
20283      INDENT(4);
20284
20285      print_VkStructureType(obj.sType, "sType", 1);
20286
20287       if (obj.pNext) {
20288          dumpPNextChain(obj.pNext);
20289       } else {
20290          PRINT_SPACE
20291          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20292      }
20293
20294      print_VkDriverId(obj.driverID, "driverID", 1);
20295
20296      PRINT_SPACE
20297      _OUT << "\"driverName\":" << std::endl;
20298      PRINT_SPACE
20299      if (obj.driverName) {
20300        _OUT << "[" << std::endl;
20301        for (unsigned int i = 0; i < VK_MAX_DRIVER_NAME_SIZE; i++) {
20302            bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_NAME_SIZE;
20303            print_char(obj.driverName[i], "", isCommaNeeded);
20304        }
20305        PRINT_SPACE
20306        _OUT << "]" << "," << std::endl;
20307      } else {
20308        _OUT << "\"NULL\"" << "," << std::endl;
20309      }
20310
20311      PRINT_SPACE
20312      _OUT << "\"driverInfo\":" << std::endl;
20313      PRINT_SPACE
20314      if (obj.driverInfo) {
20315        _OUT << "[" << std::endl;
20316        for (unsigned int i = 0; i < VK_MAX_DRIVER_INFO_SIZE; i++) {
20317            bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_INFO_SIZE;
20318            print_char(obj.driverInfo[i], "", isCommaNeeded);
20319        }
20320        PRINT_SPACE
20321        _OUT << "]" << "," << std::endl;
20322      } else {
20323        _OUT << "\"NULL\"" << "," << std::endl;
20324      }
20325
20326      PRINT_SPACE
20327      _OUT << "\"conformanceVersion\": " << std::endl;
20328      {
20329            print_VkConformanceVersion(obj.conformanceVersion, "conformanceVersion", 0);
20330      }
20331
20332      INDENT(-4);
20333      PRINT_SPACE
20334      if (commaNeeded)
20335          _OUT << "}," << std::endl;
20336      else
20337          _OUT << "}" << std::endl;
20338 }
20339 static void print_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties * obj, const std::string& s, bool commaNeeded=true) {
20340      PRINT_SPACE
20341      _OUT << "{" << std::endl;
20342      INDENT(4);
20343
20344      print_VkStructureType(obj->sType, "sType", 1);
20345
20346       if (obj->pNext) {
20347          dumpPNextChain(obj->pNext);
20348       } else {
20349          PRINT_SPACE
20350          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20351      }
20352
20353      print_VkDriverId(obj->driverID, "driverID", 1);
20354
20355      PRINT_SPACE
20356      _OUT << "\"driverName\":" << std::endl;
20357      PRINT_SPACE
20358      if (obj->driverName) {
20359        _OUT << "[" << std::endl;
20360        for (unsigned int i = 0; i < VK_MAX_DRIVER_NAME_SIZE; i++) {
20361            bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_NAME_SIZE;
20362            print_char(obj->driverName[i], "", isCommaNeeded);
20363        }
20364        PRINT_SPACE
20365        _OUT << "]" << "," << std::endl;
20366      } else {
20367        _OUT << "\"NULL\"" << "," << std::endl;
20368      }
20369
20370      PRINT_SPACE
20371      _OUT << "\"driverInfo\":" << std::endl;
20372      PRINT_SPACE
20373      if (obj->driverInfo) {
20374        _OUT << "[" << std::endl;
20375        for (unsigned int i = 0; i < VK_MAX_DRIVER_INFO_SIZE; i++) {
20376            bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_INFO_SIZE;
20377            print_char(obj->driverInfo[i], "", isCommaNeeded);
20378        }
20379        PRINT_SPACE
20380        _OUT << "]" << "," << std::endl;
20381      } else {
20382        _OUT << "\"NULL\"" << "," << std::endl;
20383      }
20384
20385      PRINT_SPACE
20386      _OUT << "\"conformanceVersion\": " << std::endl;
20387      {
20388            print_VkConformanceVersion(obj->conformanceVersion, "conformanceVersion", 0);
20389      }
20390
20391      INDENT(-4);
20392      PRINT_SPACE
20393      if (commaNeeded)
20394          _OUT << "}," << std::endl;
20395      else
20396          _OUT << "}" << std::endl;
20397 }
20398
20399 static void print_VkPhysicalDeviceShaderAtomicInt64Features(VkPhysicalDeviceShaderAtomicInt64Features obj, const std::string& s, bool commaNeeded=true) {
20400      PRINT_SPACE
20401      _OUT << "{" << std::endl;
20402      INDENT(4);
20403
20404      print_VkStructureType(obj.sType, "sType", 1);
20405
20406       if (obj.pNext) {
20407          dumpPNextChain(obj.pNext);
20408       } else {
20409          PRINT_SPACE
20410          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20411      }
20412
20413      print_VkBool32(obj.shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1);
20414
20415      print_VkBool32(obj.shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 0);
20416
20417      INDENT(-4);
20418      PRINT_SPACE
20419      if (commaNeeded)
20420          _OUT << "}," << std::endl;
20421      else
20422          _OUT << "}" << std::endl;
20423 }
20424 static void print_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features * obj, const std::string& s, bool commaNeeded=true) {
20425      PRINT_SPACE
20426      _OUT << "{" << std::endl;
20427      INDENT(4);
20428
20429      print_VkStructureType(obj->sType, "sType", 1);
20430
20431       if (obj->pNext) {
20432          dumpPNextChain(obj->pNext);
20433       } else {
20434          PRINT_SPACE
20435          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20436      }
20437
20438      print_VkBool32(obj->shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1);
20439
20440      print_VkBool32(obj->shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 0);
20441
20442      INDENT(-4);
20443      PRINT_SPACE
20444      if (commaNeeded)
20445          _OUT << "}," << std::endl;
20446      else
20447          _OUT << "}" << std::endl;
20448 }
20449
20450 static void print_VkPhysicalDeviceShaderFloat16Int8Features(VkPhysicalDeviceShaderFloat16Int8Features obj, const std::string& s, bool commaNeeded=true) {
20451      PRINT_SPACE
20452      _OUT << "{" << std::endl;
20453      INDENT(4);
20454
20455      print_VkStructureType(obj.sType, "sType", 1);
20456
20457       if (obj.pNext) {
20458          dumpPNextChain(obj.pNext);
20459       } else {
20460          PRINT_SPACE
20461          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20462      }
20463
20464      print_VkBool32(obj.shaderFloat16, "shaderFloat16", 1);
20465
20466      print_VkBool32(obj.shaderInt8, "shaderInt8", 0);
20467
20468      INDENT(-4);
20469      PRINT_SPACE
20470      if (commaNeeded)
20471          _OUT << "}," << std::endl;
20472      else
20473          _OUT << "}" << std::endl;
20474 }
20475 static void print_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features * obj, const std::string& s, bool commaNeeded=true) {
20476      PRINT_SPACE
20477      _OUT << "{" << std::endl;
20478      INDENT(4);
20479
20480      print_VkStructureType(obj->sType, "sType", 1);
20481
20482       if (obj->pNext) {
20483          dumpPNextChain(obj->pNext);
20484       } else {
20485          PRINT_SPACE
20486          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20487      }
20488
20489      print_VkBool32(obj->shaderFloat16, "shaderFloat16", 1);
20490
20491      print_VkBool32(obj->shaderInt8, "shaderInt8", 0);
20492
20493      INDENT(-4);
20494      PRINT_SPACE
20495      if (commaNeeded)
20496          _OUT << "}," << std::endl;
20497      else
20498          _OUT << "}" << std::endl;
20499 }
20500
20501 static void print_VkPhysicalDeviceFloatControlsProperties(VkPhysicalDeviceFloatControlsProperties obj, const std::string& s, bool commaNeeded=true) {
20502      PRINT_SPACE
20503      _OUT << "{" << std::endl;
20504      INDENT(4);
20505
20506      print_VkStructureType(obj.sType, "sType", 1);
20507
20508       if (obj.pNext) {
20509          dumpPNextChain(obj.pNext);
20510       } else {
20511          PRINT_SPACE
20512          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20513      }
20514
20515      print_VkShaderFloatControlsIndependence(obj.denormBehaviorIndependence, "denormBehaviorIndependence", 1);
20516
20517      print_VkShaderFloatControlsIndependence(obj.roundingModeIndependence, "roundingModeIndependence", 1);
20518
20519      print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1);
20520
20521      print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1);
20522
20523      print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1);
20524
20525      print_VkBool32(obj.shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1);
20526
20527      print_VkBool32(obj.shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1);
20528
20529      print_VkBool32(obj.shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1);
20530
20531      print_VkBool32(obj.shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1);
20532
20533      print_VkBool32(obj.shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1);
20534
20535      print_VkBool32(obj.shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1);
20536
20537      print_VkBool32(obj.shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1);
20538
20539      print_VkBool32(obj.shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1);
20540
20541      print_VkBool32(obj.shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1);
20542
20543      print_VkBool32(obj.shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1);
20544
20545      print_VkBool32(obj.shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1);
20546
20547      print_VkBool32(obj.shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 0);
20548
20549      INDENT(-4);
20550      PRINT_SPACE
20551      if (commaNeeded)
20552          _OUT << "}," << std::endl;
20553      else
20554          _OUT << "}" << std::endl;
20555 }
20556 static void print_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties * obj, const std::string& s, bool commaNeeded=true) {
20557      PRINT_SPACE
20558      _OUT << "{" << std::endl;
20559      INDENT(4);
20560
20561      print_VkStructureType(obj->sType, "sType", 1);
20562
20563       if (obj->pNext) {
20564          dumpPNextChain(obj->pNext);
20565       } else {
20566          PRINT_SPACE
20567          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20568      }
20569
20570      print_VkShaderFloatControlsIndependence(obj->denormBehaviorIndependence, "denormBehaviorIndependence", 1);
20571
20572      print_VkShaderFloatControlsIndependence(obj->roundingModeIndependence, "roundingModeIndependence", 1);
20573
20574      print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1);
20575
20576      print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1);
20577
20578      print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1);
20579
20580      print_VkBool32(obj->shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1);
20581
20582      print_VkBool32(obj->shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1);
20583
20584      print_VkBool32(obj->shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1);
20585
20586      print_VkBool32(obj->shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1);
20587
20588      print_VkBool32(obj->shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1);
20589
20590      print_VkBool32(obj->shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1);
20591
20592      print_VkBool32(obj->shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1);
20593
20594      print_VkBool32(obj->shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1);
20595
20596      print_VkBool32(obj->shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1);
20597
20598      print_VkBool32(obj->shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1);
20599
20600      print_VkBool32(obj->shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1);
20601
20602      print_VkBool32(obj->shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 0);
20603
20604      INDENT(-4);
20605      PRINT_SPACE
20606      if (commaNeeded)
20607          _OUT << "}," << std::endl;
20608      else
20609          _OUT << "}" << std::endl;
20610 }
20611
20612 static void print_VkDescriptorSetLayoutBindingFlagsCreateInfo(VkDescriptorSetLayoutBindingFlagsCreateInfo obj, const std::string& s, bool commaNeeded=true) {
20613      PRINT_SPACE
20614      _OUT << "{" << std::endl;
20615      INDENT(4);
20616
20617      print_VkStructureType(obj.sType, "sType", 1);
20618
20619       if (obj.pNext) {
20620          dumpPNextChain(obj.pNext);
20621       } else {
20622          PRINT_SPACE
20623          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20624      }
20625
20626      print_uint32_t(obj.bindingCount, "bindingCount", 1);
20627
20628      PRINT_SPACE
20629      _OUT << "\"pBindingFlags\":" << std::endl;
20630      PRINT_SPACE
20631      if (obj.pBindingFlags) {
20632        _OUT << "[" << std::endl;
20633        for (unsigned int i = 0; i < obj.bindingCount; i++) {
20634            bool isCommaNeeded = (i+1) != obj.bindingCount;
20635            print_VkDescriptorBindingFlags(obj.pBindingFlags[i], "", isCommaNeeded);
20636        }
20637        PRINT_SPACE
20638        _OUT << "]" << "" << std::endl;
20639      } else {
20640        _OUT << "\"NULL\"" << "" << std::endl;
20641      }
20642
20643      INDENT(-4);
20644      PRINT_SPACE
20645      if (commaNeeded)
20646          _OUT << "}," << std::endl;
20647      else
20648          _OUT << "}" << std::endl;
20649 }
20650 static void print_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
20651      PRINT_SPACE
20652      _OUT << "{" << std::endl;
20653      INDENT(4);
20654
20655      print_VkStructureType(obj->sType, "sType", 1);
20656
20657       if (obj->pNext) {
20658          dumpPNextChain(obj->pNext);
20659       } else {
20660          PRINT_SPACE
20661          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20662      }
20663
20664      print_uint32_t(obj->bindingCount, "bindingCount", 1);
20665
20666      PRINT_SPACE
20667      _OUT << "\"pBindingFlags\":" << std::endl;
20668      PRINT_SPACE
20669      if (obj->pBindingFlags) {
20670        _OUT << "[" << std::endl;
20671        for (unsigned int i = 0; i < obj->bindingCount; i++) {
20672            bool isCommaNeeded = (i+1) != obj->bindingCount;
20673            print_VkDescriptorBindingFlags(obj->pBindingFlags[i], "", isCommaNeeded);
20674        }
20675        PRINT_SPACE
20676        _OUT << "]" << "" << std::endl;
20677      } else {
20678        _OUT << "\"NULL\"" << "" << std::endl;
20679      }
20680
20681      INDENT(-4);
20682      PRINT_SPACE
20683      if (commaNeeded)
20684          _OUT << "}," << std::endl;
20685      else
20686          _OUT << "}" << std::endl;
20687 }
20688
20689 static void print_VkPhysicalDeviceDescriptorIndexingFeatures(VkPhysicalDeviceDescriptorIndexingFeatures obj, const std::string& s, bool commaNeeded=true) {
20690      PRINT_SPACE
20691      _OUT << "{" << std::endl;
20692      INDENT(4);
20693
20694      print_VkStructureType(obj.sType, "sType", 1);
20695
20696       if (obj.pNext) {
20697          dumpPNextChain(obj.pNext);
20698       } else {
20699          PRINT_SPACE
20700          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20701      }
20702
20703      print_VkBool32(obj.shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1);
20704
20705      print_VkBool32(obj.shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing", 1);
20706
20707      print_VkBool32(obj.shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing", 1);
20708
20709      print_VkBool32(obj.shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1);
20710
20711      print_VkBool32(obj.shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1);
20712
20713      print_VkBool32(obj.shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1);
20714
20715      print_VkBool32(obj.shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1);
20716
20717      print_VkBool32(obj.shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing", 1);
20718
20719      print_VkBool32(obj.shaderUniformTexelBufferArrayNonUniformIndexing, "shaderUniformTexelBufferArrayNonUniformIndexing", 1);
20720
20721      print_VkBool32(obj.shaderStorageTexelBufferArrayNonUniformIndexing, "shaderStorageTexelBufferArrayNonUniformIndexing", 1);
20722
20723      print_VkBool32(obj.descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind", 1);
20724
20725      print_VkBool32(obj.descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind", 1);
20726
20727      print_VkBool32(obj.descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind", 1);
20728
20729      print_VkBool32(obj.descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind", 1);
20730
20731      print_VkBool32(obj.descriptorBindingUniformTexelBufferUpdateAfterBind, "descriptorBindingUniformTexelBufferUpdateAfterBind", 1);
20732
20733      print_VkBool32(obj.descriptorBindingStorageTexelBufferUpdateAfterBind, "descriptorBindingStorageTexelBufferUpdateAfterBind", 1);
20734
20735      print_VkBool32(obj.descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1);
20736
20737      print_VkBool32(obj.descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1);
20738
20739      print_VkBool32(obj.descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1);
20740
20741      print_VkBool32(obj.runtimeDescriptorArray, "runtimeDescriptorArray", 0);
20742
20743      INDENT(-4);
20744      PRINT_SPACE
20745      if (commaNeeded)
20746          _OUT << "}," << std::endl;
20747      else
20748          _OUT << "}" << std::endl;
20749 }
20750 static void print_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures * obj, const std::string& s, bool commaNeeded=true) {
20751      PRINT_SPACE
20752      _OUT << "{" << std::endl;
20753      INDENT(4);
20754
20755      print_VkStructureType(obj->sType, "sType", 1);
20756
20757       if (obj->pNext) {
20758          dumpPNextChain(obj->pNext);
20759       } else {
20760          PRINT_SPACE
20761          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20762      }
20763
20764      print_VkBool32(obj->shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1);
20765
20766      print_VkBool32(obj->shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing", 1);
20767
20768      print_VkBool32(obj->shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing", 1);
20769
20770      print_VkBool32(obj->shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1);
20771
20772      print_VkBool32(obj->shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1);
20773
20774      print_VkBool32(obj->shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1);
20775
20776      print_VkBool32(obj->shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1);
20777
20778      print_VkBool32(obj->shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing", 1);
20779
20780      print_VkBool32(obj->shaderUniformTexelBufferArrayNonUniformIndexing, "shaderUniformTexelBufferArrayNonUniformIndexing", 1);
20781
20782      print_VkBool32(obj->shaderStorageTexelBufferArrayNonUniformIndexing, "shaderStorageTexelBufferArrayNonUniformIndexing", 1);
20783
20784      print_VkBool32(obj->descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind", 1);
20785
20786      print_VkBool32(obj->descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind", 1);
20787
20788      print_VkBool32(obj->descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind", 1);
20789
20790      print_VkBool32(obj->descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind", 1);
20791
20792      print_VkBool32(obj->descriptorBindingUniformTexelBufferUpdateAfterBind, "descriptorBindingUniformTexelBufferUpdateAfterBind", 1);
20793
20794      print_VkBool32(obj->descriptorBindingStorageTexelBufferUpdateAfterBind, "descriptorBindingStorageTexelBufferUpdateAfterBind", 1);
20795
20796      print_VkBool32(obj->descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1);
20797
20798      print_VkBool32(obj->descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1);
20799
20800      print_VkBool32(obj->descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1);
20801
20802      print_VkBool32(obj->runtimeDescriptorArray, "runtimeDescriptorArray", 0);
20803
20804      INDENT(-4);
20805      PRINT_SPACE
20806      if (commaNeeded)
20807          _OUT << "}," << std::endl;
20808      else
20809          _OUT << "}" << std::endl;
20810 }
20811
20812 static void print_VkPhysicalDeviceDescriptorIndexingProperties(VkPhysicalDeviceDescriptorIndexingProperties obj, const std::string& s, bool commaNeeded=true) {
20813      PRINT_SPACE
20814      _OUT << "{" << std::endl;
20815      INDENT(4);
20816
20817      print_VkStructureType(obj.sType, "sType", 1);
20818
20819       if (obj.pNext) {
20820          dumpPNextChain(obj.pNext);
20821       } else {
20822          PRINT_SPACE
20823          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20824      }
20825
20826      print_uint32_t(obj.maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1);
20827
20828      print_VkBool32(obj.shaderUniformBufferArrayNonUniformIndexingNative, "shaderUniformBufferArrayNonUniformIndexingNative", 1);
20829
20830      print_VkBool32(obj.shaderSampledImageArrayNonUniformIndexingNative, "shaderSampledImageArrayNonUniformIndexingNative", 1);
20831
20832      print_VkBool32(obj.shaderStorageBufferArrayNonUniformIndexingNative, "shaderStorageBufferArrayNonUniformIndexingNative", 1);
20833
20834      print_VkBool32(obj.shaderStorageImageArrayNonUniformIndexingNative, "shaderStorageImageArrayNonUniformIndexingNative", 1);
20835
20836      print_VkBool32(obj.shaderInputAttachmentArrayNonUniformIndexingNative, "shaderInputAttachmentArrayNonUniformIndexingNative", 1);
20837
20838      print_VkBool32(obj.robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1);
20839
20840      print_VkBool32(obj.quadDivergentImplicitLod, "quadDivergentImplicitLod", 1);
20841
20842      print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers", 1);
20843
20844      print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers, "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1);
20845
20846      print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers, "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1);
20847
20848      print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindSampledImages, "maxPerStageDescriptorUpdateAfterBindSampledImages", 1);
20849
20850      print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindStorageImages, "maxPerStageDescriptorUpdateAfterBindStorageImages", 1);
20851
20852      print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindInputAttachments, "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1);
20853
20854      print_uint32_t(obj.maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1);
20855
20856      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1);
20857
20858      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers", 1);
20859
20860      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1);
20861
20862      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers", 1);
20863
20864      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1);
20865
20866      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages", 1);
20867
20868      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages", 1);
20869
20870      print_uint32_t(obj.maxDescriptorSetUpdateAfterBindInputAttachments, "maxDescriptorSetUpdateAfterBindInputAttachments", 0);
20871
20872      INDENT(-4);
20873      PRINT_SPACE
20874      if (commaNeeded)
20875          _OUT << "}," << std::endl;
20876      else
20877          _OUT << "}" << std::endl;
20878 }
20879 static void print_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties * obj, const std::string& s, bool commaNeeded=true) {
20880      PRINT_SPACE
20881      _OUT << "{" << std::endl;
20882      INDENT(4);
20883
20884      print_VkStructureType(obj->sType, "sType", 1);
20885
20886       if (obj->pNext) {
20887          dumpPNextChain(obj->pNext);
20888       } else {
20889          PRINT_SPACE
20890          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20891      }
20892
20893      print_uint32_t(obj->maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1);
20894
20895      print_VkBool32(obj->shaderUniformBufferArrayNonUniformIndexingNative, "shaderUniformBufferArrayNonUniformIndexingNative", 1);
20896
20897      print_VkBool32(obj->shaderSampledImageArrayNonUniformIndexingNative, "shaderSampledImageArrayNonUniformIndexingNative", 1);
20898
20899      print_VkBool32(obj->shaderStorageBufferArrayNonUniformIndexingNative, "shaderStorageBufferArrayNonUniformIndexingNative", 1);
20900
20901      print_VkBool32(obj->shaderStorageImageArrayNonUniformIndexingNative, "shaderStorageImageArrayNonUniformIndexingNative", 1);
20902
20903      print_VkBool32(obj->shaderInputAttachmentArrayNonUniformIndexingNative, "shaderInputAttachmentArrayNonUniformIndexingNative", 1);
20904
20905      print_VkBool32(obj->robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1);
20906
20907      print_VkBool32(obj->quadDivergentImplicitLod, "quadDivergentImplicitLod", 1);
20908
20909      print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers", 1);
20910
20911      print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindUniformBuffers, "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1);
20912
20913      print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindStorageBuffers, "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1);
20914
20915      print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindSampledImages, "maxPerStageDescriptorUpdateAfterBindSampledImages", 1);
20916
20917      print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindStorageImages, "maxPerStageDescriptorUpdateAfterBindStorageImages", 1);
20918
20919      print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindInputAttachments, "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1);
20920
20921      print_uint32_t(obj->maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1);
20922
20923      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1);
20924
20925      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers", 1);
20926
20927      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1);
20928
20929      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers", 1);
20930
20931      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1);
20932
20933      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages", 1);
20934
20935      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages", 1);
20936
20937      print_uint32_t(obj->maxDescriptorSetUpdateAfterBindInputAttachments, "maxDescriptorSetUpdateAfterBindInputAttachments", 0);
20938
20939      INDENT(-4);
20940      PRINT_SPACE
20941      if (commaNeeded)
20942          _OUT << "}," << std::endl;
20943      else
20944          _OUT << "}" << std::endl;
20945 }
20946
20947 static void print_VkDescriptorSetVariableDescriptorCountAllocateInfo(VkDescriptorSetVariableDescriptorCountAllocateInfo obj, const std::string& s, bool commaNeeded=true) {
20948      PRINT_SPACE
20949      _OUT << "{" << std::endl;
20950      INDENT(4);
20951
20952      print_VkStructureType(obj.sType, "sType", 1);
20953
20954       if (obj.pNext) {
20955          dumpPNextChain(obj.pNext);
20956       } else {
20957          PRINT_SPACE
20958          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20959      }
20960
20961      print_uint32_t(obj.descriptorSetCount, "descriptorSetCount", 1);
20962
20963      PRINT_SPACE
20964      _OUT << "\"pDescriptorCounts\":" << std::endl;
20965      PRINT_SPACE
20966      if (obj.pDescriptorCounts) {
20967        _OUT << "[" << std::endl;
20968        for (unsigned int i = 0; i < obj.descriptorSetCount; i++) {
20969            bool isCommaNeeded = (i+1) != obj.descriptorSetCount;
20970            print_uint32_t(obj.pDescriptorCounts[i], "", isCommaNeeded);
20971        }
20972        PRINT_SPACE
20973        _OUT << "]" << "" << std::endl;
20974      } else {
20975        _OUT << "\"NULL\"" << "" << std::endl;
20976      }
20977
20978      INDENT(-4);
20979      PRINT_SPACE
20980      if (commaNeeded)
20981          _OUT << "}," << std::endl;
20982      else
20983          _OUT << "}" << std::endl;
20984 }
20985 static void print_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo * obj, const std::string& s, bool commaNeeded=true) {
20986      PRINT_SPACE
20987      _OUT << "{" << std::endl;
20988      INDENT(4);
20989
20990      print_VkStructureType(obj->sType, "sType", 1);
20991
20992       if (obj->pNext) {
20993          dumpPNextChain(obj->pNext);
20994       } else {
20995          PRINT_SPACE
20996          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
20997      }
20998
20999      print_uint32_t(obj->descriptorSetCount, "descriptorSetCount", 1);
21000
21001      PRINT_SPACE
21002      _OUT << "\"pDescriptorCounts\":" << std::endl;
21003      PRINT_SPACE
21004      if (obj->pDescriptorCounts) {
21005        _OUT << "[" << std::endl;
21006        for (unsigned int i = 0; i < obj->descriptorSetCount; i++) {
21007            bool isCommaNeeded = (i+1) != obj->descriptorSetCount;
21008            print_uint32_t(obj->pDescriptorCounts[i], "", isCommaNeeded);
21009        }
21010        PRINT_SPACE
21011        _OUT << "]" << "" << std::endl;
21012      } else {
21013        _OUT << "\"NULL\"" << "" << std::endl;
21014      }
21015
21016      INDENT(-4);
21017      PRINT_SPACE
21018      if (commaNeeded)
21019          _OUT << "}," << std::endl;
21020      else
21021          _OUT << "}" << std::endl;
21022 }
21023
21024 static void print_VkDescriptorSetVariableDescriptorCountLayoutSupport(VkDescriptorSetVariableDescriptorCountLayoutSupport obj, const std::string& s, bool commaNeeded=true) {
21025      PRINT_SPACE
21026      _OUT << "{" << std::endl;
21027      INDENT(4);
21028
21029      print_VkStructureType(obj.sType, "sType", 1);
21030
21031       if (obj.pNext) {
21032          dumpPNextChain(obj.pNext);
21033       } else {
21034          PRINT_SPACE
21035          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21036      }
21037
21038      print_uint32_t(obj.maxVariableDescriptorCount, "maxVariableDescriptorCount", 0);
21039
21040      INDENT(-4);
21041      PRINT_SPACE
21042      if (commaNeeded)
21043          _OUT << "}," << std::endl;
21044      else
21045          _OUT << "}" << std::endl;
21046 }
21047 static void print_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport * obj, const std::string& s, bool commaNeeded=true) {
21048      PRINT_SPACE
21049      _OUT << "{" << std::endl;
21050      INDENT(4);
21051
21052      print_VkStructureType(obj->sType, "sType", 1);
21053
21054       if (obj->pNext) {
21055          dumpPNextChain(obj->pNext);
21056       } else {
21057          PRINT_SPACE
21058          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21059      }
21060
21061      print_uint32_t(obj->maxVariableDescriptorCount, "maxVariableDescriptorCount", 0);
21062
21063      INDENT(-4);
21064      PRINT_SPACE
21065      if (commaNeeded)
21066          _OUT << "}," << std::endl;
21067      else
21068          _OUT << "}" << std::endl;
21069 }
21070
21071 static void print_VkSubpassDescriptionDepthStencilResolve(VkSubpassDescriptionDepthStencilResolve obj, const std::string& s, bool commaNeeded=true) {
21072      PRINT_SPACE
21073      _OUT << "{" << std::endl;
21074      INDENT(4);
21075
21076      print_VkStructureType(obj.sType, "sType", 1);
21077
21078       if (obj.pNext) {
21079          dumpPNextChain(obj.pNext);
21080       } else {
21081          PRINT_SPACE
21082          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21083      }
21084
21085      print_VkResolveModeFlagBits(obj.depthResolveMode, "depthResolveMode", 1);
21086
21087      print_VkResolveModeFlagBits(obj.stencilResolveMode, "stencilResolveMode", 1);
21088
21089      PRINT_SPACE
21090      _OUT << "\"pDepthStencilResolveAttachment\": " << std::endl;
21091      if (obj.pDepthStencilResolveAttachment) {
21092            print_VkAttachmentReference2(obj.pDepthStencilResolveAttachment, "pDepthStencilResolveAttachment", 0);
21093      }
21094      else
21095      {
21096          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
21097      }
21098
21099      INDENT(-4);
21100      PRINT_SPACE
21101      if (commaNeeded)
21102          _OUT << "}," << std::endl;
21103      else
21104          _OUT << "}" << std::endl;
21105 }
21106 static void print_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve * obj, const std::string& s, bool commaNeeded=true) {
21107      PRINT_SPACE
21108      _OUT << "{" << std::endl;
21109      INDENT(4);
21110
21111      print_VkStructureType(obj->sType, "sType", 1);
21112
21113       if (obj->pNext) {
21114          dumpPNextChain(obj->pNext);
21115       } else {
21116          PRINT_SPACE
21117          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21118      }
21119
21120      print_VkResolveModeFlagBits(obj->depthResolveMode, "depthResolveMode", 1);
21121
21122      print_VkResolveModeFlagBits(obj->stencilResolveMode, "stencilResolveMode", 1);
21123
21124      PRINT_SPACE
21125      _OUT << "\"pDepthStencilResolveAttachment\": " << std::endl;
21126      if (obj->pDepthStencilResolveAttachment) {
21127            print_VkAttachmentReference2(obj->pDepthStencilResolveAttachment, "pDepthStencilResolveAttachment", 0);
21128      }
21129      else
21130      {
21131          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
21132      }
21133
21134      INDENT(-4);
21135      PRINT_SPACE
21136      if (commaNeeded)
21137          _OUT << "}," << std::endl;
21138      else
21139          _OUT << "}" << std::endl;
21140 }
21141
21142 static void print_VkPhysicalDeviceDepthStencilResolveProperties(VkPhysicalDeviceDepthStencilResolveProperties obj, const std::string& s, bool commaNeeded=true) {
21143      PRINT_SPACE
21144      _OUT << "{" << std::endl;
21145      INDENT(4);
21146
21147      print_VkStructureType(obj.sType, "sType", 1);
21148
21149       if (obj.pNext) {
21150          dumpPNextChain(obj.pNext);
21151       } else {
21152          PRINT_SPACE
21153          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21154      }
21155
21156      print_VkResolveModeFlags(obj.supportedDepthResolveModes, "supportedDepthResolveModes", 1);
21157
21158      print_VkResolveModeFlags(obj.supportedStencilResolveModes, "supportedStencilResolveModes", 1);
21159
21160      print_VkBool32(obj.independentResolveNone, "independentResolveNone", 1);
21161
21162      print_VkBool32(obj.independentResolve, "independentResolve", 0);
21163
21164      INDENT(-4);
21165      PRINT_SPACE
21166      if (commaNeeded)
21167          _OUT << "}," << std::endl;
21168      else
21169          _OUT << "}" << std::endl;
21170 }
21171 static void print_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties * obj, const std::string& s, bool commaNeeded=true) {
21172      PRINT_SPACE
21173      _OUT << "{" << std::endl;
21174      INDENT(4);
21175
21176      print_VkStructureType(obj->sType, "sType", 1);
21177
21178       if (obj->pNext) {
21179          dumpPNextChain(obj->pNext);
21180       } else {
21181          PRINT_SPACE
21182          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21183      }
21184
21185      print_VkResolveModeFlags(obj->supportedDepthResolveModes, "supportedDepthResolveModes", 1);
21186
21187      print_VkResolveModeFlags(obj->supportedStencilResolveModes, "supportedStencilResolveModes", 1);
21188
21189      print_VkBool32(obj->independentResolveNone, "independentResolveNone", 1);
21190
21191      print_VkBool32(obj->independentResolve, "independentResolve", 0);
21192
21193      INDENT(-4);
21194      PRINT_SPACE
21195      if (commaNeeded)
21196          _OUT << "}," << std::endl;
21197      else
21198          _OUT << "}" << std::endl;
21199 }
21200
21201 static void print_VkPhysicalDeviceScalarBlockLayoutFeatures(VkPhysicalDeviceScalarBlockLayoutFeatures obj, const std::string& s, bool commaNeeded=true) {
21202      PRINT_SPACE
21203      _OUT << "{" << std::endl;
21204      INDENT(4);
21205
21206      print_VkStructureType(obj.sType, "sType", 1);
21207
21208       if (obj.pNext) {
21209          dumpPNextChain(obj.pNext);
21210       } else {
21211          PRINT_SPACE
21212          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21213      }
21214
21215      print_VkBool32(obj.scalarBlockLayout, "scalarBlockLayout", 0);
21216
21217      INDENT(-4);
21218      PRINT_SPACE
21219      if (commaNeeded)
21220          _OUT << "}," << std::endl;
21221      else
21222          _OUT << "}" << std::endl;
21223 }
21224 static void print_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures * obj, const std::string& s, bool commaNeeded=true) {
21225      PRINT_SPACE
21226      _OUT << "{" << std::endl;
21227      INDENT(4);
21228
21229      print_VkStructureType(obj->sType, "sType", 1);
21230
21231       if (obj->pNext) {
21232          dumpPNextChain(obj->pNext);
21233       } else {
21234          PRINT_SPACE
21235          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21236      }
21237
21238      print_VkBool32(obj->scalarBlockLayout, "scalarBlockLayout", 0);
21239
21240      INDENT(-4);
21241      PRINT_SPACE
21242      if (commaNeeded)
21243          _OUT << "}," << std::endl;
21244      else
21245          _OUT << "}" << std::endl;
21246 }
21247
21248 static void print_VkImageStencilUsageCreateInfo(VkImageStencilUsageCreateInfo obj, const std::string& s, bool commaNeeded=true) {
21249      PRINT_SPACE
21250      _OUT << "{" << std::endl;
21251      INDENT(4);
21252
21253      print_VkStructureType(obj.sType, "sType", 1);
21254
21255       if (obj.pNext) {
21256          dumpPNextChain(obj.pNext);
21257       } else {
21258          PRINT_SPACE
21259          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21260      }
21261
21262      print_VkImageUsageFlags(obj.stencilUsage, "stencilUsage", 0);
21263
21264      INDENT(-4);
21265      PRINT_SPACE
21266      if (commaNeeded)
21267          _OUT << "}," << std::endl;
21268      else
21269          _OUT << "}" << std::endl;
21270 }
21271 static void print_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
21272      PRINT_SPACE
21273      _OUT << "{" << std::endl;
21274      INDENT(4);
21275
21276      print_VkStructureType(obj->sType, "sType", 1);
21277
21278       if (obj->pNext) {
21279          dumpPNextChain(obj->pNext);
21280       } else {
21281          PRINT_SPACE
21282          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21283      }
21284
21285      print_VkImageUsageFlags(obj->stencilUsage, "stencilUsage", 0);
21286
21287      INDENT(-4);
21288      PRINT_SPACE
21289      if (commaNeeded)
21290          _OUT << "}," << std::endl;
21291      else
21292          _OUT << "}" << std::endl;
21293 }
21294
21295 static void print_VkSamplerReductionModeCreateInfo(VkSamplerReductionModeCreateInfo obj, const std::string& s, bool commaNeeded=true) {
21296      PRINT_SPACE
21297      _OUT << "{" << std::endl;
21298      INDENT(4);
21299
21300      print_VkStructureType(obj.sType, "sType", 1);
21301
21302       if (obj.pNext) {
21303          dumpPNextChain(obj.pNext);
21304       } else {
21305          PRINT_SPACE
21306          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21307      }
21308
21309      print_VkSamplerReductionMode(obj.reductionMode, "reductionMode", 0);
21310
21311      INDENT(-4);
21312      PRINT_SPACE
21313      if (commaNeeded)
21314          _OUT << "}," << std::endl;
21315      else
21316          _OUT << "}" << std::endl;
21317 }
21318 static void print_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
21319      PRINT_SPACE
21320      _OUT << "{" << std::endl;
21321      INDENT(4);
21322
21323      print_VkStructureType(obj->sType, "sType", 1);
21324
21325       if (obj->pNext) {
21326          dumpPNextChain(obj->pNext);
21327       } else {
21328          PRINT_SPACE
21329          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21330      }
21331
21332      print_VkSamplerReductionMode(obj->reductionMode, "reductionMode", 0);
21333
21334      INDENT(-4);
21335      PRINT_SPACE
21336      if (commaNeeded)
21337          _OUT << "}," << std::endl;
21338      else
21339          _OUT << "}" << std::endl;
21340 }
21341
21342 static void print_VkPhysicalDeviceSamplerFilterMinmaxProperties(VkPhysicalDeviceSamplerFilterMinmaxProperties obj, const std::string& s, bool commaNeeded=true) {
21343      PRINT_SPACE
21344      _OUT << "{" << std::endl;
21345      INDENT(4);
21346
21347      print_VkStructureType(obj.sType, "sType", 1);
21348
21349       if (obj.pNext) {
21350          dumpPNextChain(obj.pNext);
21351       } else {
21352          PRINT_SPACE
21353          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21354      }
21355
21356      print_VkBool32(obj.filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1);
21357
21358      print_VkBool32(obj.filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 0);
21359
21360      INDENT(-4);
21361      PRINT_SPACE
21362      if (commaNeeded)
21363          _OUT << "}," << std::endl;
21364      else
21365          _OUT << "}" << std::endl;
21366 }
21367 static void print_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties * obj, const std::string& s, bool commaNeeded=true) {
21368      PRINT_SPACE
21369      _OUT << "{" << std::endl;
21370      INDENT(4);
21371
21372      print_VkStructureType(obj->sType, "sType", 1);
21373
21374       if (obj->pNext) {
21375          dumpPNextChain(obj->pNext);
21376       } else {
21377          PRINT_SPACE
21378          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21379      }
21380
21381      print_VkBool32(obj->filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1);
21382
21383      print_VkBool32(obj->filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 0);
21384
21385      INDENT(-4);
21386      PRINT_SPACE
21387      if (commaNeeded)
21388          _OUT << "}," << std::endl;
21389      else
21390          _OUT << "}" << std::endl;
21391 }
21392
21393 static void print_VkPhysicalDeviceVulkanMemoryModelFeatures(VkPhysicalDeviceVulkanMemoryModelFeatures obj, const std::string& s, bool commaNeeded=true) {
21394      PRINT_SPACE
21395      _OUT << "{" << std::endl;
21396      INDENT(4);
21397
21398      print_VkStructureType(obj.sType, "sType", 1);
21399
21400       if (obj.pNext) {
21401          dumpPNextChain(obj.pNext);
21402       } else {
21403          PRINT_SPACE
21404          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21405      }
21406
21407      print_VkBool32(obj.vulkanMemoryModel, "vulkanMemoryModel", 1);
21408
21409      print_VkBool32(obj.vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1);
21410
21411      print_VkBool32(obj.vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains", 0);
21412
21413      INDENT(-4);
21414      PRINT_SPACE
21415      if (commaNeeded)
21416          _OUT << "}," << std::endl;
21417      else
21418          _OUT << "}" << std::endl;
21419 }
21420 static void print_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures * obj, const std::string& s, bool commaNeeded=true) {
21421      PRINT_SPACE
21422      _OUT << "{" << std::endl;
21423      INDENT(4);
21424
21425      print_VkStructureType(obj->sType, "sType", 1);
21426
21427       if (obj->pNext) {
21428          dumpPNextChain(obj->pNext);
21429       } else {
21430          PRINT_SPACE
21431          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21432      }
21433
21434      print_VkBool32(obj->vulkanMemoryModel, "vulkanMemoryModel", 1);
21435
21436      print_VkBool32(obj->vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1);
21437
21438      print_VkBool32(obj->vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains", 0);
21439
21440      INDENT(-4);
21441      PRINT_SPACE
21442      if (commaNeeded)
21443          _OUT << "}," << std::endl;
21444      else
21445          _OUT << "}" << std::endl;
21446 }
21447
21448 static void print_VkPhysicalDeviceImagelessFramebufferFeatures(VkPhysicalDeviceImagelessFramebufferFeatures obj, const std::string& s, bool commaNeeded=true) {
21449      PRINT_SPACE
21450      _OUT << "{" << std::endl;
21451      INDENT(4);
21452
21453      print_VkStructureType(obj.sType, "sType", 1);
21454
21455       if (obj.pNext) {
21456          dumpPNextChain(obj.pNext);
21457       } else {
21458          PRINT_SPACE
21459          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21460      }
21461
21462      print_VkBool32(obj.imagelessFramebuffer, "imagelessFramebuffer", 0);
21463
21464      INDENT(-4);
21465      PRINT_SPACE
21466      if (commaNeeded)
21467          _OUT << "}," << std::endl;
21468      else
21469          _OUT << "}" << std::endl;
21470 }
21471 static void print_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures * obj, const std::string& s, bool commaNeeded=true) {
21472      PRINT_SPACE
21473      _OUT << "{" << std::endl;
21474      INDENT(4);
21475
21476      print_VkStructureType(obj->sType, "sType", 1);
21477
21478       if (obj->pNext) {
21479          dumpPNextChain(obj->pNext);
21480       } else {
21481          PRINT_SPACE
21482          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21483      }
21484
21485      print_VkBool32(obj->imagelessFramebuffer, "imagelessFramebuffer", 0);
21486
21487      INDENT(-4);
21488      PRINT_SPACE
21489      if (commaNeeded)
21490          _OUT << "}," << std::endl;
21491      else
21492          _OUT << "}" << std::endl;
21493 }
21494
21495 static void print_VkFramebufferAttachmentImageInfo(VkFramebufferAttachmentImageInfo obj, const std::string& s, bool commaNeeded=true) {
21496      PRINT_SPACE
21497      _OUT << "{" << std::endl;
21498      INDENT(4);
21499
21500      print_VkStructureType(obj.sType, "sType", 1);
21501
21502       if (obj.pNext) {
21503          dumpPNextChain(obj.pNext);
21504       } else {
21505          PRINT_SPACE
21506          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21507      }
21508
21509      print_VkImageCreateFlags(obj.flags, "flags", 1);
21510
21511      print_VkImageUsageFlags(obj.usage, "usage", 1);
21512
21513      print_uint32_t(obj.width, "width", 1);
21514
21515      print_uint32_t(obj.height, "height", 1);
21516
21517      print_uint32_t(obj.layerCount, "layerCount", 1);
21518
21519      print_uint32_t(obj.viewFormatCount, "viewFormatCount", 1);
21520
21521      PRINT_SPACE
21522      _OUT << "\"pViewFormats\":" << std::endl;
21523      PRINT_SPACE
21524      if (obj.pViewFormats) {
21525        _OUT << "[" << std::endl;
21526        for (unsigned int i = 0; i < obj.viewFormatCount; i++) {
21527            bool isCommaNeeded = (i+1) != obj.viewFormatCount;
21528            print_VkFormat(obj.pViewFormats[i], "", isCommaNeeded);
21529        }
21530        PRINT_SPACE
21531        _OUT << "]" << "" << std::endl;
21532      } else {
21533        _OUT << "\"NULL\"" << "" << std::endl;
21534      }
21535
21536      INDENT(-4);
21537      PRINT_SPACE
21538      if (commaNeeded)
21539          _OUT << "}," << std::endl;
21540      else
21541          _OUT << "}" << std::endl;
21542 }
21543 static void print_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo * obj, const std::string& s, bool commaNeeded=true) {
21544      PRINT_SPACE
21545      _OUT << "{" << std::endl;
21546      INDENT(4);
21547
21548      print_VkStructureType(obj->sType, "sType", 1);
21549
21550       if (obj->pNext) {
21551          dumpPNextChain(obj->pNext);
21552       } else {
21553          PRINT_SPACE
21554          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21555      }
21556
21557      print_VkImageCreateFlags(obj->flags, "flags", 1);
21558
21559      print_VkImageUsageFlags(obj->usage, "usage", 1);
21560
21561      print_uint32_t(obj->width, "width", 1);
21562
21563      print_uint32_t(obj->height, "height", 1);
21564
21565      print_uint32_t(obj->layerCount, "layerCount", 1);
21566
21567      print_uint32_t(obj->viewFormatCount, "viewFormatCount", 1);
21568
21569      PRINT_SPACE
21570      _OUT << "\"pViewFormats\":" << std::endl;
21571      PRINT_SPACE
21572      if (obj->pViewFormats) {
21573        _OUT << "[" << std::endl;
21574        for (unsigned int i = 0; i < obj->viewFormatCount; i++) {
21575            bool isCommaNeeded = (i+1) != obj->viewFormatCount;
21576            print_VkFormat(obj->pViewFormats[i], "", isCommaNeeded);
21577        }
21578        PRINT_SPACE
21579        _OUT << "]" << "" << std::endl;
21580      } else {
21581        _OUT << "\"NULL\"" << "" << std::endl;
21582      }
21583
21584      INDENT(-4);
21585      PRINT_SPACE
21586      if (commaNeeded)
21587          _OUT << "}," << std::endl;
21588      else
21589          _OUT << "}" << std::endl;
21590 }
21591
21592 static void print_VkFramebufferAttachmentsCreateInfo(VkFramebufferAttachmentsCreateInfo obj, const std::string& s, bool commaNeeded=true) {
21593      PRINT_SPACE
21594      _OUT << "{" << std::endl;
21595      INDENT(4);
21596
21597      print_VkStructureType(obj.sType, "sType", 1);
21598
21599       if (obj.pNext) {
21600          dumpPNextChain(obj.pNext);
21601       } else {
21602          PRINT_SPACE
21603          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21604      }
21605
21606      print_uint32_t(obj.attachmentImageInfoCount, "attachmentImageInfoCount", 1);
21607
21608      PRINT_SPACE
21609      _OUT << "\"pAttachmentImageInfos\": " << std::endl;
21610      if (obj.pAttachmentImageInfos) {
21611          PRINT_SPACE
21612          _OUT << "[" << std::endl;
21613          for (unsigned int i = 0; i < obj.attachmentImageInfoCount; i++) {
21614            if (i+1 == obj.attachmentImageInfoCount)
21615                print_VkFramebufferAttachmentImageInfo(obj.pAttachmentImageInfos[i], "pAttachmentImageInfos", 0);
21616            else
21617                print_VkFramebufferAttachmentImageInfo(obj.pAttachmentImageInfos[i], "pAttachmentImageInfos", 1);
21618          }
21619          PRINT_SPACE
21620          _OUT << "]" << std::endl;
21621     }
21622      else
21623      {
21624          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
21625      }
21626
21627      INDENT(-4);
21628      PRINT_SPACE
21629      if (commaNeeded)
21630          _OUT << "}," << std::endl;
21631      else
21632          _OUT << "}" << std::endl;
21633 }
21634 static void print_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
21635      PRINT_SPACE
21636      _OUT << "{" << std::endl;
21637      INDENT(4);
21638
21639      print_VkStructureType(obj->sType, "sType", 1);
21640
21641       if (obj->pNext) {
21642          dumpPNextChain(obj->pNext);
21643       } else {
21644          PRINT_SPACE
21645          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21646      }
21647
21648      print_uint32_t(obj->attachmentImageInfoCount, "attachmentImageInfoCount", 1);
21649
21650      PRINT_SPACE
21651      _OUT << "\"pAttachmentImageInfos\": " << std::endl;
21652      if (obj->pAttachmentImageInfos) {
21653          PRINT_SPACE
21654          _OUT << "[" << std::endl;
21655          for (unsigned int i = 0; i < obj->attachmentImageInfoCount; i++) {
21656            if (i+1 == obj->attachmentImageInfoCount)
21657                print_VkFramebufferAttachmentImageInfo(obj->pAttachmentImageInfos[i], "pAttachmentImageInfos", 0);
21658            else
21659                print_VkFramebufferAttachmentImageInfo(obj->pAttachmentImageInfos[i], "pAttachmentImageInfos", 1);
21660          }
21661          PRINT_SPACE
21662          _OUT << "]" << std::endl;
21663     }
21664      else
21665      {
21666          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
21667      }
21668
21669      INDENT(-4);
21670      PRINT_SPACE
21671      if (commaNeeded)
21672          _OUT << "}," << std::endl;
21673      else
21674          _OUT << "}" << std::endl;
21675 }
21676
21677 static void print_VkRenderPassAttachmentBeginInfo(VkRenderPassAttachmentBeginInfo obj, const std::string& s, bool commaNeeded=true) {
21678      PRINT_SPACE
21679      _OUT << "{" << std::endl;
21680      INDENT(4);
21681
21682      print_VkStructureType(obj.sType, "sType", 1);
21683
21684       if (obj.pNext) {
21685          dumpPNextChain(obj.pNext);
21686       } else {
21687          PRINT_SPACE
21688          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21689      }
21690
21691      print_uint32_t(obj.attachmentCount, "attachmentCount", 1);
21692
21693      PRINT_SPACE
21694      _OUT << "\"pAttachments\":" << std::endl;
21695      PRINT_SPACE
21696      if (obj.pAttachments) {
21697        _OUT << "[" << std::endl;
21698        for (unsigned int i = 0; i < obj.attachmentCount; i++) {
21699            std:: stringstream tmp;
21700            tmp << "pAttachments" << "_" << i;
21701            bool isCommaNeeded = (i+1) != obj.attachmentCount;
21702            print_VkImageView(obj.pAttachments[i], tmp.str(), isCommaNeeded);
21703        }
21704        PRINT_SPACE
21705        _OUT << "]" << "" << std::endl;
21706      } else {
21707        _OUT << "\"NULL\"" << "" << std::endl;
21708      }
21709
21710      INDENT(-4);
21711      PRINT_SPACE
21712      if (commaNeeded)
21713          _OUT << "}," << std::endl;
21714      else
21715          _OUT << "}" << std::endl;
21716 }
21717 static void print_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo * obj, const std::string& s, bool commaNeeded=true) {
21718      PRINT_SPACE
21719      _OUT << "{" << std::endl;
21720      INDENT(4);
21721
21722      print_VkStructureType(obj->sType, "sType", 1);
21723
21724       if (obj->pNext) {
21725          dumpPNextChain(obj->pNext);
21726       } else {
21727          PRINT_SPACE
21728          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21729      }
21730
21731      print_uint32_t(obj->attachmentCount, "attachmentCount", 1);
21732
21733      PRINT_SPACE
21734      _OUT << "\"pAttachments\":" << std::endl;
21735      PRINT_SPACE
21736      if (obj->pAttachments) {
21737        _OUT << "[" << std::endl;
21738        for (unsigned int i = 0; i < obj->attachmentCount; i++) {
21739            std:: stringstream tmp;
21740            tmp << "pAttachments" << "_" << i;
21741            bool isCommaNeeded = (i+1) != obj->attachmentCount;
21742            print_VkImageView(obj->pAttachments[i], tmp.str(), isCommaNeeded);
21743        }
21744        PRINT_SPACE
21745        _OUT << "]" << "" << std::endl;
21746      } else {
21747        _OUT << "\"NULL\"" << "" << std::endl;
21748      }
21749
21750      INDENT(-4);
21751      PRINT_SPACE
21752      if (commaNeeded)
21753          _OUT << "}," << std::endl;
21754      else
21755          _OUT << "}" << std::endl;
21756 }
21757
21758 static void print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(VkPhysicalDeviceUniformBufferStandardLayoutFeatures obj, const std::string& s, bool commaNeeded=true) {
21759      PRINT_SPACE
21760      _OUT << "{" << std::endl;
21761      INDENT(4);
21762
21763      print_VkStructureType(obj.sType, "sType", 1);
21764
21765       if (obj.pNext) {
21766          dumpPNextChain(obj.pNext);
21767       } else {
21768          PRINT_SPACE
21769          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21770      }
21771
21772      print_VkBool32(obj.uniformBufferStandardLayout, "uniformBufferStandardLayout", 0);
21773
21774      INDENT(-4);
21775      PRINT_SPACE
21776      if (commaNeeded)
21777          _OUT << "}," << std::endl;
21778      else
21779          _OUT << "}" << std::endl;
21780 }
21781 static void print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * obj, const std::string& s, bool commaNeeded=true) {
21782      PRINT_SPACE
21783      _OUT << "{" << std::endl;
21784      INDENT(4);
21785
21786      print_VkStructureType(obj->sType, "sType", 1);
21787
21788       if (obj->pNext) {
21789          dumpPNextChain(obj->pNext);
21790       } else {
21791          PRINT_SPACE
21792          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21793      }
21794
21795      print_VkBool32(obj->uniformBufferStandardLayout, "uniformBufferStandardLayout", 0);
21796
21797      INDENT(-4);
21798      PRINT_SPACE
21799      if (commaNeeded)
21800          _OUT << "}," << std::endl;
21801      else
21802          _OUT << "}" << std::endl;
21803 }
21804
21805 static void print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures obj, const std::string& s, bool commaNeeded=true) {
21806      PRINT_SPACE
21807      _OUT << "{" << std::endl;
21808      INDENT(4);
21809
21810      print_VkStructureType(obj.sType, "sType", 1);
21811
21812       if (obj.pNext) {
21813          dumpPNextChain(obj.pNext);
21814       } else {
21815          PRINT_SPACE
21816          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21817      }
21818
21819      print_VkBool32(obj.shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 0);
21820
21821      INDENT(-4);
21822      PRINT_SPACE
21823      if (commaNeeded)
21824          _OUT << "}," << std::endl;
21825      else
21826          _OUT << "}" << std::endl;
21827 }
21828 static void print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * obj, const std::string& s, bool commaNeeded=true) {
21829      PRINT_SPACE
21830      _OUT << "{" << std::endl;
21831      INDENT(4);
21832
21833      print_VkStructureType(obj->sType, "sType", 1);
21834
21835       if (obj->pNext) {
21836          dumpPNextChain(obj->pNext);
21837       } else {
21838          PRINT_SPACE
21839          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21840      }
21841
21842      print_VkBool32(obj->shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 0);
21843
21844      INDENT(-4);
21845      PRINT_SPACE
21846      if (commaNeeded)
21847          _OUT << "}," << std::endl;
21848      else
21849          _OUT << "}" << std::endl;
21850 }
21851
21852 static void print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures obj, const std::string& s, bool commaNeeded=true) {
21853      PRINT_SPACE
21854      _OUT << "{" << std::endl;
21855      INDENT(4);
21856
21857      print_VkStructureType(obj.sType, "sType", 1);
21858
21859       if (obj.pNext) {
21860          dumpPNextChain(obj.pNext);
21861       } else {
21862          PRINT_SPACE
21863          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21864      }
21865
21866      print_VkBool32(obj.separateDepthStencilLayouts, "separateDepthStencilLayouts", 0);
21867
21868      INDENT(-4);
21869      PRINT_SPACE
21870      if (commaNeeded)
21871          _OUT << "}," << std::endl;
21872      else
21873          _OUT << "}" << std::endl;
21874 }
21875 static void print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * obj, const std::string& s, bool commaNeeded=true) {
21876      PRINT_SPACE
21877      _OUT << "{" << std::endl;
21878      INDENT(4);
21879
21880      print_VkStructureType(obj->sType, "sType", 1);
21881
21882       if (obj->pNext) {
21883          dumpPNextChain(obj->pNext);
21884       } else {
21885          PRINT_SPACE
21886          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21887      }
21888
21889      print_VkBool32(obj->separateDepthStencilLayouts, "separateDepthStencilLayouts", 0);
21890
21891      INDENT(-4);
21892      PRINT_SPACE
21893      if (commaNeeded)
21894          _OUT << "}," << std::endl;
21895      else
21896          _OUT << "}" << std::endl;
21897 }
21898
21899 static void print_VkAttachmentReferenceStencilLayout(VkAttachmentReferenceStencilLayout obj, const std::string& s, bool commaNeeded=true) {
21900      PRINT_SPACE
21901      _OUT << "{" << std::endl;
21902      INDENT(4);
21903
21904      print_VkStructureType(obj.sType, "sType", 1);
21905
21906       if (obj.pNext) {
21907          dumpPNextChain(obj.pNext);
21908       } else {
21909          PRINT_SPACE
21910          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21911      }
21912
21913      print_VkImageLayout(obj.stencilLayout, "stencilLayout", 0);
21914
21915      INDENT(-4);
21916      PRINT_SPACE
21917      if (commaNeeded)
21918          _OUT << "}," << std::endl;
21919      else
21920          _OUT << "}" << std::endl;
21921 }
21922 static void print_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout * obj, const std::string& s, bool commaNeeded=true) {
21923      PRINT_SPACE
21924      _OUT << "{" << std::endl;
21925      INDENT(4);
21926
21927      print_VkStructureType(obj->sType, "sType", 1);
21928
21929       if (obj->pNext) {
21930          dumpPNextChain(obj->pNext);
21931       } else {
21932          PRINT_SPACE
21933          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21934      }
21935
21936      print_VkImageLayout(obj->stencilLayout, "stencilLayout", 0);
21937
21938      INDENT(-4);
21939      PRINT_SPACE
21940      if (commaNeeded)
21941          _OUT << "}," << std::endl;
21942      else
21943          _OUT << "}" << std::endl;
21944 }
21945
21946 static void print_VkAttachmentDescriptionStencilLayout(VkAttachmentDescriptionStencilLayout obj, const std::string& s, bool commaNeeded=true) {
21947      PRINT_SPACE
21948      _OUT << "{" << std::endl;
21949      INDENT(4);
21950
21951      print_VkStructureType(obj.sType, "sType", 1);
21952
21953       if (obj.pNext) {
21954          dumpPNextChain(obj.pNext);
21955       } else {
21956          PRINT_SPACE
21957          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21958      }
21959
21960      print_VkImageLayout(obj.stencilInitialLayout, "stencilInitialLayout", 1);
21961
21962      print_VkImageLayout(obj.stencilFinalLayout, "stencilFinalLayout", 0);
21963
21964      INDENT(-4);
21965      PRINT_SPACE
21966      if (commaNeeded)
21967          _OUT << "}," << std::endl;
21968      else
21969          _OUT << "}" << std::endl;
21970 }
21971 static void print_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout * obj, const std::string& s, bool commaNeeded=true) {
21972      PRINT_SPACE
21973      _OUT << "{" << std::endl;
21974      INDENT(4);
21975
21976      print_VkStructureType(obj->sType, "sType", 1);
21977
21978       if (obj->pNext) {
21979          dumpPNextChain(obj->pNext);
21980       } else {
21981          PRINT_SPACE
21982          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
21983      }
21984
21985      print_VkImageLayout(obj->stencilInitialLayout, "stencilInitialLayout", 1);
21986
21987      print_VkImageLayout(obj->stencilFinalLayout, "stencilFinalLayout", 0);
21988
21989      INDENT(-4);
21990      PRINT_SPACE
21991      if (commaNeeded)
21992          _OUT << "}," << std::endl;
21993      else
21994          _OUT << "}" << std::endl;
21995 }
21996
21997 static void print_VkPhysicalDeviceHostQueryResetFeatures(VkPhysicalDeviceHostQueryResetFeatures obj, const std::string& s, bool commaNeeded=true) {
21998      PRINT_SPACE
21999      _OUT << "{" << std::endl;
22000      INDENT(4);
22001
22002      print_VkStructureType(obj.sType, "sType", 1);
22003
22004       if (obj.pNext) {
22005          dumpPNextChain(obj.pNext);
22006       } else {
22007          PRINT_SPACE
22008          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22009      }
22010
22011      print_VkBool32(obj.hostQueryReset, "hostQueryReset", 0);
22012
22013      INDENT(-4);
22014      PRINT_SPACE
22015      if (commaNeeded)
22016          _OUT << "}," << std::endl;
22017      else
22018          _OUT << "}" << std::endl;
22019 }
22020 static void print_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures * obj, const std::string& s, bool commaNeeded=true) {
22021      PRINT_SPACE
22022      _OUT << "{" << std::endl;
22023      INDENT(4);
22024
22025      print_VkStructureType(obj->sType, "sType", 1);
22026
22027       if (obj->pNext) {
22028          dumpPNextChain(obj->pNext);
22029       } else {
22030          PRINT_SPACE
22031          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22032      }
22033
22034      print_VkBool32(obj->hostQueryReset, "hostQueryReset", 0);
22035
22036      INDENT(-4);
22037      PRINT_SPACE
22038      if (commaNeeded)
22039          _OUT << "}," << std::endl;
22040      else
22041          _OUT << "}" << std::endl;
22042 }
22043
22044 static void print_VkPhysicalDeviceTimelineSemaphoreFeatures(VkPhysicalDeviceTimelineSemaphoreFeatures obj, const std::string& s, bool commaNeeded=true) {
22045      PRINT_SPACE
22046      _OUT << "{" << std::endl;
22047      INDENT(4);
22048
22049      print_VkStructureType(obj.sType, "sType", 1);
22050
22051       if (obj.pNext) {
22052          dumpPNextChain(obj.pNext);
22053       } else {
22054          PRINT_SPACE
22055          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22056      }
22057
22058      print_VkBool32(obj.timelineSemaphore, "timelineSemaphore", 0);
22059
22060      INDENT(-4);
22061      PRINT_SPACE
22062      if (commaNeeded)
22063          _OUT << "}," << std::endl;
22064      else
22065          _OUT << "}" << std::endl;
22066 }
22067 static void print_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures * obj, const std::string& s, bool commaNeeded=true) {
22068      PRINT_SPACE
22069      _OUT << "{" << std::endl;
22070      INDENT(4);
22071
22072      print_VkStructureType(obj->sType, "sType", 1);
22073
22074       if (obj->pNext) {
22075          dumpPNextChain(obj->pNext);
22076       } else {
22077          PRINT_SPACE
22078          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22079      }
22080
22081      print_VkBool32(obj->timelineSemaphore, "timelineSemaphore", 0);
22082
22083      INDENT(-4);
22084      PRINT_SPACE
22085      if (commaNeeded)
22086          _OUT << "}," << std::endl;
22087      else
22088          _OUT << "}" << std::endl;
22089 }
22090
22091 static void print_VkPhysicalDeviceTimelineSemaphoreProperties(VkPhysicalDeviceTimelineSemaphoreProperties obj, const std::string& s, bool commaNeeded=true) {
22092      PRINT_SPACE
22093      _OUT << "{" << std::endl;
22094      INDENT(4);
22095
22096      print_VkStructureType(obj.sType, "sType", 1);
22097
22098       if (obj.pNext) {
22099          dumpPNextChain(obj.pNext);
22100       } else {
22101          PRINT_SPACE
22102          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22103      }
22104
22105      print_uint64_t(obj.maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 0);
22106
22107      INDENT(-4);
22108      PRINT_SPACE
22109      if (commaNeeded)
22110          _OUT << "}," << std::endl;
22111      else
22112          _OUT << "}" << std::endl;
22113 }
22114 static void print_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties * obj, const std::string& s, bool commaNeeded=true) {
22115      PRINT_SPACE
22116      _OUT << "{" << std::endl;
22117      INDENT(4);
22118
22119      print_VkStructureType(obj->sType, "sType", 1);
22120
22121       if (obj->pNext) {
22122          dumpPNextChain(obj->pNext);
22123       } else {
22124          PRINT_SPACE
22125          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22126      }
22127
22128      print_uint64_t(obj->maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 0);
22129
22130      INDENT(-4);
22131      PRINT_SPACE
22132      if (commaNeeded)
22133          _OUT << "}," << std::endl;
22134      else
22135          _OUT << "}" << std::endl;
22136 }
22137
22138 static void print_VkSemaphoreTypeCreateInfo(VkSemaphoreTypeCreateInfo obj, const std::string& s, bool commaNeeded=true) {
22139      PRINT_SPACE
22140      _OUT << "{" << std::endl;
22141      INDENT(4);
22142
22143      print_VkStructureType(obj.sType, "sType", 1);
22144
22145       if (obj.pNext) {
22146          dumpPNextChain(obj.pNext);
22147       } else {
22148          PRINT_SPACE
22149          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22150      }
22151
22152      print_VkSemaphoreType(obj.semaphoreType, "semaphoreType", 1);
22153
22154      print_uint64_t(obj.initialValue, "initialValue", 0);
22155
22156      INDENT(-4);
22157      PRINT_SPACE
22158      if (commaNeeded)
22159          _OUT << "}," << std::endl;
22160      else
22161          _OUT << "}" << std::endl;
22162 }
22163 static void print_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
22164      PRINT_SPACE
22165      _OUT << "{" << std::endl;
22166      INDENT(4);
22167
22168      print_VkStructureType(obj->sType, "sType", 1);
22169
22170       if (obj->pNext) {
22171          dumpPNextChain(obj->pNext);
22172       } else {
22173          PRINT_SPACE
22174          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22175      }
22176
22177      print_VkSemaphoreType(obj->semaphoreType, "semaphoreType", 1);
22178
22179      print_uint64_t(obj->initialValue, "initialValue", 0);
22180
22181      INDENT(-4);
22182      PRINT_SPACE
22183      if (commaNeeded)
22184          _OUT << "}," << std::endl;
22185      else
22186          _OUT << "}" << std::endl;
22187 }
22188
22189 static void print_VkTimelineSemaphoreSubmitInfo(VkTimelineSemaphoreSubmitInfo obj, const std::string& s, bool commaNeeded=true) {
22190      PRINT_SPACE
22191      _OUT << "{" << std::endl;
22192      INDENT(4);
22193
22194      print_VkStructureType(obj.sType, "sType", 1);
22195
22196       if (obj.pNext) {
22197          dumpPNextChain(obj.pNext);
22198       } else {
22199          PRINT_SPACE
22200          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22201      }
22202
22203      print_uint32_t(obj.waitSemaphoreValueCount, "waitSemaphoreValueCount", 1);
22204
22205      PRINT_SPACE
22206      _OUT << "\"pWaitSemaphoreValues\":" << std::endl;
22207      PRINT_SPACE
22208      if (obj.pWaitSemaphoreValues) {
22209        _OUT << "[" << std::endl;
22210        for (unsigned int i = 0; i < obj.waitSemaphoreValueCount; i++) {
22211            bool isCommaNeeded = (i+1) != obj.waitSemaphoreValueCount;
22212            print_uint64_t(obj.pWaitSemaphoreValues[i], "", isCommaNeeded);
22213        }
22214        PRINT_SPACE
22215        _OUT << "]" << "," << std::endl;
22216      } else {
22217        _OUT << "\"NULL\"" << "," << std::endl;
22218      }
22219
22220      print_uint32_t(obj.signalSemaphoreValueCount, "signalSemaphoreValueCount", 1);
22221
22222      PRINT_SPACE
22223      _OUT << "\"pSignalSemaphoreValues\":" << std::endl;
22224      PRINT_SPACE
22225      if (obj.pSignalSemaphoreValues) {
22226        _OUT << "[" << std::endl;
22227        for (unsigned int i = 0; i < obj.signalSemaphoreValueCount; i++) {
22228            bool isCommaNeeded = (i+1) != obj.signalSemaphoreValueCount;
22229            print_uint64_t(obj.pSignalSemaphoreValues[i], "", isCommaNeeded);
22230        }
22231        PRINT_SPACE
22232        _OUT << "]" << "" << std::endl;
22233      } else {
22234        _OUT << "\"NULL\"" << "" << std::endl;
22235      }
22236
22237      INDENT(-4);
22238      PRINT_SPACE
22239      if (commaNeeded)
22240          _OUT << "}," << std::endl;
22241      else
22242          _OUT << "}" << std::endl;
22243 }
22244 static void print_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo * obj, const std::string& s, bool commaNeeded=true) {
22245      PRINT_SPACE
22246      _OUT << "{" << std::endl;
22247      INDENT(4);
22248
22249      print_VkStructureType(obj->sType, "sType", 1);
22250
22251       if (obj->pNext) {
22252          dumpPNextChain(obj->pNext);
22253       } else {
22254          PRINT_SPACE
22255          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22256      }
22257
22258      print_uint32_t(obj->waitSemaphoreValueCount, "waitSemaphoreValueCount", 1);
22259
22260      PRINT_SPACE
22261      _OUT << "\"pWaitSemaphoreValues\":" << std::endl;
22262      PRINT_SPACE
22263      if (obj->pWaitSemaphoreValues) {
22264        _OUT << "[" << std::endl;
22265        for (unsigned int i = 0; i < obj->waitSemaphoreValueCount; i++) {
22266            bool isCommaNeeded = (i+1) != obj->waitSemaphoreValueCount;
22267            print_uint64_t(obj->pWaitSemaphoreValues[i], "", isCommaNeeded);
22268        }
22269        PRINT_SPACE
22270        _OUT << "]" << "," << std::endl;
22271      } else {
22272        _OUT << "\"NULL\"" << "," << std::endl;
22273      }
22274
22275      print_uint32_t(obj->signalSemaphoreValueCount, "signalSemaphoreValueCount", 1);
22276
22277      PRINT_SPACE
22278      _OUT << "\"pSignalSemaphoreValues\":" << std::endl;
22279      PRINT_SPACE
22280      if (obj->pSignalSemaphoreValues) {
22281        _OUT << "[" << std::endl;
22282        for (unsigned int i = 0; i < obj->signalSemaphoreValueCount; i++) {
22283            bool isCommaNeeded = (i+1) != obj->signalSemaphoreValueCount;
22284            print_uint64_t(obj->pSignalSemaphoreValues[i], "", isCommaNeeded);
22285        }
22286        PRINT_SPACE
22287        _OUT << "]" << "" << std::endl;
22288      } else {
22289        _OUT << "\"NULL\"" << "" << std::endl;
22290      }
22291
22292      INDENT(-4);
22293      PRINT_SPACE
22294      if (commaNeeded)
22295          _OUT << "}," << std::endl;
22296      else
22297          _OUT << "}" << std::endl;
22298 }
22299
22300 static void print_VkSemaphoreWaitInfo(VkSemaphoreWaitInfo obj, const std::string& s, bool commaNeeded=true) {
22301      PRINT_SPACE
22302      _OUT << "{" << std::endl;
22303      INDENT(4);
22304
22305      print_VkStructureType(obj.sType, "sType", 1);
22306
22307       if (obj.pNext) {
22308          dumpPNextChain(obj.pNext);
22309       } else {
22310          PRINT_SPACE
22311          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22312      }
22313
22314      print_VkSemaphoreWaitFlags(obj.flags, "flags", 1);
22315
22316      print_uint32_t(obj.semaphoreCount, "semaphoreCount", 1);
22317
22318      PRINT_SPACE
22319      _OUT << "\"pSemaphores\":" << std::endl;
22320      PRINT_SPACE
22321      if (obj.pSemaphores) {
22322        _OUT << "[" << std::endl;
22323        for (unsigned int i = 0; i < obj.semaphoreCount; i++) {
22324            std:: stringstream tmp;
22325            tmp << "pSemaphores" << "_" << i;
22326            bool isCommaNeeded = (i+1) != obj.semaphoreCount;
22327            print_VkSemaphore(obj.pSemaphores[i], tmp.str(), isCommaNeeded);
22328        }
22329        PRINT_SPACE
22330        _OUT << "]" << "," << std::endl;
22331      } else {
22332        _OUT << "\"NULL\"" << "," << std::endl;
22333      }
22334
22335      PRINT_SPACE
22336      _OUT << "\"pValues\":" << std::endl;
22337      PRINT_SPACE
22338      if (obj.pValues) {
22339        _OUT << "[" << std::endl;
22340        for (unsigned int i = 0; i < obj.semaphoreCount; i++) {
22341            bool isCommaNeeded = (i+1) != obj.semaphoreCount;
22342            print_uint64_t(obj.pValues[i], "", isCommaNeeded);
22343        }
22344        PRINT_SPACE
22345        _OUT << "]" << "" << std::endl;
22346      } else {
22347        _OUT << "\"NULL\"" << "" << std::endl;
22348      }
22349
22350      INDENT(-4);
22351      PRINT_SPACE
22352      if (commaNeeded)
22353          _OUT << "}," << std::endl;
22354      else
22355          _OUT << "}" << std::endl;
22356 }
22357 static void print_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo * obj, const std::string& s, bool commaNeeded=true) {
22358      PRINT_SPACE
22359      _OUT << "{" << std::endl;
22360      INDENT(4);
22361
22362      print_VkStructureType(obj->sType, "sType", 1);
22363
22364       if (obj->pNext) {
22365          dumpPNextChain(obj->pNext);
22366       } else {
22367          PRINT_SPACE
22368          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22369      }
22370
22371      print_VkSemaphoreWaitFlags(obj->flags, "flags", 1);
22372
22373      print_uint32_t(obj->semaphoreCount, "semaphoreCount", 1);
22374
22375      PRINT_SPACE
22376      _OUT << "\"pSemaphores\":" << std::endl;
22377      PRINT_SPACE
22378      if (obj->pSemaphores) {
22379        _OUT << "[" << std::endl;
22380        for (unsigned int i = 0; i < obj->semaphoreCount; i++) {
22381            std:: stringstream tmp;
22382            tmp << "pSemaphores" << "_" << i;
22383            bool isCommaNeeded = (i+1) != obj->semaphoreCount;
22384            print_VkSemaphore(obj->pSemaphores[i], tmp.str(), isCommaNeeded);
22385        }
22386        PRINT_SPACE
22387        _OUT << "]" << "," << std::endl;
22388      } else {
22389        _OUT << "\"NULL\"" << "," << std::endl;
22390      }
22391
22392      PRINT_SPACE
22393      _OUT << "\"pValues\":" << std::endl;
22394      PRINT_SPACE
22395      if (obj->pValues) {
22396        _OUT << "[" << std::endl;
22397        for (unsigned int i = 0; i < obj->semaphoreCount; i++) {
22398            bool isCommaNeeded = (i+1) != obj->semaphoreCount;
22399            print_uint64_t(obj->pValues[i], "", isCommaNeeded);
22400        }
22401        PRINT_SPACE
22402        _OUT << "]" << "" << std::endl;
22403      } else {
22404        _OUT << "\"NULL\"" << "" << std::endl;
22405      }
22406
22407      INDENT(-4);
22408      PRINT_SPACE
22409      if (commaNeeded)
22410          _OUT << "}," << std::endl;
22411      else
22412          _OUT << "}" << std::endl;
22413 }
22414
22415 static void print_VkSemaphoreSignalInfo(VkSemaphoreSignalInfo obj, const std::string& s, bool commaNeeded=true) {
22416      PRINT_SPACE
22417      _OUT << "{" << std::endl;
22418      INDENT(4);
22419
22420      print_VkStructureType(obj.sType, "sType", 1);
22421
22422       if (obj.pNext) {
22423          dumpPNextChain(obj.pNext);
22424       } else {
22425          PRINT_SPACE
22426          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22427      }
22428
22429      // CTS : required value
22430      PRINT_SPACE    _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl;
22431
22432      print_uint64_t(obj.value, "value", 0);
22433
22434      INDENT(-4);
22435      PRINT_SPACE
22436      if (commaNeeded)
22437          _OUT << "}," << std::endl;
22438      else
22439          _OUT << "}" << std::endl;
22440 }
22441 static void print_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo * obj, const std::string& s, bool commaNeeded=true) {
22442      PRINT_SPACE
22443      _OUT << "{" << std::endl;
22444      INDENT(4);
22445
22446      print_VkStructureType(obj->sType, "sType", 1);
22447
22448       if (obj->pNext) {
22449          dumpPNextChain(obj->pNext);
22450       } else {
22451          PRINT_SPACE
22452          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22453      }
22454
22455      // CTS : required value
22456      PRINT_SPACE    _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl;
22457
22458      print_uint64_t(obj->value, "value", 0);
22459
22460      INDENT(-4);
22461      PRINT_SPACE
22462      if (commaNeeded)
22463          _OUT << "}," << std::endl;
22464      else
22465          _OUT << "}" << std::endl;
22466 }
22467
22468 static void print_VkPhysicalDeviceBufferDeviceAddressFeatures(VkPhysicalDeviceBufferDeviceAddressFeatures obj, const std::string& s, bool commaNeeded=true) {
22469      PRINT_SPACE
22470      _OUT << "{" << std::endl;
22471      INDENT(4);
22472
22473      print_VkStructureType(obj.sType, "sType", 1);
22474
22475       if (obj.pNext) {
22476          dumpPNextChain(obj.pNext);
22477       } else {
22478          PRINT_SPACE
22479          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22480      }
22481
22482      print_VkBool32(obj.bufferDeviceAddress, "bufferDeviceAddress", 1);
22483
22484      print_VkBool32(obj.bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1);
22485
22486      print_VkBool32(obj.bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 0);
22487
22488      INDENT(-4);
22489      PRINT_SPACE
22490      if (commaNeeded)
22491          _OUT << "}," << std::endl;
22492      else
22493          _OUT << "}" << std::endl;
22494 }
22495 static void print_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures * obj, const std::string& s, bool commaNeeded=true) {
22496      PRINT_SPACE
22497      _OUT << "{" << std::endl;
22498      INDENT(4);
22499
22500      print_VkStructureType(obj->sType, "sType", 1);
22501
22502       if (obj->pNext) {
22503          dumpPNextChain(obj->pNext);
22504       } else {
22505          PRINT_SPACE
22506          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22507      }
22508
22509      print_VkBool32(obj->bufferDeviceAddress, "bufferDeviceAddress", 1);
22510
22511      print_VkBool32(obj->bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1);
22512
22513      print_VkBool32(obj->bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 0);
22514
22515      INDENT(-4);
22516      PRINT_SPACE
22517      if (commaNeeded)
22518          _OUT << "}," << std::endl;
22519      else
22520          _OUT << "}" << std::endl;
22521 }
22522
22523 static void print_VkBufferDeviceAddressInfo(VkBufferDeviceAddressInfo obj, const std::string& s, bool commaNeeded=true) {
22524      PRINT_SPACE
22525      _OUT << "{" << std::endl;
22526      INDENT(4);
22527
22528      print_VkStructureType(obj.sType, "sType", 1);
22529
22530       if (obj.pNext) {
22531          dumpPNextChain(obj.pNext);
22532       } else {
22533          PRINT_SPACE
22534          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22535      }
22536
22537      // CTS : required value
22538      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"" << std::endl;
22539
22540      INDENT(-4);
22541      PRINT_SPACE
22542      if (commaNeeded)
22543          _OUT << "}," << std::endl;
22544      else
22545          _OUT << "}" << std::endl;
22546 }
22547 static void print_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo * obj, const std::string& s, bool commaNeeded=true) {
22548      PRINT_SPACE
22549      _OUT << "{" << std::endl;
22550      INDENT(4);
22551
22552      print_VkStructureType(obj->sType, "sType", 1);
22553
22554       if (obj->pNext) {
22555          dumpPNextChain(obj->pNext);
22556       } else {
22557          PRINT_SPACE
22558          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22559      }
22560
22561      // CTS : required value
22562      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"" << std::endl;
22563
22564      INDENT(-4);
22565      PRINT_SPACE
22566      if (commaNeeded)
22567          _OUT << "}," << std::endl;
22568      else
22569          _OUT << "}" << std::endl;
22570 }
22571
22572 static void print_VkBufferOpaqueCaptureAddressCreateInfo(VkBufferOpaqueCaptureAddressCreateInfo obj, const std::string& s, bool commaNeeded=true) {
22573      PRINT_SPACE
22574      _OUT << "{" << std::endl;
22575      INDENT(4);
22576
22577      print_VkStructureType(obj.sType, "sType", 1);
22578
22579       if (obj.pNext) {
22580          dumpPNextChain(obj.pNext);
22581       } else {
22582          PRINT_SPACE
22583          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22584      }
22585
22586      print_uint64_t(obj.opaqueCaptureAddress, "opaqueCaptureAddress", 0);
22587
22588      INDENT(-4);
22589      PRINT_SPACE
22590      if (commaNeeded)
22591          _OUT << "}," << std::endl;
22592      else
22593          _OUT << "}" << std::endl;
22594 }
22595 static void print_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
22596      PRINT_SPACE
22597      _OUT << "{" << std::endl;
22598      INDENT(4);
22599
22600      print_VkStructureType(obj->sType, "sType", 1);
22601
22602       if (obj->pNext) {
22603          dumpPNextChain(obj->pNext);
22604       } else {
22605          PRINT_SPACE
22606          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22607      }
22608
22609      print_uint64_t(obj->opaqueCaptureAddress, "opaqueCaptureAddress", 0);
22610
22611      INDENT(-4);
22612      PRINT_SPACE
22613      if (commaNeeded)
22614          _OUT << "}," << std::endl;
22615      else
22616          _OUT << "}" << std::endl;
22617 }
22618
22619 static void print_VkMemoryOpaqueCaptureAddressAllocateInfo(VkMemoryOpaqueCaptureAddressAllocateInfo obj, const std::string& s, bool commaNeeded=true) {
22620      PRINT_SPACE
22621      _OUT << "{" << std::endl;
22622      INDENT(4);
22623
22624      print_VkStructureType(obj.sType, "sType", 1);
22625
22626       if (obj.pNext) {
22627          dumpPNextChain(obj.pNext);
22628       } else {
22629          PRINT_SPACE
22630          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22631      }
22632
22633      print_uint64_t(obj.opaqueCaptureAddress, "opaqueCaptureAddress", 0);
22634
22635      INDENT(-4);
22636      PRINT_SPACE
22637      if (commaNeeded)
22638          _OUT << "}," << std::endl;
22639      else
22640          _OUT << "}" << std::endl;
22641 }
22642 static void print_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo * obj, const std::string& s, bool commaNeeded=true) {
22643      PRINT_SPACE
22644      _OUT << "{" << std::endl;
22645      INDENT(4);
22646
22647      print_VkStructureType(obj->sType, "sType", 1);
22648
22649       if (obj->pNext) {
22650          dumpPNextChain(obj->pNext);
22651       } else {
22652          PRINT_SPACE
22653          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22654      }
22655
22656      print_uint64_t(obj->opaqueCaptureAddress, "opaqueCaptureAddress", 0);
22657
22658      INDENT(-4);
22659      PRINT_SPACE
22660      if (commaNeeded)
22661          _OUT << "}," << std::endl;
22662      else
22663          _OUT << "}" << std::endl;
22664 }
22665
22666 static void print_VkDeviceMemoryOpaqueCaptureAddressInfo(VkDeviceMemoryOpaqueCaptureAddressInfo obj, const std::string& s, bool commaNeeded=true) {
22667      PRINT_SPACE
22668      _OUT << "{" << std::endl;
22669      INDENT(4);
22670
22671      print_VkStructureType(obj.sType, "sType", 1);
22672
22673       if (obj.pNext) {
22674          dumpPNextChain(obj.pNext);
22675       } else {
22676          PRINT_SPACE
22677          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22678      }
22679
22680      // CTS : required value
22681      PRINT_SPACE    _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"" << std::endl;
22682
22683      INDENT(-4);
22684      PRINT_SPACE
22685      if (commaNeeded)
22686          _OUT << "}," << std::endl;
22687      else
22688          _OUT << "}" << std::endl;
22689 }
22690 static void print_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo * obj, const std::string& s, bool commaNeeded=true) {
22691      PRINT_SPACE
22692      _OUT << "{" << std::endl;
22693      INDENT(4);
22694
22695      print_VkStructureType(obj->sType, "sType", 1);
22696
22697       if (obj->pNext) {
22698          dumpPNextChain(obj->pNext);
22699       } else {
22700          PRINT_SPACE
22701          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22702      }
22703
22704      // CTS : required value
22705      PRINT_SPACE    _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"" << std::endl;
22706
22707      INDENT(-4);
22708      PRINT_SPACE
22709      if (commaNeeded)
22710          _OUT << "}," << std::endl;
22711      else
22712          _OUT << "}" << std::endl;
22713 }
22714
22715 static std::map<deUint64, std::string> VkFaultLevel_map = {
22716     std::make_pair(0, "VK_FAULT_LEVEL_UNASSIGNED"),
22717     std::make_pair(1, "VK_FAULT_LEVEL_CRITICAL"),
22718     std::make_pair(2, "VK_FAULT_LEVEL_RECOVERABLE"),
22719     std::make_pair(3, "VK_FAULT_LEVEL_WARNING"),
22720 };
22721 static void print_VkFaultLevel(VkFaultLevel obj, const std::string& str, bool commaNeeded=true) {
22722      PRINT_SPACE
22723      if (str != "") _OUT << "\"" << str << "\"" << " : ";
22724      if (commaNeeded)
22725          _OUT << "\"" <<  VkFaultLevel_map[obj] << "\"," << std::endl;
22726      else
22727          _OUT << "\"" << VkFaultLevel_map[obj] << "\"" << std::endl;
22728 }
22729 static void print_VkFaultLevel(const VkFaultLevel * obj, const std::string& str, bool commaNeeded=true) {
22730      PRINT_SPACE
22731      if (str != "") _OUT << "\"" << str << "\"" << " : ";
22732      if (commaNeeded)
22733          _OUT << "\"" <<  VkFaultLevel_map[*obj] << "\"," << std::endl;
22734      else
22735          _OUT << "\"" << VkFaultLevel_map[*obj] << "\"" << std::endl;
22736 }
22737
22738 static std::map<deUint64, std::string> VkFaultType_map = {
22739     std::make_pair(0, "VK_FAULT_TYPE_INVALID"),
22740     std::make_pair(1, "VK_FAULT_TYPE_UNASSIGNED"),
22741     std::make_pair(2, "VK_FAULT_TYPE_IMPLEMENTATION"),
22742     std::make_pair(3, "VK_FAULT_TYPE_SYSTEM"),
22743     std::make_pair(4, "VK_FAULT_TYPE_PHYSICAL_DEVICE"),
22744     std::make_pair(5, "VK_FAULT_TYPE_COMMAND_BUFFER_FULL"),
22745     std::make_pair(6, "VK_FAULT_TYPE_INVALID_API_USAGE"),
22746 };
22747 static void print_VkFaultType(VkFaultType obj, const std::string& str, bool commaNeeded=true) {
22748      PRINT_SPACE
22749      if (str != "") _OUT << "\"" << str << "\"" << " : ";
22750      if (commaNeeded)
22751          _OUT << "\"" <<  VkFaultType_map[obj] << "\"," << std::endl;
22752      else
22753          _OUT << "\"" << VkFaultType_map[obj] << "\"" << std::endl;
22754 }
22755 static void print_VkFaultType(const VkFaultType * obj, const std::string& str, bool commaNeeded=true) {
22756      PRINT_SPACE
22757      if (str != "") _OUT << "\"" << str << "\"" << " : ";
22758      if (commaNeeded)
22759          _OUT << "\"" <<  VkFaultType_map[*obj] << "\"," << std::endl;
22760      else
22761          _OUT << "\"" << VkFaultType_map[*obj] << "\"" << std::endl;
22762 }
22763
22764 static std::map<deUint64, std::string> VkFaultQueryBehavior_map = {
22765     std::make_pair(0, "VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS"),
22766 };
22767 static void print_VkFaultQueryBehavior(VkFaultQueryBehavior obj, const std::string& str, bool commaNeeded=true) {
22768      PRINT_SPACE
22769      if (str != "") _OUT << "\"" << str << "\"" << " : ";
22770      if (commaNeeded)
22771          _OUT << "\"" <<  VkFaultQueryBehavior_map[obj] << "\"," << std::endl;
22772      else
22773          _OUT << "\"" << VkFaultQueryBehavior_map[obj] << "\"" << std::endl;
22774 }
22775 static void print_VkFaultQueryBehavior(const VkFaultQueryBehavior * obj, const std::string& str, bool commaNeeded=true) {
22776      PRINT_SPACE
22777      if (str != "") _OUT << "\"" << str << "\"" << " : ";
22778      if (commaNeeded)
22779          _OUT << "\"" <<  VkFaultQueryBehavior_map[*obj] << "\"," << std::endl;
22780      else
22781          _OUT << "\"" << VkFaultQueryBehavior_map[*obj] << "\"" << std::endl;
22782 }
22783
22784 static std::map<deUint64, std::string> VkPipelineMatchControl_map = {
22785     std::make_pair(0, "VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH"),
22786 };
22787 static void print_VkPipelineMatchControl(VkPipelineMatchControl obj, const std::string& str, bool commaNeeded=true) {
22788      PRINT_SPACE
22789      if (str != "") _OUT << "\"" << str << "\"" << " : ";
22790      if (commaNeeded)
22791          _OUT << "\"" <<  VkPipelineMatchControl_map[obj] << "\"," << std::endl;
22792      else
22793          _OUT << "\"" << VkPipelineMatchControl_map[obj] << "\"" << std::endl;
22794 }
22795 static void print_VkPipelineMatchControl(const VkPipelineMatchControl * obj, const std::string& str, bool commaNeeded=true) {
22796      PRINT_SPACE
22797      if (str != "") _OUT << "\"" << str << "\"" << " : ";
22798      if (commaNeeded)
22799          _OUT << "\"" <<  VkPipelineMatchControl_map[*obj] << "\"," << std::endl;
22800      else
22801          _OUT << "\"" << VkPipelineMatchControl_map[*obj] << "\"" << std::endl;
22802 }
22803
22804 static std::map<deUint64, std::string> VkPipelineCacheValidationVersion_map = {
22805     std::make_pair(1, "VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE"),
22806 };
22807 static void print_VkPipelineCacheValidationVersion(VkPipelineCacheValidationVersion obj, const std::string& str, bool commaNeeded=true) {
22808      PRINT_SPACE
22809      if (str != "") _OUT << "\"" << str << "\"" << " : ";
22810      if (commaNeeded)
22811          _OUT << "\"" <<  VkPipelineCacheValidationVersion_map[obj] << "\"," << std::endl;
22812      else
22813          _OUT << "\"" << VkPipelineCacheValidationVersion_map[obj] << "\"" << std::endl;
22814 }
22815 static void print_VkPipelineCacheValidationVersion(const VkPipelineCacheValidationVersion * obj, const std::string& str, bool commaNeeded=true) {
22816      PRINT_SPACE
22817      if (str != "") _OUT << "\"" << str << "\"" << " : ";
22818      if (commaNeeded)
22819          _OUT << "\"" <<  VkPipelineCacheValidationVersion_map[*obj] << "\"," << std::endl;
22820      else
22821          _OUT << "\"" << VkPipelineCacheValidationVersion_map[*obj] << "\"" << std::endl;
22822 }
22823
22824 static void print_VkPhysicalDeviceVulkanSC10Features(VkPhysicalDeviceVulkanSC10Features obj, const std::string& s, bool commaNeeded=true) {
22825      PRINT_SPACE
22826      _OUT << "{" << std::endl;
22827      INDENT(4);
22828
22829      print_VkStructureType(obj.sType, "sType", 1);
22830
22831       if (obj.pNext) {
22832          dumpPNextChain(obj.pNext);
22833       } else {
22834          PRINT_SPACE
22835          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22836      }
22837
22838      print_VkBool32(obj.shaderAtomicInstructions, "shaderAtomicInstructions", 0);
22839
22840      INDENT(-4);
22841      PRINT_SPACE
22842      if (commaNeeded)
22843          _OUT << "}," << std::endl;
22844      else
22845          _OUT << "}" << std::endl;
22846 }
22847 static void print_VkPhysicalDeviceVulkanSC10Features(const VkPhysicalDeviceVulkanSC10Features * obj, const std::string& s, bool commaNeeded=true) {
22848      PRINT_SPACE
22849      _OUT << "{" << std::endl;
22850      INDENT(4);
22851
22852      print_VkStructureType(obj->sType, "sType", 1);
22853
22854       if (obj->pNext) {
22855          dumpPNextChain(obj->pNext);
22856       } else {
22857          PRINT_SPACE
22858          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22859      }
22860
22861      print_VkBool32(obj->shaderAtomicInstructions, "shaderAtomicInstructions", 0);
22862
22863      INDENT(-4);
22864      PRINT_SPACE
22865      if (commaNeeded)
22866          _OUT << "}," << std::endl;
22867      else
22868          _OUT << "}" << std::endl;
22869 }
22870
22871 static void print_VkPhysicalDeviceVulkanSC10Properties(VkPhysicalDeviceVulkanSC10Properties obj, const std::string& s, bool commaNeeded=true) {
22872      PRINT_SPACE
22873      _OUT << "{" << std::endl;
22874      INDENT(4);
22875
22876      print_VkStructureType(obj.sType, "sType", 1);
22877
22878       if (obj.pNext) {
22879          dumpPNextChain(obj.pNext);
22880       } else {
22881          PRINT_SPACE
22882          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22883      }
22884
22885      print_VkBool32(obj.deviceNoDynamicHostAllocations, "deviceNoDynamicHostAllocations", 1);
22886
22887      print_VkBool32(obj.deviceDestroyFreesMemory, "deviceDestroyFreesMemory", 1);
22888
22889      print_VkBool32(obj.commandPoolMultipleCommandBuffersRecording, "commandPoolMultipleCommandBuffersRecording", 1);
22890
22891      print_VkBool32(obj.commandPoolResetCommandBuffer, "commandPoolResetCommandBuffer", 1);
22892
22893      print_VkBool32(obj.commandBufferSimultaneousUse, "commandBufferSimultaneousUse", 1);
22894
22895      print_VkBool32(obj.secondaryCommandBufferNullOrImagelessFramebuffer, "secondaryCommandBufferNullOrImagelessFramebuffer", 1);
22896
22897      print_VkBool32(obj.recycleDescriptorSetMemory, "recycleDescriptorSetMemory", 1);
22898
22899      print_VkBool32(obj.recyclePipelineMemory, "recyclePipelineMemory", 1);
22900
22901      print_uint32_t(obj.maxRenderPassSubpasses, "maxRenderPassSubpasses", 1);
22902
22903      print_uint32_t(obj.maxRenderPassDependencies, "maxRenderPassDependencies", 1);
22904
22905      print_uint32_t(obj.maxSubpassInputAttachments, "maxSubpassInputAttachments", 1);
22906
22907      print_uint32_t(obj.maxSubpassPreserveAttachments, "maxSubpassPreserveAttachments", 1);
22908
22909      print_uint32_t(obj.maxFramebufferAttachments, "maxFramebufferAttachments", 1);
22910
22911      print_uint32_t(obj.maxDescriptorSetLayoutBindings, "maxDescriptorSetLayoutBindings", 1);
22912
22913      print_uint32_t(obj.maxQueryFaultCount, "maxQueryFaultCount", 1);
22914
22915      print_uint32_t(obj.maxCallbackFaultCount, "maxCallbackFaultCount", 1);
22916
22917      print_uint32_t(obj.maxCommandPoolCommandBuffers, "maxCommandPoolCommandBuffers", 1);
22918
22919      print_VkDeviceSize(obj.maxCommandBufferSize, "maxCommandBufferSize", 0);
22920
22921      INDENT(-4);
22922      PRINT_SPACE
22923      if (commaNeeded)
22924          _OUT << "}," << std::endl;
22925      else
22926          _OUT << "}" << std::endl;
22927 }
22928 static void print_VkPhysicalDeviceVulkanSC10Properties(const VkPhysicalDeviceVulkanSC10Properties * obj, const std::string& s, bool commaNeeded=true) {
22929      PRINT_SPACE
22930      _OUT << "{" << std::endl;
22931      INDENT(4);
22932
22933      print_VkStructureType(obj->sType, "sType", 1);
22934
22935       if (obj->pNext) {
22936          dumpPNextChain(obj->pNext);
22937       } else {
22938          PRINT_SPACE
22939          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22940      }
22941
22942      print_VkBool32(obj->deviceNoDynamicHostAllocations, "deviceNoDynamicHostAllocations", 1);
22943
22944      print_VkBool32(obj->deviceDestroyFreesMemory, "deviceDestroyFreesMemory", 1);
22945
22946      print_VkBool32(obj->commandPoolMultipleCommandBuffersRecording, "commandPoolMultipleCommandBuffersRecording", 1);
22947
22948      print_VkBool32(obj->commandPoolResetCommandBuffer, "commandPoolResetCommandBuffer", 1);
22949
22950      print_VkBool32(obj->commandBufferSimultaneousUse, "commandBufferSimultaneousUse", 1);
22951
22952      print_VkBool32(obj->secondaryCommandBufferNullOrImagelessFramebuffer, "secondaryCommandBufferNullOrImagelessFramebuffer", 1);
22953
22954      print_VkBool32(obj->recycleDescriptorSetMemory, "recycleDescriptorSetMemory", 1);
22955
22956      print_VkBool32(obj->recyclePipelineMemory, "recyclePipelineMemory", 1);
22957
22958      print_uint32_t(obj->maxRenderPassSubpasses, "maxRenderPassSubpasses", 1);
22959
22960      print_uint32_t(obj->maxRenderPassDependencies, "maxRenderPassDependencies", 1);
22961
22962      print_uint32_t(obj->maxSubpassInputAttachments, "maxSubpassInputAttachments", 1);
22963
22964      print_uint32_t(obj->maxSubpassPreserveAttachments, "maxSubpassPreserveAttachments", 1);
22965
22966      print_uint32_t(obj->maxFramebufferAttachments, "maxFramebufferAttachments", 1);
22967
22968      print_uint32_t(obj->maxDescriptorSetLayoutBindings, "maxDescriptorSetLayoutBindings", 1);
22969
22970      print_uint32_t(obj->maxQueryFaultCount, "maxQueryFaultCount", 1);
22971
22972      print_uint32_t(obj->maxCallbackFaultCount, "maxCallbackFaultCount", 1);
22973
22974      print_uint32_t(obj->maxCommandPoolCommandBuffers, "maxCommandPoolCommandBuffers", 1);
22975
22976      print_VkDeviceSize(obj->maxCommandBufferSize, "maxCommandBufferSize", 0);
22977
22978      INDENT(-4);
22979      PRINT_SPACE
22980      if (commaNeeded)
22981          _OUT << "}," << std::endl;
22982      else
22983          _OUT << "}" << std::endl;
22984 }
22985
22986 static void print_VkPipelinePoolSize(VkPipelinePoolSize obj, const std::string& s, bool commaNeeded=true) {
22987      PRINT_SPACE
22988      _OUT << "{" << std::endl;
22989      INDENT(4);
22990
22991      print_VkStructureType(obj.sType, "sType", 1);
22992
22993       if (obj.pNext) {
22994          dumpPNextChain(obj.pNext);
22995       } else {
22996          PRINT_SPACE
22997          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
22998      }
22999
23000      print_VkDeviceSize(obj.poolEntrySize, "poolEntrySize", 1);
23001
23002      print_uint32_t(obj.poolEntryCount, "poolEntryCount", 0);
23003
23004      INDENT(-4);
23005      PRINT_SPACE
23006      if (commaNeeded)
23007          _OUT << "}," << std::endl;
23008      else
23009          _OUT << "}" << std::endl;
23010 }
23011 static void print_VkPipelinePoolSize(const VkPipelinePoolSize * obj, const std::string& s, bool commaNeeded=true) {
23012      PRINT_SPACE
23013      _OUT << "{" << std::endl;
23014      INDENT(4);
23015
23016      print_VkStructureType(obj->sType, "sType", 1);
23017
23018       if (obj->pNext) {
23019          dumpPNextChain(obj->pNext);
23020       } else {
23021          PRINT_SPACE
23022          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23023      }
23024
23025      print_VkDeviceSize(obj->poolEntrySize, "poolEntrySize", 1);
23026
23027      print_uint32_t(obj->poolEntryCount, "poolEntryCount", 0);
23028
23029      INDENT(-4);
23030      PRINT_SPACE
23031      if (commaNeeded)
23032          _OUT << "}," << std::endl;
23033      else
23034          _OUT << "}" << std::endl;
23035 }
23036
23037 static void print_VkDeviceObjectReservationCreateInfo(VkDeviceObjectReservationCreateInfo obj, const std::string& s, bool commaNeeded=true) {
23038      PRINT_SPACE
23039      _OUT << "{" << std::endl;
23040      INDENT(4);
23041
23042      print_VkStructureType(obj.sType, "sType", 1);
23043
23044       if (obj.pNext) {
23045          dumpPNextChain(obj.pNext);
23046       } else {
23047          PRINT_SPACE
23048          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23049      }
23050
23051      print_uint32_t(obj.pipelineCacheCreateInfoCount, "pipelineCacheCreateInfoCount", 1);
23052
23053      PRINT_SPACE
23054      _OUT << "\"pPipelineCacheCreateInfos\": " << std::endl;
23055      if (obj.pPipelineCacheCreateInfos) {
23056          PRINT_SPACE
23057          _OUT << "[" << std::endl;
23058          for (unsigned int i = 0; i < obj.pipelineCacheCreateInfoCount; i++) {
23059            if (i+1 == obj.pipelineCacheCreateInfoCount)
23060                print_VkPipelineCacheCreateInfo(obj.pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 0);
23061            else
23062                print_VkPipelineCacheCreateInfo(obj.pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 1);
23063          }
23064          PRINT_SPACE
23065          _OUT << "]," << std::endl;
23066     }
23067      else
23068      {
23069          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
23070      }
23071
23072      print_uint32_t(obj.pipelinePoolSizeCount, "pipelinePoolSizeCount", 1);
23073
23074      PRINT_SPACE
23075      _OUT << "\"pPipelinePoolSizes\": " << std::endl;
23076      if (obj.pPipelinePoolSizes) {
23077          PRINT_SPACE
23078          _OUT << "[" << std::endl;
23079          for (unsigned int i = 0; i < obj.pipelinePoolSizeCount; i++) {
23080            if (i+1 == obj.pipelinePoolSizeCount)
23081                print_VkPipelinePoolSize(obj.pPipelinePoolSizes[i], "pPipelinePoolSizes", 0);
23082            else
23083                print_VkPipelinePoolSize(obj.pPipelinePoolSizes[i], "pPipelinePoolSizes", 1);
23084          }
23085          PRINT_SPACE
23086          _OUT << "]," << std::endl;
23087     }
23088      else
23089      {
23090          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
23091      }
23092
23093      print_uint32_t(obj.semaphoreRequestCount, "semaphoreRequestCount", 1);
23094
23095      print_uint32_t(obj.commandBufferRequestCount, "commandBufferRequestCount", 1);
23096
23097      print_uint32_t(obj.fenceRequestCount, "fenceRequestCount", 1);
23098
23099      print_uint32_t(obj.deviceMemoryRequestCount, "deviceMemoryRequestCount", 1);
23100
23101      print_uint32_t(obj.bufferRequestCount, "bufferRequestCount", 1);
23102
23103      print_uint32_t(obj.imageRequestCount, "imageRequestCount", 1);
23104
23105      print_uint32_t(obj.eventRequestCount, "eventRequestCount", 1);
23106
23107      print_uint32_t(obj.queryPoolRequestCount, "queryPoolRequestCount", 1);
23108
23109      print_uint32_t(obj.bufferViewRequestCount, "bufferViewRequestCount", 1);
23110
23111      print_uint32_t(obj.imageViewRequestCount, "imageViewRequestCount", 1);
23112
23113      print_uint32_t(obj.layeredImageViewRequestCount, "layeredImageViewRequestCount", 1);
23114
23115      print_uint32_t(obj.pipelineCacheRequestCount, "pipelineCacheRequestCount", 1);
23116
23117      print_uint32_t(obj.pipelineLayoutRequestCount, "pipelineLayoutRequestCount", 1);
23118
23119      print_uint32_t(obj.renderPassRequestCount, "renderPassRequestCount", 1);
23120
23121      print_uint32_t(obj.graphicsPipelineRequestCount, "graphicsPipelineRequestCount", 1);
23122
23123      print_uint32_t(obj.computePipelineRequestCount, "computePipelineRequestCount", 1);
23124
23125      print_uint32_t(obj.descriptorSetLayoutRequestCount, "descriptorSetLayoutRequestCount", 1);
23126
23127      print_uint32_t(obj.samplerRequestCount, "samplerRequestCount", 1);
23128
23129      print_uint32_t(obj.descriptorPoolRequestCount, "descriptorPoolRequestCount", 1);
23130
23131      print_uint32_t(obj.descriptorSetRequestCount, "descriptorSetRequestCount", 1);
23132
23133      print_uint32_t(obj.framebufferRequestCount, "framebufferRequestCount", 1);
23134
23135      print_uint32_t(obj.commandPoolRequestCount, "commandPoolRequestCount", 1);
23136
23137      print_uint32_t(obj.samplerYcbcrConversionRequestCount, "samplerYcbcrConversionRequestCount", 1);
23138
23139      print_uint32_t(obj.surfaceRequestCount, "surfaceRequestCount", 1);
23140
23141      print_uint32_t(obj.swapchainRequestCount, "swapchainRequestCount", 1);
23142
23143      print_uint32_t(obj.displayModeRequestCount, "displayModeRequestCount", 1);
23144
23145      print_uint32_t(obj.subpassDescriptionRequestCount, "subpassDescriptionRequestCount", 1);
23146
23147      print_uint32_t(obj.attachmentDescriptionRequestCount, "attachmentDescriptionRequestCount", 1);
23148
23149      print_uint32_t(obj.descriptorSetLayoutBindingRequestCount, "descriptorSetLayoutBindingRequestCount", 1);
23150
23151      print_uint32_t(obj.descriptorSetLayoutBindingLimit, "descriptorSetLayoutBindingLimit", 1);
23152
23153      print_uint32_t(obj.maxImageViewMipLevels, "maxImageViewMipLevels", 1);
23154
23155      print_uint32_t(obj.maxImageViewArrayLayers, "maxImageViewArrayLayers", 1);
23156
23157      print_uint32_t(obj.maxLayeredImageViewMipLevels, "maxLayeredImageViewMipLevels", 1);
23158
23159      print_uint32_t(obj.maxOcclusionQueriesPerPool, "maxOcclusionQueriesPerPool", 1);
23160
23161      print_uint32_t(obj.maxPipelineStatisticsQueriesPerPool, "maxPipelineStatisticsQueriesPerPool", 1);
23162
23163      print_uint32_t(obj.maxTimestampQueriesPerPool, "maxTimestampQueriesPerPool", 1);
23164
23165      print_uint32_t(obj.maxImmutableSamplersPerDescriptorSetLayout, "maxImmutableSamplersPerDescriptorSetLayout", 0);
23166
23167      INDENT(-4);
23168      PRINT_SPACE
23169      if (commaNeeded)
23170          _OUT << "}," << std::endl;
23171      else
23172          _OUT << "}" << std::endl;
23173 }
23174 static void print_VkDeviceObjectReservationCreateInfo(const VkDeviceObjectReservationCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
23175      PRINT_SPACE
23176      _OUT << "{" << std::endl;
23177      INDENT(4);
23178
23179      print_VkStructureType(obj->sType, "sType", 1);
23180
23181       if (obj->pNext) {
23182          dumpPNextChain(obj->pNext);
23183       } else {
23184          PRINT_SPACE
23185          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23186      }
23187
23188      print_uint32_t(obj->pipelineCacheCreateInfoCount, "pipelineCacheCreateInfoCount", 1);
23189
23190      PRINT_SPACE
23191      _OUT << "\"pPipelineCacheCreateInfos\": " << std::endl;
23192      if (obj->pPipelineCacheCreateInfos) {
23193          PRINT_SPACE
23194          _OUT << "[" << std::endl;
23195          for (unsigned int i = 0; i < obj->pipelineCacheCreateInfoCount; i++) {
23196            if (i+1 == obj->pipelineCacheCreateInfoCount)
23197                print_VkPipelineCacheCreateInfo(obj->pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 0);
23198            else
23199                print_VkPipelineCacheCreateInfo(obj->pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 1);
23200          }
23201          PRINT_SPACE
23202          _OUT << "]," << std::endl;
23203     }
23204      else
23205      {
23206          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
23207      }
23208
23209      print_uint32_t(obj->pipelinePoolSizeCount, "pipelinePoolSizeCount", 1);
23210
23211      PRINT_SPACE
23212      _OUT << "\"pPipelinePoolSizes\": " << std::endl;
23213      if (obj->pPipelinePoolSizes) {
23214          PRINT_SPACE
23215          _OUT << "[" << std::endl;
23216          for (unsigned int i = 0; i < obj->pipelinePoolSizeCount; i++) {
23217            if (i+1 == obj->pipelinePoolSizeCount)
23218                print_VkPipelinePoolSize(obj->pPipelinePoolSizes[i], "pPipelinePoolSizes", 0);
23219            else
23220                print_VkPipelinePoolSize(obj->pPipelinePoolSizes[i], "pPipelinePoolSizes", 1);
23221          }
23222          PRINT_SPACE
23223          _OUT << "]," << std::endl;
23224     }
23225      else
23226      {
23227          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
23228      }
23229
23230      print_uint32_t(obj->semaphoreRequestCount, "semaphoreRequestCount", 1);
23231
23232      print_uint32_t(obj->commandBufferRequestCount, "commandBufferRequestCount", 1);
23233
23234      print_uint32_t(obj->fenceRequestCount, "fenceRequestCount", 1);
23235
23236      print_uint32_t(obj->deviceMemoryRequestCount, "deviceMemoryRequestCount", 1);
23237
23238      print_uint32_t(obj->bufferRequestCount, "bufferRequestCount", 1);
23239
23240      print_uint32_t(obj->imageRequestCount, "imageRequestCount", 1);
23241
23242      print_uint32_t(obj->eventRequestCount, "eventRequestCount", 1);
23243
23244      print_uint32_t(obj->queryPoolRequestCount, "queryPoolRequestCount", 1);
23245
23246      print_uint32_t(obj->bufferViewRequestCount, "bufferViewRequestCount", 1);
23247
23248      print_uint32_t(obj->imageViewRequestCount, "imageViewRequestCount", 1);
23249
23250      print_uint32_t(obj->layeredImageViewRequestCount, "layeredImageViewRequestCount", 1);
23251
23252      print_uint32_t(obj->pipelineCacheRequestCount, "pipelineCacheRequestCount", 1);
23253
23254      print_uint32_t(obj->pipelineLayoutRequestCount, "pipelineLayoutRequestCount", 1);
23255
23256      print_uint32_t(obj->renderPassRequestCount, "renderPassRequestCount", 1);
23257
23258      print_uint32_t(obj->graphicsPipelineRequestCount, "graphicsPipelineRequestCount", 1);
23259
23260      print_uint32_t(obj->computePipelineRequestCount, "computePipelineRequestCount", 1);
23261
23262      print_uint32_t(obj->descriptorSetLayoutRequestCount, "descriptorSetLayoutRequestCount", 1);
23263
23264      print_uint32_t(obj->samplerRequestCount, "samplerRequestCount", 1);
23265
23266      print_uint32_t(obj->descriptorPoolRequestCount, "descriptorPoolRequestCount", 1);
23267
23268      print_uint32_t(obj->descriptorSetRequestCount, "descriptorSetRequestCount", 1);
23269
23270      print_uint32_t(obj->framebufferRequestCount, "framebufferRequestCount", 1);
23271
23272      print_uint32_t(obj->commandPoolRequestCount, "commandPoolRequestCount", 1);
23273
23274      print_uint32_t(obj->samplerYcbcrConversionRequestCount, "samplerYcbcrConversionRequestCount", 1);
23275
23276      print_uint32_t(obj->surfaceRequestCount, "surfaceRequestCount", 1);
23277
23278      print_uint32_t(obj->swapchainRequestCount, "swapchainRequestCount", 1);
23279
23280      print_uint32_t(obj->displayModeRequestCount, "displayModeRequestCount", 1);
23281
23282      print_uint32_t(obj->subpassDescriptionRequestCount, "subpassDescriptionRequestCount", 1);
23283
23284      print_uint32_t(obj->attachmentDescriptionRequestCount, "attachmentDescriptionRequestCount", 1);
23285
23286      print_uint32_t(obj->descriptorSetLayoutBindingRequestCount, "descriptorSetLayoutBindingRequestCount", 1);
23287
23288      print_uint32_t(obj->descriptorSetLayoutBindingLimit, "descriptorSetLayoutBindingLimit", 1);
23289
23290      print_uint32_t(obj->maxImageViewMipLevels, "maxImageViewMipLevels", 1);
23291
23292      print_uint32_t(obj->maxImageViewArrayLayers, "maxImageViewArrayLayers", 1);
23293
23294      print_uint32_t(obj->maxLayeredImageViewMipLevels, "maxLayeredImageViewMipLevels", 1);
23295
23296      print_uint32_t(obj->maxOcclusionQueriesPerPool, "maxOcclusionQueriesPerPool", 1);
23297
23298      print_uint32_t(obj->maxPipelineStatisticsQueriesPerPool, "maxPipelineStatisticsQueriesPerPool", 1);
23299
23300      print_uint32_t(obj->maxTimestampQueriesPerPool, "maxTimestampQueriesPerPool", 1);
23301
23302      print_uint32_t(obj->maxImmutableSamplersPerDescriptorSetLayout, "maxImmutableSamplersPerDescriptorSetLayout", 0);
23303
23304      INDENT(-4);
23305      PRINT_SPACE
23306      if (commaNeeded)
23307          _OUT << "}," << std::endl;
23308      else
23309          _OUT << "}" << std::endl;
23310 }
23311
23312 static void print_VkCommandPoolMemoryReservationCreateInfo(VkCommandPoolMemoryReservationCreateInfo obj, const std::string& s, bool commaNeeded=true) {
23313      PRINT_SPACE
23314      _OUT << "{" << std::endl;
23315      INDENT(4);
23316
23317      print_VkStructureType(obj.sType, "sType", 1);
23318
23319       if (obj.pNext) {
23320          dumpPNextChain(obj.pNext);
23321       } else {
23322          PRINT_SPACE
23323          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23324      }
23325
23326      print_VkDeviceSize(obj.commandPoolReservedSize, "commandPoolReservedSize", 1);
23327
23328      print_uint32_t(obj.commandPoolMaxCommandBuffers, "commandPoolMaxCommandBuffers", 0);
23329
23330      INDENT(-4);
23331      PRINT_SPACE
23332      if (commaNeeded)
23333          _OUT << "}," << std::endl;
23334      else
23335          _OUT << "}" << std::endl;
23336 }
23337 static void print_VkCommandPoolMemoryReservationCreateInfo(const VkCommandPoolMemoryReservationCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
23338      PRINT_SPACE
23339      _OUT << "{" << std::endl;
23340      INDENT(4);
23341
23342      print_VkStructureType(obj->sType, "sType", 1);
23343
23344       if (obj->pNext) {
23345          dumpPNextChain(obj->pNext);
23346       } else {
23347          PRINT_SPACE
23348          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23349      }
23350
23351      print_VkDeviceSize(obj->commandPoolReservedSize, "commandPoolReservedSize", 1);
23352
23353      print_uint32_t(obj->commandPoolMaxCommandBuffers, "commandPoolMaxCommandBuffers", 0);
23354
23355      INDENT(-4);
23356      PRINT_SPACE
23357      if (commaNeeded)
23358          _OUT << "}," << std::endl;
23359      else
23360          _OUT << "}" << std::endl;
23361 }
23362
23363 static void print_VkCommandPoolMemoryConsumption(VkCommandPoolMemoryConsumption obj, const std::string& s, bool commaNeeded=true) {
23364      PRINT_SPACE
23365      _OUT << "{" << std::endl;
23366      INDENT(4);
23367
23368      print_VkStructureType(obj.sType, "sType", 1);
23369
23370       if (obj.pNext) {
23371          dumpPNextChain(obj.pNext);
23372       } else {
23373          PRINT_SPACE
23374          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23375      }
23376
23377      print_VkDeviceSize(obj.commandPoolAllocated, "commandPoolAllocated", 1);
23378
23379      print_VkDeviceSize(obj.commandPoolReservedSize, "commandPoolReservedSize", 1);
23380
23381      print_VkDeviceSize(obj.commandBufferAllocated, "commandBufferAllocated", 0);
23382
23383      INDENT(-4);
23384      PRINT_SPACE
23385      if (commaNeeded)
23386          _OUT << "}," << std::endl;
23387      else
23388          _OUT << "}" << std::endl;
23389 }
23390 static void print_VkCommandPoolMemoryConsumption(const VkCommandPoolMemoryConsumption * obj, const std::string& s, bool commaNeeded=true) {
23391      PRINT_SPACE
23392      _OUT << "{" << std::endl;
23393      INDENT(4);
23394
23395      print_VkStructureType(obj->sType, "sType", 1);
23396
23397       if (obj->pNext) {
23398          dumpPNextChain(obj->pNext);
23399       } else {
23400          PRINT_SPACE
23401          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23402      }
23403
23404      print_VkDeviceSize(obj->commandPoolAllocated, "commandPoolAllocated", 1);
23405
23406      print_VkDeviceSize(obj->commandPoolReservedSize, "commandPoolReservedSize", 1);
23407
23408      print_VkDeviceSize(obj->commandBufferAllocated, "commandBufferAllocated", 0);
23409
23410      INDENT(-4);
23411      PRINT_SPACE
23412      if (commaNeeded)
23413          _OUT << "}," << std::endl;
23414      else
23415          _OUT << "}" << std::endl;
23416 }
23417
23418 static void print_VkFaultData(VkFaultData obj, const std::string& s, bool commaNeeded=true) {
23419      PRINT_SPACE
23420      _OUT << "{" << std::endl;
23421      INDENT(4);
23422
23423      print_VkStructureType(obj.sType, "sType", 1);
23424
23425       if (obj.pNext) {
23426          dumpPNextChain(obj.pNext);
23427       } else {
23428          PRINT_SPACE
23429          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23430      }
23431
23432      print_VkFaultLevel(obj.faultLevel, "faultLevel", 1);
23433
23434      print_VkFaultType(obj.faultType, "faultType", 0);
23435
23436      INDENT(-4);
23437      PRINT_SPACE
23438      if (commaNeeded)
23439          _OUT << "}," << std::endl;
23440      else
23441          _OUT << "}" << std::endl;
23442 }
23443 static void print_VkFaultData(const VkFaultData * obj, const std::string& s, bool commaNeeded=true) {
23444      PRINT_SPACE
23445      _OUT << "{" << std::endl;
23446      INDENT(4);
23447
23448      print_VkStructureType(obj->sType, "sType", 1);
23449
23450       if (obj->pNext) {
23451          dumpPNextChain(obj->pNext);
23452       } else {
23453          PRINT_SPACE
23454          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23455      }
23456
23457      print_VkFaultLevel(obj->faultLevel, "faultLevel", 1);
23458
23459      print_VkFaultType(obj->faultType, "faultType", 0);
23460
23461      INDENT(-4);
23462      PRINT_SPACE
23463      if (commaNeeded)
23464          _OUT << "}," << std::endl;
23465      else
23466          _OUT << "}" << std::endl;
23467 }
23468
23469 static void print_VkFaultCallbackInfo(VkFaultCallbackInfo obj, const std::string& s, bool commaNeeded=true) {
23470      PRINT_SPACE
23471      _OUT << "{" << std::endl;
23472      INDENT(4);
23473
23474      print_VkStructureType(obj.sType, "sType", 1);
23475
23476       if (obj.pNext) {
23477          dumpPNextChain(obj.pNext);
23478       } else {
23479          PRINT_SPACE
23480          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23481      }
23482
23483      print_uint32_t(obj.faultCount, "faultCount", 1);
23484
23485      PRINT_SPACE
23486      _OUT << "\"pFaults\": " << std::endl;
23487      if (obj.pFaults) {
23488          PRINT_SPACE
23489          _OUT << "[" << std::endl;
23490          for (unsigned int i = 0; i < obj.faultCount; i++) {
23491            if (i+1 == obj.faultCount)
23492                print_VkFaultData(obj.pFaults[i], "pFaults", 0);
23493            else
23494                print_VkFaultData(obj.pFaults[i], "pFaults", 1);
23495          }
23496          PRINT_SPACE
23497          _OUT << "]," << std::endl;
23498     }
23499      else
23500      {
23501          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
23502      }
23503
23504      /** Note: Ignoring function pointer (PFN_vkFaultCallbackFunction). **/
23505
23506      INDENT(-4);
23507      PRINT_SPACE
23508      if (commaNeeded)
23509          _OUT << "}," << std::endl;
23510      else
23511          _OUT << "}" << std::endl;
23512 }
23513 static void print_VkFaultCallbackInfo(const VkFaultCallbackInfo * obj, const std::string& s, bool commaNeeded=true) {
23514      PRINT_SPACE
23515      _OUT << "{" << std::endl;
23516      INDENT(4);
23517
23518      print_VkStructureType(obj->sType, "sType", 1);
23519
23520       if (obj->pNext) {
23521          dumpPNextChain(obj->pNext);
23522       } else {
23523          PRINT_SPACE
23524          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23525      }
23526
23527      print_uint32_t(obj->faultCount, "faultCount", 1);
23528
23529      PRINT_SPACE
23530      _OUT << "\"pFaults\": " << std::endl;
23531      if (obj->pFaults) {
23532          PRINT_SPACE
23533          _OUT << "[" << std::endl;
23534          for (unsigned int i = 0; i < obj->faultCount; i++) {
23535            if (i+1 == obj->faultCount)
23536                print_VkFaultData(obj->pFaults[i], "pFaults", 0);
23537            else
23538                print_VkFaultData(obj->pFaults[i], "pFaults", 1);
23539          }
23540          PRINT_SPACE
23541          _OUT << "]," << std::endl;
23542     }
23543      else
23544      {
23545          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
23546      }
23547
23548      /** Note: Ignoring function pointer (PFN_vkFaultCallbackFunction). **/
23549
23550      INDENT(-4);
23551      PRINT_SPACE
23552      if (commaNeeded)
23553          _OUT << "}," << std::endl;
23554      else
23555          _OUT << "}" << std::endl;
23556 }
23557
23558 static void print_VkPipelineOfflineCreateInfo(VkPipelineOfflineCreateInfo obj, const std::string& s, bool commaNeeded=true) {
23559      PRINT_SPACE
23560      _OUT << "{" << std::endl;
23561      INDENT(4);
23562
23563      print_VkStructureType(obj.sType, "sType", 1);
23564
23565       if (obj.pNext) {
23566          dumpPNextChain(obj.pNext);
23567       } else {
23568          PRINT_SPACE
23569          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23570      }
23571
23572      PRINT_SPACE
23573      _OUT << "\"pipelineIdentifier\":" << std::endl;
23574      PRINT_SPACE
23575      if (obj.pipelineIdentifier) {
23576        _OUT << "[" << std::endl;
23577        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
23578            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
23579            print_uint32_t((deUint32)obj.pipelineIdentifier[i], "", isCommaNeeded);
23580        }
23581        PRINT_SPACE
23582        _OUT << "]" << "," << std::endl;
23583      } else {
23584        _OUT << "\"NULL\"" << "," << std::endl;
23585      }
23586
23587      print_VkPipelineMatchControl(obj.matchControl, "matchControl", 1);
23588
23589      print_VkDeviceSize(obj.poolEntrySize, "poolEntrySize", 0);
23590
23591      INDENT(-4);
23592      PRINT_SPACE
23593      if (commaNeeded)
23594          _OUT << "}," << std::endl;
23595      else
23596          _OUT << "}" << std::endl;
23597 }
23598 static void print_VkPipelineOfflineCreateInfo(const VkPipelineOfflineCreateInfo * obj, const std::string& s, bool commaNeeded=true) {
23599      PRINT_SPACE
23600      _OUT << "{" << std::endl;
23601      INDENT(4);
23602
23603      print_VkStructureType(obj->sType, "sType", 1);
23604
23605       if (obj->pNext) {
23606          dumpPNextChain(obj->pNext);
23607       } else {
23608          PRINT_SPACE
23609          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
23610      }
23611
23612      PRINT_SPACE
23613      _OUT << "\"pipelineIdentifier\":" << std::endl;
23614      PRINT_SPACE
23615      if (obj->pipelineIdentifier) {
23616        _OUT << "[" << std::endl;
23617        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
23618            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
23619            print_uint32_t((deUint32)obj->pipelineIdentifier[i], "", isCommaNeeded);
23620        }
23621        PRINT_SPACE
23622        _OUT << "]" << "," << std::endl;
23623      } else {
23624        _OUT << "\"NULL\"" << "," << std::endl;
23625      }
23626
23627      print_VkPipelineMatchControl(obj->matchControl, "matchControl", 1);
23628
23629      print_VkDeviceSize(obj->poolEntrySize, "poolEntrySize", 0);
23630
23631      INDENT(-4);
23632      PRINT_SPACE
23633      if (commaNeeded)
23634          _OUT << "}," << std::endl;
23635      else
23636          _OUT << "}" << std::endl;
23637 }
23638
23639 static void print_VkPipelineCacheStageValidationIndexEntry(VkPipelineCacheStageValidationIndexEntry obj, const std::string& s, bool commaNeeded=true) {
23640      PRINT_SPACE
23641      _OUT << "{" << std::endl;
23642      INDENT(4);
23643
23644      print_uint64_t(obj.codeSize, "codeSize", 1);
23645
23646      print_uint64_t(obj.codeOffset, "codeOffset", 0);
23647
23648      INDENT(-4);
23649      PRINT_SPACE
23650      if (commaNeeded)
23651          _OUT << "}," << std::endl;
23652      else
23653          _OUT << "}" << std::endl;
23654 }
23655 static void print_VkPipelineCacheStageValidationIndexEntry(const VkPipelineCacheStageValidationIndexEntry * obj, const std::string& s, bool commaNeeded=true) {
23656      PRINT_SPACE
23657      _OUT << "{" << std::endl;
23658      INDENT(4);
23659
23660      print_uint64_t(obj->codeSize, "codeSize", 1);
23661
23662      print_uint64_t(obj->codeOffset, "codeOffset", 0);
23663
23664      INDENT(-4);
23665      PRINT_SPACE
23666      if (commaNeeded)
23667          _OUT << "}," << std::endl;
23668      else
23669          _OUT << "}" << std::endl;
23670 }
23671
23672 static void print_VkPipelineCacheSafetyCriticalIndexEntry(VkPipelineCacheSafetyCriticalIndexEntry obj, const std::string& s, bool commaNeeded=true) {
23673      PRINT_SPACE
23674      _OUT << "{" << std::endl;
23675      INDENT(4);
23676
23677      PRINT_SPACE
23678      _OUT << "\"pipelineIdentifier\":" << std::endl;
23679      PRINT_SPACE
23680      if (obj.pipelineIdentifier) {
23681        _OUT << "[" << std::endl;
23682        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
23683            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
23684            print_uint32_t((deUint32)obj.pipelineIdentifier[i], "", isCommaNeeded);
23685        }
23686        PRINT_SPACE
23687        _OUT << "]" << "," << std::endl;
23688      } else {
23689        _OUT << "\"NULL\"" << "," << std::endl;
23690      }
23691
23692      print_uint64_t(obj.pipelineMemorySize, "pipelineMemorySize", 1);
23693
23694      print_uint64_t(obj.jsonSize, "jsonSize", 1);
23695
23696      print_uint64_t(obj.jsonOffset, "jsonOffset", 1);
23697
23698      print_uint32_t(obj.stageIndexCount, "stageIndexCount", 1);
23699
23700      print_uint32_t(obj.stageIndexStride, "stageIndexStride", 1);
23701
23702      print_uint64_t(obj.stageIndexOffset, "stageIndexOffset", 0);
23703
23704      INDENT(-4);
23705      PRINT_SPACE
23706      if (commaNeeded)
23707          _OUT << "}," << std::endl;
23708      else
23709          _OUT << "}" << std::endl;
23710 }
23711 static void print_VkPipelineCacheSafetyCriticalIndexEntry(const VkPipelineCacheSafetyCriticalIndexEntry * obj, const std::string& s, bool commaNeeded=true) {
23712      PRINT_SPACE
23713      _OUT << "{" << std::endl;
23714      INDENT(4);
23715
23716      PRINT_SPACE
23717      _OUT << "\"pipelineIdentifier\":" << std::endl;
23718      PRINT_SPACE
23719      if (obj->pipelineIdentifier) {
23720        _OUT << "[" << std::endl;
23721        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
23722            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
23723            print_uint32_t((deUint32)obj->pipelineIdentifier[i], "", isCommaNeeded);
23724        }
23725        PRINT_SPACE
23726        _OUT << "]" << "," << std::endl;
23727      } else {
23728        _OUT << "\"NULL\"" << "," << std::endl;
23729      }
23730
23731      print_uint64_t(obj->pipelineMemorySize, "pipelineMemorySize", 1);
23732
23733      print_uint64_t(obj->jsonSize, "jsonSize", 1);
23734
23735      print_uint64_t(obj->jsonOffset, "jsonOffset", 1);
23736
23737      print_uint32_t(obj->stageIndexCount, "stageIndexCount", 1);
23738
23739      print_uint32_t(obj->stageIndexStride, "stageIndexStride", 1);
23740
23741      print_uint64_t(obj->stageIndexOffset, "stageIndexOffset", 0);
23742
23743      INDENT(-4);
23744      PRINT_SPACE
23745      if (commaNeeded)
23746          _OUT << "}," << std::endl;
23747      else
23748          _OUT << "}" << std::endl;
23749 }
23750
23751 static void print_VkPipelineCacheHeaderVersionSafetyCriticalOne(VkPipelineCacheHeaderVersionSafetyCriticalOne obj, const std::string& s, bool commaNeeded=true) {
23752      PRINT_SPACE
23753      _OUT << "{" << std::endl;
23754      INDENT(4);
23755
23756      PRINT_SPACE
23757      _OUT << "\"headerVersionOne\": " << std::endl;
23758      {
23759            print_VkPipelineCacheHeaderVersionOne(obj.headerVersionOne, "headerVersionOne", 1);
23760      }
23761
23762      print_VkPipelineCacheValidationVersion(obj.validationVersion, "validationVersion", 1);
23763
23764      print_uint32_t(obj.implementationData, "implementationData", 1);
23765
23766      print_uint32_t(obj.pipelineIndexCount, "pipelineIndexCount", 1);
23767
23768      print_uint32_t(obj.pipelineIndexStride, "pipelineIndexStride", 1);
23769
23770      print_uint64_t(obj.pipelineIndexOffset, "pipelineIndexOffset", 0);
23771
23772      INDENT(-4);
23773      PRINT_SPACE
23774      if (commaNeeded)
23775          _OUT << "}," << std::endl;
23776      else
23777          _OUT << "}" << std::endl;
23778 }
23779 static void print_VkPipelineCacheHeaderVersionSafetyCriticalOne(const VkPipelineCacheHeaderVersionSafetyCriticalOne * obj, const std::string& s, bool commaNeeded=true) {
23780      PRINT_SPACE
23781      _OUT << "{" << std::endl;
23782      INDENT(4);
23783
23784      PRINT_SPACE
23785      _OUT << "\"headerVersionOne\": " << std::endl;
23786      {
23787            print_VkPipelineCacheHeaderVersionOne(obj->headerVersionOne, "headerVersionOne", 1);
23788      }
23789
23790      print_VkPipelineCacheValidationVersion(obj->validationVersion, "validationVersion", 1);
23791
23792      print_uint32_t(obj->implementationData, "implementationData", 1);
23793
23794      print_uint32_t(obj->pipelineIndexCount, "pipelineIndexCount", 1);
23795
23796      print_uint32_t(obj->pipelineIndexStride, "pipelineIndexStride", 1);
23797
23798      print_uint64_t(obj->pipelineIndexOffset, "pipelineIndexOffset", 0);
23799
23800      INDENT(-4);
23801      PRINT_SPACE
23802      if (commaNeeded)
23803          _OUT << "}," << std::endl;
23804      else
23805          _OUT << "}" << std::endl;
23806 }
23807
23808 static void print_VkSurfaceKHR(VkSurfaceKHR obj, const std::string& str, bool commaNeeded=true) {
23809      PRINT_SPACE
23810      if (commaNeeded)
23811          _OUT << "\"" << str << "\"" << "," << std::endl;
23812      else
23813          _OUT << "\"" << str << "\"" << std::endl;
23814 }
23815 static void print_VkSurfaceKHR(const VkSurfaceKHR * obj, const std::string& str, bool commaNeeded=true) {
23816      PRINT_SPACE
23817      if (commaNeeded)
23818          _OUT << "\"" << str << "\"" << "," << std::endl;
23819      else
23820          _OUT << "\"" << str << "\"" << std::endl;
23821 }
23822
23823 static std::map<deUint64, std::string> VkSurfaceTransformFlagBitsKHR_map = {
23824     std::make_pair(1ULL << 0, "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR"),
23825     std::make_pair(1ULL << 1, "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR"),
23826     std::make_pair(1ULL << 2, "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR"),
23827     std::make_pair(1ULL << 3, "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR"),
23828     std::make_pair(1ULL << 4, "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR"),
23829     std::make_pair(1ULL << 5, "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR"),
23830     std::make_pair(1ULL << 6, "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR"),
23831     std::make_pair(1ULL << 7, "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR"),
23832     std::make_pair(1ULL << 8, "VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR"),
23833 };
23834 static void print_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) {
23835      PRINT_SPACE
23836      if (str != "") _OUT << "\"" << str << "\"" << " : ";
23837      if (commaNeeded)
23838          _OUT << "\"" <<  VkSurfaceTransformFlagBitsKHR_map[obj] << "\"," << std::endl;
23839      else
23840          _OUT << "\"" << VkSurfaceTransformFlagBitsKHR_map[obj] << "\"" << std::endl;
23841 }
23842 static void print_VkSurfaceTransformFlagBitsKHR(const VkSurfaceTransformFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) {
23843      PRINT_SPACE
23844      if (str != "") _OUT << "\"" << str << "\"" << " : ";
23845      if (commaNeeded)
23846          _OUT << "\"" <<  VkSurfaceTransformFlagBitsKHR_map[*obj] << "\"," << std::endl;
23847      else
23848          _OUT << "\"" << VkSurfaceTransformFlagBitsKHR_map[*obj] << "\"" << std::endl;
23849 }
23850
23851 static std::map<deUint64, std::string> VkPresentModeKHR_map = {
23852     std::make_pair(0, "VK_PRESENT_MODE_IMMEDIATE_KHR"),
23853     std::make_pair(1, "VK_PRESENT_MODE_MAILBOX_KHR"),
23854     std::make_pair(2, "VK_PRESENT_MODE_FIFO_KHR"),
23855     std::make_pair(3, "VK_PRESENT_MODE_FIFO_RELAXED_KHR"),
23856     std::make_pair(1000111000, "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR"),
23857     std::make_pair(1000111001, "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR"),
23858 };
23859 static void print_VkPresentModeKHR(VkPresentModeKHR obj, const std::string& str, bool commaNeeded=true) {
23860      PRINT_SPACE
23861      if (str != "") _OUT << "\"" << str << "\"" << " : ";
23862      if (commaNeeded)
23863          _OUT << "\"" <<  VkPresentModeKHR_map[obj] << "\"," << std::endl;
23864      else
23865          _OUT << "\"" << VkPresentModeKHR_map[obj] << "\"" << std::endl;
23866 }
23867 static void print_VkPresentModeKHR(const VkPresentModeKHR * obj, const std::string& str, bool commaNeeded=true) {
23868      PRINT_SPACE
23869      if (str != "") _OUT << "\"" << str << "\"" << " : ";
23870      if (commaNeeded)
23871          _OUT << "\"" <<  VkPresentModeKHR_map[*obj] << "\"," << std::endl;
23872      else
23873          _OUT << "\"" << VkPresentModeKHR_map[*obj] << "\"" << std::endl;
23874 }
23875
23876 static std::map<deUint64, std::string> VkColorSpaceKHR_map = {
23877     std::make_pair(0, "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR"),
23878     std::make_pair(1000104001, "VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT"),
23879     std::make_pair(1000104002, "VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT"),
23880     std::make_pair(1000104003, "VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT"),
23881     std::make_pair(1000104004, "VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT"),
23882     std::make_pair(1000104005, "VK_COLOR_SPACE_BT709_LINEAR_EXT"),
23883     std::make_pair(1000104006, "VK_COLOR_SPACE_BT709_NONLINEAR_EXT"),
23884     std::make_pair(1000104007, "VK_COLOR_SPACE_BT2020_LINEAR_EXT"),
23885     std::make_pair(1000104008, "VK_COLOR_SPACE_HDR10_ST2084_EXT"),
23886     std::make_pair(1000104009, "VK_COLOR_SPACE_DOLBYVISION_EXT"),
23887     std::make_pair(1000104010, "VK_COLOR_SPACE_HDR10_HLG_EXT"),
23888     std::make_pair(1000104011, "VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT"),
23889     std::make_pair(1000104012, "VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT"),
23890     std::make_pair(1000104013, "VK_COLOR_SPACE_PASS_THROUGH_EXT"),
23891     std::make_pair(1000104014, "VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT"),
23892     std::make_pair(1000213000, "VK_COLOR_SPACE_DISPLAY_NATIVE_AMD"),
23893 };
23894 static void print_VkColorSpaceKHR(VkColorSpaceKHR obj, const std::string& str, bool commaNeeded=true) {
23895      PRINT_SPACE
23896      if (str != "") _OUT << "\"" << str << "\"" << " : ";
23897      if (commaNeeded)
23898          _OUT << "\"" <<  VkColorSpaceKHR_map[obj] << "\"," << std::endl;
23899      else
23900          _OUT << "\"" << VkColorSpaceKHR_map[obj] << "\"" << std::endl;
23901 }
23902 static void print_VkColorSpaceKHR(const VkColorSpaceKHR * obj, const std::string& str, bool commaNeeded=true) {
23903      PRINT_SPACE
23904      if (str != "") _OUT << "\"" << str << "\"" << " : ";
23905      if (commaNeeded)
23906          _OUT << "\"" <<  VkColorSpaceKHR_map[*obj] << "\"," << std::endl;
23907      else
23908          _OUT << "\"" << VkColorSpaceKHR_map[*obj] << "\"" << std::endl;
23909 }
23910
23911 static std::map<deUint64, std::string> VkCompositeAlphaFlagBitsKHR_map = {
23912     std::make_pair(1ULL << 0, "VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR"),
23913     std::make_pair(1ULL << 1, "VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR"),
23914     std::make_pair(1ULL << 2, "VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR"),
23915     std::make_pair(1ULL << 3, "VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR"),
23916 };
23917 static void print_VkCompositeAlphaFlagBitsKHR(VkCompositeAlphaFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) {
23918      PRINT_SPACE
23919      if (str != "") _OUT << "\"" << str << "\"" << " : ";
23920      if (commaNeeded)
23921          _OUT << "\"" <<  VkCompositeAlphaFlagBitsKHR_map[obj] << "\"," << std::endl;
23922      else
23923          _OUT << "\"" << VkCompositeAlphaFlagBitsKHR_map[obj] << "\"" << std::endl;
23924 }
23925 static void print_VkCompositeAlphaFlagBitsKHR(const VkCompositeAlphaFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) {
23926      PRINT_SPACE
23927      if (str != "") _OUT << "\"" << str << "\"" << " : ";
23928      if (commaNeeded)
23929          _OUT << "\"" <<  VkCompositeAlphaFlagBitsKHR_map[*obj] << "\"," << std::endl;
23930      else
23931          _OUT << "\"" << VkCompositeAlphaFlagBitsKHR_map[*obj] << "\"" << std::endl;
23932 }
23933
23934 static void print_VkCompositeAlphaFlagsKHR(VkCompositeAlphaFlagsKHR obj, const std::string& str, bool commaNeeded=true) {
23935      PRINT_SPACE
23936      if (str != "") _OUT << "\"" << str << "\"" << " : ";
23937      const int max_bits = 64; // We don't expect the number to be larger.
23938      std::bitset<max_bits> b(obj);
23939      _OUT << "\"";
23940      if (obj == 0) _OUT << "0";
23941      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
23942          if (b[i] == 1) {
23943              bitCount++;
23944              if (bitCount < b.count())
23945                  _OUT << VkCompositeAlphaFlagBitsKHR_map[1ULL<<i] << " | ";
23946              else
23947                  _OUT << VkCompositeAlphaFlagBitsKHR_map[1ULL<<i];
23948          }
23949      }
23950      if (commaNeeded)
23951        _OUT << "\"" << ",";
23952      else
23953        _OUT << "\""<< "";
23954      _OUT << std::endl;
23955 }
23956 static void print_VkCompositeAlphaFlagsKHR(const VkCompositeAlphaFlagsKHR * obj, const std::string& str, bool commaNeeded=true) {
23957      PRINT_SPACE
23958      if (str != "") _OUT << "\"" << str << "\"" << " : ";
23959      const int max_bits = 64; // We don't expect the number to be larger.
23960      std::bitset<max_bits> b(obj);
23961      _OUT << "\"";
23962      if (obj == 0) _OUT << "0";
23963      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
23964          if (b[i] == 1) {
23965              bitCount++;
23966              if (bitCount < b.count())
23967                  _OUT << VkCompositeAlphaFlagBitsKHR_map[1ULL<<i] << " | ";
23968              else
23969                  _OUT << VkCompositeAlphaFlagBitsKHR_map[1ULL<<i];
23970          }
23971      }
23972      if (commaNeeded)
23973        _OUT << "\"" << ",";
23974      else
23975        _OUT << "\""<< "";
23976      _OUT << std::endl;
23977 }
23978
23979 static void print_VkSurfaceTransformFlagsKHR(VkSurfaceTransformFlagsKHR obj, const std::string& str, bool commaNeeded=true) {
23980      PRINT_SPACE
23981      if (str != "") _OUT << "\"" << str << "\"" << " : ";
23982      const int max_bits = 64; // We don't expect the number to be larger.
23983      std::bitset<max_bits> b(obj);
23984      _OUT << "\"";
23985      if (obj == 0) _OUT << "0";
23986      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
23987          if (b[i] == 1) {
23988              bitCount++;
23989              if (bitCount < b.count())
23990                  _OUT << VkSurfaceTransformFlagBitsKHR_map[1ULL<<i] << " | ";
23991              else
23992                  _OUT << VkSurfaceTransformFlagBitsKHR_map[1ULL<<i];
23993          }
23994      }
23995      if (commaNeeded)
23996        _OUT << "\"" << ",";
23997      else
23998        _OUT << "\""<< "";
23999      _OUT << std::endl;
24000 }
24001 static void print_VkSurfaceTransformFlagsKHR(const VkSurfaceTransformFlagsKHR * obj, const std::string& str, bool commaNeeded=true) {
24002      PRINT_SPACE
24003      if (str != "") _OUT << "\"" << str << "\"" << " : ";
24004      const int max_bits = 64; // We don't expect the number to be larger.
24005      std::bitset<max_bits> b(obj);
24006      _OUT << "\"";
24007      if (obj == 0) _OUT << "0";
24008      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
24009          if (b[i] == 1) {
24010              bitCount++;
24011              if (bitCount < b.count())
24012                  _OUT << VkSurfaceTransformFlagBitsKHR_map[1ULL<<i] << " | ";
24013              else
24014                  _OUT << VkSurfaceTransformFlagBitsKHR_map[1ULL<<i];
24015          }
24016      }
24017      if (commaNeeded)
24018        _OUT << "\"" << ",";
24019      else
24020        _OUT << "\""<< "";
24021      _OUT << std::endl;
24022 }
24023
24024 static void print_VkSurfaceCapabilitiesKHR(VkSurfaceCapabilitiesKHR obj, const std::string& s, bool commaNeeded=true) {
24025      PRINT_SPACE
24026      _OUT << "{" << std::endl;
24027      INDENT(4);
24028
24029      print_uint32_t(obj.minImageCount, "minImageCount", 1);
24030
24031      print_uint32_t(obj.maxImageCount, "maxImageCount", 1);
24032
24033      PRINT_SPACE
24034      _OUT << "\"currentExtent\": " << std::endl;
24035      {
24036            print_VkExtent2D(obj.currentExtent, "currentExtent", 1);
24037      }
24038
24039      PRINT_SPACE
24040      _OUT << "\"minImageExtent\": " << std::endl;
24041      {
24042            print_VkExtent2D(obj.minImageExtent, "minImageExtent", 1);
24043      }
24044
24045      PRINT_SPACE
24046      _OUT << "\"maxImageExtent\": " << std::endl;
24047      {
24048            print_VkExtent2D(obj.maxImageExtent, "maxImageExtent", 1);
24049      }
24050
24051      print_uint32_t(obj.maxImageArrayLayers, "maxImageArrayLayers", 1);
24052
24053      print_VkSurfaceTransformFlagsKHR(obj.supportedTransforms, "supportedTransforms", 1);
24054
24055      print_VkSurfaceTransformFlagBitsKHR(obj.currentTransform, "currentTransform", 1);
24056
24057      print_VkCompositeAlphaFlagsKHR(obj.supportedCompositeAlpha, "supportedCompositeAlpha", 1);
24058
24059      print_VkImageUsageFlags(obj.supportedUsageFlags, "supportedUsageFlags", 0);
24060
24061      INDENT(-4);
24062      PRINT_SPACE
24063      if (commaNeeded)
24064          _OUT << "}," << std::endl;
24065      else
24066          _OUT << "}" << std::endl;
24067 }
24068 static void print_VkSurfaceCapabilitiesKHR(const VkSurfaceCapabilitiesKHR * obj, const std::string& s, bool commaNeeded=true) {
24069      PRINT_SPACE
24070      _OUT << "{" << std::endl;
24071      INDENT(4);
24072
24073      print_uint32_t(obj->minImageCount, "minImageCount", 1);
24074
24075      print_uint32_t(obj->maxImageCount, "maxImageCount", 1);
24076
24077      PRINT_SPACE
24078      _OUT << "\"currentExtent\": " << std::endl;
24079      {
24080            print_VkExtent2D(obj->currentExtent, "currentExtent", 1);
24081      }
24082
24083      PRINT_SPACE
24084      _OUT << "\"minImageExtent\": " << std::endl;
24085      {
24086            print_VkExtent2D(obj->minImageExtent, "minImageExtent", 1);
24087      }
24088
24089      PRINT_SPACE
24090      _OUT << "\"maxImageExtent\": " << std::endl;
24091      {
24092            print_VkExtent2D(obj->maxImageExtent, "maxImageExtent", 1);
24093      }
24094
24095      print_uint32_t(obj->maxImageArrayLayers, "maxImageArrayLayers", 1);
24096
24097      print_VkSurfaceTransformFlagsKHR(obj->supportedTransforms, "supportedTransforms", 1);
24098
24099      print_VkSurfaceTransformFlagBitsKHR(obj->currentTransform, "currentTransform", 1);
24100
24101      print_VkCompositeAlphaFlagsKHR(obj->supportedCompositeAlpha, "supportedCompositeAlpha", 1);
24102
24103      print_VkImageUsageFlags(obj->supportedUsageFlags, "supportedUsageFlags", 0);
24104
24105      INDENT(-4);
24106      PRINT_SPACE
24107      if (commaNeeded)
24108          _OUT << "}," << std::endl;
24109      else
24110          _OUT << "}" << std::endl;
24111 }
24112
24113 static void print_VkSurfaceFormatKHR(VkSurfaceFormatKHR obj, const std::string& s, bool commaNeeded=true) {
24114      PRINT_SPACE
24115      _OUT << "{" << std::endl;
24116      INDENT(4);
24117
24118      print_VkFormat(obj.format, "format", 1);
24119
24120      print_VkColorSpaceKHR(obj.colorSpace, "colorSpace", 0);
24121
24122      INDENT(-4);
24123      PRINT_SPACE
24124      if (commaNeeded)
24125          _OUT << "}," << std::endl;
24126      else
24127          _OUT << "}" << std::endl;
24128 }
24129 static void print_VkSurfaceFormatKHR(const VkSurfaceFormatKHR * obj, const std::string& s, bool commaNeeded=true) {
24130      PRINT_SPACE
24131      _OUT << "{" << std::endl;
24132      INDENT(4);
24133
24134      print_VkFormat(obj->format, "format", 1);
24135
24136      print_VkColorSpaceKHR(obj->colorSpace, "colorSpace", 0);
24137
24138      INDENT(-4);
24139      PRINT_SPACE
24140      if (commaNeeded)
24141          _OUT << "}," << std::endl;
24142      else
24143          _OUT << "}" << std::endl;
24144 }
24145
24146 static void print_VkSwapchainKHR(VkSwapchainKHR obj, const std::string& str, bool commaNeeded=true) {
24147      PRINT_SPACE
24148      if (commaNeeded)
24149          _OUT << "\"" << str << "\"" << "," << std::endl;
24150      else
24151          _OUT << "\"" << str << "\"" << std::endl;
24152 }
24153 static void print_VkSwapchainKHR(const VkSwapchainKHR * obj, const std::string& str, bool commaNeeded=true) {
24154      PRINT_SPACE
24155      if (commaNeeded)
24156          _OUT << "\"" << str << "\"" << "," << std::endl;
24157      else
24158          _OUT << "\"" << str << "\"" << std::endl;
24159 }
24160
24161 static std::map<deUint64, std::string> VkSwapchainCreateFlagBitsKHR_map = {
24162     std::make_pair(1ULL << 0, "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR"),
24163     std::make_pair(1ULL << 1, "VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR"),
24164     std::make_pair(1ULL << 0, "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR"),
24165     std::make_pair(1ULL << 2, "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR"),
24166 };
24167 static void print_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) {
24168      PRINT_SPACE
24169      if (str != "") _OUT << "\"" << str << "\"" << " : ";
24170      if (commaNeeded)
24171          _OUT << "\"" <<  VkSwapchainCreateFlagBitsKHR_map[obj] << "\"," << std::endl;
24172      else
24173          _OUT << "\"" << VkSwapchainCreateFlagBitsKHR_map[obj] << "\"" << std::endl;
24174 }
24175 static void print_VkSwapchainCreateFlagBitsKHR(const VkSwapchainCreateFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) {
24176      PRINT_SPACE
24177      if (str != "") _OUT << "\"" << str << "\"" << " : ";
24178      if (commaNeeded)
24179          _OUT << "\"" <<  VkSwapchainCreateFlagBitsKHR_map[*obj] << "\"," << std::endl;
24180      else
24181          _OUT << "\"" << VkSwapchainCreateFlagBitsKHR_map[*obj] << "\"" << std::endl;
24182 }
24183
24184 static std::map<deUint64, std::string> VkDeviceGroupPresentModeFlagBitsKHR_map = {
24185     std::make_pair(1ULL << 0, "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR"),
24186     std::make_pair(1ULL << 1, "VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR"),
24187     std::make_pair(1ULL << 2, "VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR"),
24188     std::make_pair(1ULL << 3, "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR"),
24189 };
24190 static void print_VkDeviceGroupPresentModeFlagBitsKHR(VkDeviceGroupPresentModeFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) {
24191      PRINT_SPACE
24192      if (str != "") _OUT << "\"" << str << "\"" << " : ";
24193      if (commaNeeded)
24194          _OUT << "\"" <<  VkDeviceGroupPresentModeFlagBitsKHR_map[obj] << "\"," << std::endl;
24195      else
24196          _OUT << "\"" << VkDeviceGroupPresentModeFlagBitsKHR_map[obj] << "\"" << std::endl;
24197 }
24198 static void print_VkDeviceGroupPresentModeFlagBitsKHR(const VkDeviceGroupPresentModeFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) {
24199      PRINT_SPACE
24200      if (str != "") _OUT << "\"" << str << "\"" << " : ";
24201      if (commaNeeded)
24202          _OUT << "\"" <<  VkDeviceGroupPresentModeFlagBitsKHR_map[*obj] << "\"," << std::endl;
24203      else
24204          _OUT << "\"" << VkDeviceGroupPresentModeFlagBitsKHR_map[*obj] << "\"" << std::endl;
24205 }
24206
24207 static void print_VkSwapchainCreateFlagsKHR(VkSwapchainCreateFlagsKHR obj, const std::string& str, bool commaNeeded=true) {
24208      PRINT_SPACE
24209      if (str != "") _OUT << "\"" << str << "\"" << " : ";
24210      const int max_bits = 64; // We don't expect the number to be larger.
24211      std::bitset<max_bits> b(obj);
24212      _OUT << "\"";
24213      if (obj == 0) _OUT << "0";
24214      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
24215          if (b[i] == 1) {
24216              bitCount++;
24217              if (bitCount < b.count())
24218                  _OUT << VkSwapchainCreateFlagBitsKHR_map[1ULL<<i] << " | ";
24219              else
24220                  _OUT << VkSwapchainCreateFlagBitsKHR_map[1ULL<<i];
24221          }
24222      }
24223      if (commaNeeded)
24224        _OUT << "\"" << ",";
24225      else
24226        _OUT << "\""<< "";
24227      _OUT << std::endl;
24228 }
24229 static void print_VkSwapchainCreateFlagsKHR(const VkSwapchainCreateFlagsKHR * obj, const std::string& str, bool commaNeeded=true) {
24230      PRINT_SPACE
24231      if (str != "") _OUT << "\"" << str << "\"" << " : ";
24232      const int max_bits = 64; // We don't expect the number to be larger.
24233      std::bitset<max_bits> b(obj);
24234      _OUT << "\"";
24235      if (obj == 0) _OUT << "0";
24236      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
24237          if (b[i] == 1) {
24238              bitCount++;
24239              if (bitCount < b.count())
24240                  _OUT << VkSwapchainCreateFlagBitsKHR_map[1ULL<<i] << " | ";
24241              else
24242                  _OUT << VkSwapchainCreateFlagBitsKHR_map[1ULL<<i];
24243          }
24244      }
24245      if (commaNeeded)
24246        _OUT << "\"" << ",";
24247      else
24248        _OUT << "\""<< "";
24249      _OUT << std::endl;
24250 }
24251
24252 static void print_VkDeviceGroupPresentModeFlagsKHR(VkDeviceGroupPresentModeFlagsKHR obj, const std::string& str, bool commaNeeded=true) {
24253      PRINT_SPACE
24254      if (str != "") _OUT << "\"" << str << "\"" << " : ";
24255      const int max_bits = 64; // We don't expect the number to be larger.
24256      std::bitset<max_bits> b(obj);
24257      _OUT << "\"";
24258      if (obj == 0) _OUT << "0";
24259      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
24260          if (b[i] == 1) {
24261              bitCount++;
24262              if (bitCount < b.count())
24263                  _OUT << VkDeviceGroupPresentModeFlagBitsKHR_map[1ULL<<i] << " | ";
24264              else
24265                  _OUT << VkDeviceGroupPresentModeFlagBitsKHR_map[1ULL<<i];
24266          }
24267      }
24268      if (commaNeeded)
24269        _OUT << "\"" << ",";
24270      else
24271        _OUT << "\""<< "";
24272      _OUT << std::endl;
24273 }
24274 static void print_VkDeviceGroupPresentModeFlagsKHR(const VkDeviceGroupPresentModeFlagsKHR * obj, const std::string& str, bool commaNeeded=true) {
24275      PRINT_SPACE
24276      if (str != "") _OUT << "\"" << str << "\"" << " : ";
24277      const int max_bits = 64; // We don't expect the number to be larger.
24278      std::bitset<max_bits> b(obj);
24279      _OUT << "\"";
24280      if (obj == 0) _OUT << "0";
24281      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
24282          if (b[i] == 1) {
24283              bitCount++;
24284              if (bitCount < b.count())
24285                  _OUT << VkDeviceGroupPresentModeFlagBitsKHR_map[1ULL<<i] << " | ";
24286              else
24287                  _OUT << VkDeviceGroupPresentModeFlagBitsKHR_map[1ULL<<i];
24288          }
24289      }
24290      if (commaNeeded)
24291        _OUT << "\"" << ",";
24292      else
24293        _OUT << "\""<< "";
24294      _OUT << std::endl;
24295 }
24296
24297 static void print_VkSwapchainCreateInfoKHR(VkSwapchainCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) {
24298      PRINT_SPACE
24299      _OUT << "{" << std::endl;
24300      INDENT(4);
24301
24302      print_VkStructureType(obj.sType, "sType", 1);
24303
24304       if (obj.pNext) {
24305          dumpPNextChain(obj.pNext);
24306       } else {
24307          PRINT_SPACE
24308          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24309      }
24310
24311      print_VkSwapchainCreateFlagsKHR(obj.flags, "flags", 1);
24312
24313      // CTS : required value
24314      PRINT_SPACE    _OUT << "\"" << "surface" << "\"" << " : " << "\"" << "\"," << std::endl;
24315
24316      print_uint32_t(obj.minImageCount, "minImageCount", 1);
24317
24318      print_VkFormat(obj.imageFormat, "imageFormat", 1);
24319
24320      print_VkColorSpaceKHR(obj.imageColorSpace, "imageColorSpace", 1);
24321
24322      PRINT_SPACE
24323      _OUT << "\"imageExtent\": " << std::endl;
24324      {
24325            print_VkExtent2D(obj.imageExtent, "imageExtent", 1);
24326      }
24327
24328      print_uint32_t(obj.imageArrayLayers, "imageArrayLayers", 1);
24329
24330      print_VkImageUsageFlags(obj.imageUsage, "imageUsage", 1);
24331
24332      print_VkSharingMode(obj.imageSharingMode, "imageSharingMode", 1);
24333
24334      print_uint32_t(obj.queueFamilyIndexCount, "queueFamilyIndexCount", 1);
24335
24336      PRINT_SPACE
24337      _OUT << "\"pQueueFamilyIndices\":" << std::endl;
24338      PRINT_SPACE
24339      if (obj.pQueueFamilyIndices) {
24340        _OUT << "[" << std::endl;
24341        for (unsigned int i = 0; i < obj.queueFamilyIndexCount; i++) {
24342            bool isCommaNeeded = (i+1) != obj.queueFamilyIndexCount;
24343            print_uint32_t(obj.pQueueFamilyIndices[i], "", isCommaNeeded);
24344        }
24345        PRINT_SPACE
24346        _OUT << "]" << "," << std::endl;
24347      } else {
24348        _OUT << "\"NULL\"" << "," << std::endl;
24349      }
24350
24351      print_VkSurfaceTransformFlagBitsKHR(obj.preTransform, "preTransform", 1);
24352
24353      print_VkCompositeAlphaFlagBitsKHR(obj.compositeAlpha, "compositeAlpha", 1);
24354
24355      print_VkPresentModeKHR(obj.presentMode, "presentMode", 1);
24356
24357      print_VkBool32(obj.clipped, "clipped", 1);
24358
24359      // CTS : required value
24360      PRINT_SPACE    _OUT << "\"" << "oldSwapchain" << "\"" << " : " << "\"" << "\"" << std::endl;
24361
24362      INDENT(-4);
24363      PRINT_SPACE
24364      if (commaNeeded)
24365          _OUT << "}," << std::endl;
24366      else
24367          _OUT << "}" << std::endl;
24368 }
24369 static void print_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
24370      PRINT_SPACE
24371      _OUT << "{" << std::endl;
24372      INDENT(4);
24373
24374      print_VkStructureType(obj->sType, "sType", 1);
24375
24376       if (obj->pNext) {
24377          dumpPNextChain(obj->pNext);
24378       } else {
24379          PRINT_SPACE
24380          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24381      }
24382
24383      print_VkSwapchainCreateFlagsKHR(obj->flags, "flags", 1);
24384
24385      // CTS : required value
24386      PRINT_SPACE    _OUT << "\"" << "surface" << "\"" << " : " << "\"" << "\"," << std::endl;
24387
24388      print_uint32_t(obj->minImageCount, "minImageCount", 1);
24389
24390      print_VkFormat(obj->imageFormat, "imageFormat", 1);
24391
24392      print_VkColorSpaceKHR(obj->imageColorSpace, "imageColorSpace", 1);
24393
24394      PRINT_SPACE
24395      _OUT << "\"imageExtent\": " << std::endl;
24396      {
24397            print_VkExtent2D(obj->imageExtent, "imageExtent", 1);
24398      }
24399
24400      print_uint32_t(obj->imageArrayLayers, "imageArrayLayers", 1);
24401
24402      print_VkImageUsageFlags(obj->imageUsage, "imageUsage", 1);
24403
24404      print_VkSharingMode(obj->imageSharingMode, "imageSharingMode", 1);
24405
24406      print_uint32_t(obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1);
24407
24408      PRINT_SPACE
24409      _OUT << "\"pQueueFamilyIndices\":" << std::endl;
24410      PRINT_SPACE
24411      if (obj->pQueueFamilyIndices) {
24412        _OUT << "[" << std::endl;
24413        for (unsigned int i = 0; i < obj->queueFamilyIndexCount; i++) {
24414            bool isCommaNeeded = (i+1) != obj->queueFamilyIndexCount;
24415            print_uint32_t(obj->pQueueFamilyIndices[i], "", isCommaNeeded);
24416        }
24417        PRINT_SPACE
24418        _OUT << "]" << "," << std::endl;
24419      } else {
24420        _OUT << "\"NULL\"" << "," << std::endl;
24421      }
24422
24423      print_VkSurfaceTransformFlagBitsKHR(obj->preTransform, "preTransform", 1);
24424
24425      print_VkCompositeAlphaFlagBitsKHR(obj->compositeAlpha, "compositeAlpha", 1);
24426
24427      print_VkPresentModeKHR(obj->presentMode, "presentMode", 1);
24428
24429      print_VkBool32(obj->clipped, "clipped", 1);
24430
24431      // CTS : required value
24432      PRINT_SPACE    _OUT << "\"" << "oldSwapchain" << "\"" << " : " << "\"" << "\"" << std::endl;
24433
24434      INDENT(-4);
24435      PRINT_SPACE
24436      if (commaNeeded)
24437          _OUT << "}," << std::endl;
24438      else
24439          _OUT << "}" << std::endl;
24440 }
24441
24442 static void print_VkPresentInfoKHR(VkPresentInfoKHR obj, const std::string& s, bool commaNeeded=true) {
24443      PRINT_SPACE
24444      _OUT << "{" << std::endl;
24445      INDENT(4);
24446
24447      print_VkStructureType(obj.sType, "sType", 1);
24448
24449       if (obj.pNext) {
24450          dumpPNextChain(obj.pNext);
24451       } else {
24452          PRINT_SPACE
24453          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24454      }
24455
24456      print_uint32_t(obj.waitSemaphoreCount, "waitSemaphoreCount", 1);
24457
24458      PRINT_SPACE
24459      _OUT << "\"pWaitSemaphores\":" << std::endl;
24460      PRINT_SPACE
24461      if (obj.pWaitSemaphores) {
24462        _OUT << "[" << std::endl;
24463        for (unsigned int i = 0; i < obj.waitSemaphoreCount; i++) {
24464            std:: stringstream tmp;
24465            tmp << "pWaitSemaphores" << "_" << i;
24466            bool isCommaNeeded = (i+1) != obj.waitSemaphoreCount;
24467            print_VkSemaphore(obj.pWaitSemaphores[i], tmp.str(), isCommaNeeded);
24468        }
24469        PRINT_SPACE
24470        _OUT << "]" << "," << std::endl;
24471      } else {
24472        _OUT << "\"NULL\"" << "," << std::endl;
24473      }
24474
24475      print_uint32_t(obj.swapchainCount, "swapchainCount", 1);
24476
24477      PRINT_SPACE
24478      _OUT << "\"pSwapchains\":" << std::endl;
24479      PRINT_SPACE
24480      if (obj.pSwapchains) {
24481        _OUT << "[" << std::endl;
24482        for (unsigned int i = 0; i < obj.swapchainCount; i++) {
24483            std:: stringstream tmp;
24484            tmp << "pSwapchains" << "_" << i;
24485            bool isCommaNeeded = (i+1) != obj.swapchainCount;
24486            print_VkSwapchainKHR(obj.pSwapchains[i], tmp.str(), isCommaNeeded);
24487        }
24488        PRINT_SPACE
24489        _OUT << "]" << "," << std::endl;
24490      } else {
24491        _OUT << "\"NULL\"" << "," << std::endl;
24492      }
24493
24494      PRINT_SPACE
24495      _OUT << "\"pImageIndices\":" << std::endl;
24496      PRINT_SPACE
24497      if (obj.pImageIndices) {
24498        _OUT << "[" << std::endl;
24499        for (unsigned int i = 0; i < obj.swapchainCount; i++) {
24500            bool isCommaNeeded = (i+1) != obj.swapchainCount;
24501            print_uint32_t(obj.pImageIndices[i], "", isCommaNeeded);
24502        }
24503        PRINT_SPACE
24504        _OUT << "]" << "," << std::endl;
24505      } else {
24506        _OUT << "\"NULL\"" << "," << std::endl;
24507      }
24508
24509      PRINT_SPACE
24510      _OUT << "\"pResults\":" << std::endl;
24511      PRINT_SPACE
24512      if (obj.pResults) {
24513        _OUT << "[" << std::endl;
24514        for (unsigned int i = 0; i < obj.swapchainCount; i++) {
24515            bool isCommaNeeded = (i+1) != obj.swapchainCount;
24516            print_VkResult(obj.pResults[i], "", isCommaNeeded);
24517        }
24518        PRINT_SPACE
24519        _OUT << "]" << "" << std::endl;
24520      } else {
24521        _OUT << "\"NULL\"" << "" << std::endl;
24522      }
24523
24524      INDENT(-4);
24525      PRINT_SPACE
24526      if (commaNeeded)
24527          _OUT << "}," << std::endl;
24528      else
24529          _OUT << "}" << std::endl;
24530 }
24531 static void print_VkPresentInfoKHR(const VkPresentInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
24532      PRINT_SPACE
24533      _OUT << "{" << std::endl;
24534      INDENT(4);
24535
24536      print_VkStructureType(obj->sType, "sType", 1);
24537
24538       if (obj->pNext) {
24539          dumpPNextChain(obj->pNext);
24540       } else {
24541          PRINT_SPACE
24542          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24543      }
24544
24545      print_uint32_t(obj->waitSemaphoreCount, "waitSemaphoreCount", 1);
24546
24547      PRINT_SPACE
24548      _OUT << "\"pWaitSemaphores\":" << std::endl;
24549      PRINT_SPACE
24550      if (obj->pWaitSemaphores) {
24551        _OUT << "[" << std::endl;
24552        for (unsigned int i = 0; i < obj->waitSemaphoreCount; i++) {
24553            std:: stringstream tmp;
24554            tmp << "pWaitSemaphores" << "_" << i;
24555            bool isCommaNeeded = (i+1) != obj->waitSemaphoreCount;
24556            print_VkSemaphore(obj->pWaitSemaphores[i], tmp.str(), isCommaNeeded);
24557        }
24558        PRINT_SPACE
24559        _OUT << "]" << "," << std::endl;
24560      } else {
24561        _OUT << "\"NULL\"" << "," << std::endl;
24562      }
24563
24564      print_uint32_t(obj->swapchainCount, "swapchainCount", 1);
24565
24566      PRINT_SPACE
24567      _OUT << "\"pSwapchains\":" << std::endl;
24568      PRINT_SPACE
24569      if (obj->pSwapchains) {
24570        _OUT << "[" << std::endl;
24571        for (unsigned int i = 0; i < obj->swapchainCount; i++) {
24572            std:: stringstream tmp;
24573            tmp << "pSwapchains" << "_" << i;
24574            bool isCommaNeeded = (i+1) != obj->swapchainCount;
24575            print_VkSwapchainKHR(obj->pSwapchains[i], tmp.str(), isCommaNeeded);
24576        }
24577        PRINT_SPACE
24578        _OUT << "]" << "," << std::endl;
24579      } else {
24580        _OUT << "\"NULL\"" << "," << std::endl;
24581      }
24582
24583      PRINT_SPACE
24584      _OUT << "\"pImageIndices\":" << std::endl;
24585      PRINT_SPACE
24586      if (obj->pImageIndices) {
24587        _OUT << "[" << std::endl;
24588        for (unsigned int i = 0; i < obj->swapchainCount; i++) {
24589            bool isCommaNeeded = (i+1) != obj->swapchainCount;
24590            print_uint32_t(obj->pImageIndices[i], "", isCommaNeeded);
24591        }
24592        PRINT_SPACE
24593        _OUT << "]" << "," << std::endl;
24594      } else {
24595        _OUT << "\"NULL\"" << "," << std::endl;
24596      }
24597
24598      PRINT_SPACE
24599      _OUT << "\"pResults\":" << std::endl;
24600      PRINT_SPACE
24601      if (obj->pResults) {
24602        _OUT << "[" << std::endl;
24603        for (unsigned int i = 0; i < obj->swapchainCount; i++) {
24604            bool isCommaNeeded = (i+1) != obj->swapchainCount;
24605            print_VkResult(obj->pResults[i], "", isCommaNeeded);
24606        }
24607        PRINT_SPACE
24608        _OUT << "]" << "" << std::endl;
24609      } else {
24610        _OUT << "\"NULL\"" << "" << std::endl;
24611      }
24612
24613      INDENT(-4);
24614      PRINT_SPACE
24615      if (commaNeeded)
24616          _OUT << "}," << std::endl;
24617      else
24618          _OUT << "}" << std::endl;
24619 }
24620
24621 static void print_VkImageSwapchainCreateInfoKHR(VkImageSwapchainCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) {
24622      PRINT_SPACE
24623      _OUT << "{" << std::endl;
24624      INDENT(4);
24625
24626      print_VkStructureType(obj.sType, "sType", 1);
24627
24628       if (obj.pNext) {
24629          dumpPNextChain(obj.pNext);
24630       } else {
24631          PRINT_SPACE
24632          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24633      }
24634
24635      // CTS : required value
24636      PRINT_SPACE    _OUT << "\"" << "swapchain" << "\"" << " : " << "\"" << "\"" << std::endl;
24637
24638      INDENT(-4);
24639      PRINT_SPACE
24640      if (commaNeeded)
24641          _OUT << "}," << std::endl;
24642      else
24643          _OUT << "}" << std::endl;
24644 }
24645 static void print_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
24646      PRINT_SPACE
24647      _OUT << "{" << std::endl;
24648      INDENT(4);
24649
24650      print_VkStructureType(obj->sType, "sType", 1);
24651
24652       if (obj->pNext) {
24653          dumpPNextChain(obj->pNext);
24654       } else {
24655          PRINT_SPACE
24656          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24657      }
24658
24659      // CTS : required value
24660      PRINT_SPACE    _OUT << "\"" << "swapchain" << "\"" << " : " << "\"" << "\"" << std::endl;
24661
24662      INDENT(-4);
24663      PRINT_SPACE
24664      if (commaNeeded)
24665          _OUT << "}," << std::endl;
24666      else
24667          _OUT << "}" << std::endl;
24668 }
24669
24670 static void print_VkBindImageMemorySwapchainInfoKHR(VkBindImageMemorySwapchainInfoKHR obj, const std::string& s, bool commaNeeded=true) {
24671      PRINT_SPACE
24672      _OUT << "{" << std::endl;
24673      INDENT(4);
24674
24675      print_VkStructureType(obj.sType, "sType", 1);
24676
24677       if (obj.pNext) {
24678          dumpPNextChain(obj.pNext);
24679       } else {
24680          PRINT_SPACE
24681          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24682      }
24683
24684      // CTS : required value
24685      PRINT_SPACE    _OUT << "\"" << "swapchain" << "\"" << " : " << "\"" << "\"," << std::endl;
24686
24687      print_uint32_t(obj.imageIndex, "imageIndex", 0);
24688
24689      INDENT(-4);
24690      PRINT_SPACE
24691      if (commaNeeded)
24692          _OUT << "}," << std::endl;
24693      else
24694          _OUT << "}" << std::endl;
24695 }
24696 static void print_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
24697      PRINT_SPACE
24698      _OUT << "{" << std::endl;
24699      INDENT(4);
24700
24701      print_VkStructureType(obj->sType, "sType", 1);
24702
24703       if (obj->pNext) {
24704          dumpPNextChain(obj->pNext);
24705       } else {
24706          PRINT_SPACE
24707          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24708      }
24709
24710      // CTS : required value
24711      PRINT_SPACE    _OUT << "\"" << "swapchain" << "\"" << " : " << "\"" << "\"," << std::endl;
24712
24713      print_uint32_t(obj->imageIndex, "imageIndex", 0);
24714
24715      INDENT(-4);
24716      PRINT_SPACE
24717      if (commaNeeded)
24718          _OUT << "}," << std::endl;
24719      else
24720          _OUT << "}" << std::endl;
24721 }
24722
24723 static void print_VkAcquireNextImageInfoKHR(VkAcquireNextImageInfoKHR obj, const std::string& s, bool commaNeeded=true) {
24724      PRINT_SPACE
24725      _OUT << "{" << std::endl;
24726      INDENT(4);
24727
24728      print_VkStructureType(obj.sType, "sType", 1);
24729
24730       if (obj.pNext) {
24731          dumpPNextChain(obj.pNext);
24732       } else {
24733          PRINT_SPACE
24734          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24735      }
24736
24737      // CTS : required value
24738      PRINT_SPACE    _OUT << "\"" << "swapchain" << "\"" << " : " << "\"" << "\"," << std::endl;
24739
24740      print_uint64_t(obj.timeout, "timeout", 1);
24741
24742      // CTS : required value
24743      PRINT_SPACE    _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl;
24744
24745      // CTS : required value
24746      PRINT_SPACE    _OUT << "\"" << "fence" << "\"" << " : " << "\"" << "\"," << std::endl;
24747
24748      print_uint32_t(obj.deviceMask, "deviceMask", 0);
24749
24750      INDENT(-4);
24751      PRINT_SPACE
24752      if (commaNeeded)
24753          _OUT << "}," << std::endl;
24754      else
24755          _OUT << "}" << std::endl;
24756 }
24757 static void print_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
24758      PRINT_SPACE
24759      _OUT << "{" << std::endl;
24760      INDENT(4);
24761
24762      print_VkStructureType(obj->sType, "sType", 1);
24763
24764       if (obj->pNext) {
24765          dumpPNextChain(obj->pNext);
24766       } else {
24767          PRINT_SPACE
24768          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24769      }
24770
24771      // CTS : required value
24772      PRINT_SPACE    _OUT << "\"" << "swapchain" << "\"" << " : " << "\"" << "\"," << std::endl;
24773
24774      print_uint64_t(obj->timeout, "timeout", 1);
24775
24776      // CTS : required value
24777      PRINT_SPACE    _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl;
24778
24779      // CTS : required value
24780      PRINT_SPACE    _OUT << "\"" << "fence" << "\"" << " : " << "\"" << "\"," << std::endl;
24781
24782      print_uint32_t(obj->deviceMask, "deviceMask", 0);
24783
24784      INDENT(-4);
24785      PRINT_SPACE
24786      if (commaNeeded)
24787          _OUT << "}," << std::endl;
24788      else
24789          _OUT << "}" << std::endl;
24790 }
24791
24792 static void print_VkDeviceGroupPresentCapabilitiesKHR(VkDeviceGroupPresentCapabilitiesKHR obj, const std::string& s, bool commaNeeded=true) {
24793      PRINT_SPACE
24794      _OUT << "{" << std::endl;
24795      INDENT(4);
24796
24797      print_VkStructureType(obj.sType, "sType", 1);
24798
24799       if (obj.pNext) {
24800          dumpPNextChain(obj.pNext);
24801       } else {
24802          PRINT_SPACE
24803          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24804      }
24805
24806      PRINT_SPACE
24807      _OUT << "\"presentMask\":" << std::endl;
24808      PRINT_SPACE
24809      if (obj.presentMask) {
24810        _OUT << "[" << std::endl;
24811        for (unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) {
24812            bool isCommaNeeded = (i+1) != VK_MAX_DEVICE_GROUP_SIZE;
24813            print_uint32_t(obj.presentMask[i], "", isCommaNeeded);
24814        }
24815        PRINT_SPACE
24816        _OUT << "]" << "," << std::endl;
24817      } else {
24818        _OUT << "\"NULL\"" << "," << std::endl;
24819      }
24820
24821      print_VkDeviceGroupPresentModeFlagsKHR(obj.modes, "modes", 0);
24822
24823      INDENT(-4);
24824      PRINT_SPACE
24825      if (commaNeeded)
24826          _OUT << "}," << std::endl;
24827      else
24828          _OUT << "}" << std::endl;
24829 }
24830 static void print_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR * obj, const std::string& s, bool commaNeeded=true) {
24831      PRINT_SPACE
24832      _OUT << "{" << std::endl;
24833      INDENT(4);
24834
24835      print_VkStructureType(obj->sType, "sType", 1);
24836
24837       if (obj->pNext) {
24838          dumpPNextChain(obj->pNext);
24839       } else {
24840          PRINT_SPACE
24841          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24842      }
24843
24844      PRINT_SPACE
24845      _OUT << "\"presentMask\":" << std::endl;
24846      PRINT_SPACE
24847      if (obj->presentMask) {
24848        _OUT << "[" << std::endl;
24849        for (unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) {
24850            bool isCommaNeeded = (i+1) != VK_MAX_DEVICE_GROUP_SIZE;
24851            print_uint32_t(obj->presentMask[i], "", isCommaNeeded);
24852        }
24853        PRINT_SPACE
24854        _OUT << "]" << "," << std::endl;
24855      } else {
24856        _OUT << "\"NULL\"" << "," << std::endl;
24857      }
24858
24859      print_VkDeviceGroupPresentModeFlagsKHR(obj->modes, "modes", 0);
24860
24861      INDENT(-4);
24862      PRINT_SPACE
24863      if (commaNeeded)
24864          _OUT << "}," << std::endl;
24865      else
24866          _OUT << "}" << std::endl;
24867 }
24868
24869 static void print_VkDeviceGroupPresentInfoKHR(VkDeviceGroupPresentInfoKHR obj, const std::string& s, bool commaNeeded=true) {
24870      PRINT_SPACE
24871      _OUT << "{" << std::endl;
24872      INDENT(4);
24873
24874      print_VkStructureType(obj.sType, "sType", 1);
24875
24876       if (obj.pNext) {
24877          dumpPNextChain(obj.pNext);
24878       } else {
24879          PRINT_SPACE
24880          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24881      }
24882
24883      print_uint32_t(obj.swapchainCount, "swapchainCount", 1);
24884
24885      PRINT_SPACE
24886      _OUT << "\"pDeviceMasks\":" << std::endl;
24887      PRINT_SPACE
24888      if (obj.pDeviceMasks) {
24889        _OUT << "[" << std::endl;
24890        for (unsigned int i = 0; i < obj.swapchainCount; i++) {
24891            bool isCommaNeeded = (i+1) != obj.swapchainCount;
24892            print_uint32_t(obj.pDeviceMasks[i], "", isCommaNeeded);
24893        }
24894        PRINT_SPACE
24895        _OUT << "]" << "," << std::endl;
24896      } else {
24897        _OUT << "\"NULL\"" << "," << std::endl;
24898      }
24899
24900      print_VkDeviceGroupPresentModeFlagBitsKHR(obj.mode, "mode", 0);
24901
24902      INDENT(-4);
24903      PRINT_SPACE
24904      if (commaNeeded)
24905          _OUT << "}," << std::endl;
24906      else
24907          _OUT << "}" << std::endl;
24908 }
24909 static void print_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
24910      PRINT_SPACE
24911      _OUT << "{" << std::endl;
24912      INDENT(4);
24913
24914      print_VkStructureType(obj->sType, "sType", 1);
24915
24916       if (obj->pNext) {
24917          dumpPNextChain(obj->pNext);
24918       } else {
24919          PRINT_SPACE
24920          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24921      }
24922
24923      print_uint32_t(obj->swapchainCount, "swapchainCount", 1);
24924
24925      PRINT_SPACE
24926      _OUT << "\"pDeviceMasks\":" << std::endl;
24927      PRINT_SPACE
24928      if (obj->pDeviceMasks) {
24929        _OUT << "[" << std::endl;
24930        for (unsigned int i = 0; i < obj->swapchainCount; i++) {
24931            bool isCommaNeeded = (i+1) != obj->swapchainCount;
24932            print_uint32_t(obj->pDeviceMasks[i], "", isCommaNeeded);
24933        }
24934        PRINT_SPACE
24935        _OUT << "]" << "," << std::endl;
24936      } else {
24937        _OUT << "\"NULL\"" << "," << std::endl;
24938      }
24939
24940      print_VkDeviceGroupPresentModeFlagBitsKHR(obj->mode, "mode", 0);
24941
24942      INDENT(-4);
24943      PRINT_SPACE
24944      if (commaNeeded)
24945          _OUT << "}," << std::endl;
24946      else
24947          _OUT << "}" << std::endl;
24948 }
24949
24950 static void print_VkDeviceGroupSwapchainCreateInfoKHR(VkDeviceGroupSwapchainCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) {
24951      PRINT_SPACE
24952      _OUT << "{" << std::endl;
24953      INDENT(4);
24954
24955      print_VkStructureType(obj.sType, "sType", 1);
24956
24957       if (obj.pNext) {
24958          dumpPNextChain(obj.pNext);
24959       } else {
24960          PRINT_SPACE
24961          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24962      }
24963
24964      print_VkDeviceGroupPresentModeFlagsKHR(obj.modes, "modes", 0);
24965
24966      INDENT(-4);
24967      PRINT_SPACE
24968      if (commaNeeded)
24969          _OUT << "}," << std::endl;
24970      else
24971          _OUT << "}" << std::endl;
24972 }
24973 static void print_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
24974      PRINT_SPACE
24975      _OUT << "{" << std::endl;
24976      INDENT(4);
24977
24978      print_VkStructureType(obj->sType, "sType", 1);
24979
24980       if (obj->pNext) {
24981          dumpPNextChain(obj->pNext);
24982       } else {
24983          PRINT_SPACE
24984          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
24985      }
24986
24987      print_VkDeviceGroupPresentModeFlagsKHR(obj->modes, "modes", 0);
24988
24989      INDENT(-4);
24990      PRINT_SPACE
24991      if (commaNeeded)
24992          _OUT << "}," << std::endl;
24993      else
24994          _OUT << "}" << std::endl;
24995 }
24996
24997 static void print_VkDisplayKHR(VkDisplayKHR obj, const std::string& str, bool commaNeeded=true) {
24998      PRINT_SPACE
24999      if (commaNeeded)
25000          _OUT << "\"" << str << "\"" << "," << std::endl;
25001      else
25002          _OUT << "\"" << str << "\"" << std::endl;
25003 }
25004 static void print_VkDisplayKHR(const VkDisplayKHR * obj, const std::string& str, bool commaNeeded=true) {
25005      PRINT_SPACE
25006      if (commaNeeded)
25007          _OUT << "\"" << str << "\"" << "," << std::endl;
25008      else
25009          _OUT << "\"" << str << "\"" << std::endl;
25010 }
25011
25012 static void print_VkDisplayModeKHR(VkDisplayModeKHR obj, const std::string& str, bool commaNeeded=true) {
25013      PRINT_SPACE
25014      if (commaNeeded)
25015          _OUT << "\"" << str << "\"" << "," << std::endl;
25016      else
25017          _OUT << "\"" << str << "\"" << std::endl;
25018 }
25019 static void print_VkDisplayModeKHR(const VkDisplayModeKHR * obj, const std::string& str, bool commaNeeded=true) {
25020      PRINT_SPACE
25021      if (commaNeeded)
25022          _OUT << "\"" << str << "\"" << "," << std::endl;
25023      else
25024          _OUT << "\"" << str << "\"" << std::endl;
25025 }
25026
25027 static std::map<deUint64, std::string> VkDisplayPlaneAlphaFlagBitsKHR_map = {
25028     std::make_pair(1ULL << 0, "VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR"),
25029     std::make_pair(1ULL << 1, "VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR"),
25030     std::make_pair(1ULL << 2, "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR"),
25031     std::make_pair(1ULL << 3, "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR"),
25032 };
25033 static void print_VkDisplayPlaneAlphaFlagBitsKHR(VkDisplayPlaneAlphaFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) {
25034      PRINT_SPACE
25035      if (str != "") _OUT << "\"" << str << "\"" << " : ";
25036      if (commaNeeded)
25037          _OUT << "\"" <<  VkDisplayPlaneAlphaFlagBitsKHR_map[obj] << "\"," << std::endl;
25038      else
25039          _OUT << "\"" << VkDisplayPlaneAlphaFlagBitsKHR_map[obj] << "\"" << std::endl;
25040 }
25041 static void print_VkDisplayPlaneAlphaFlagBitsKHR(const VkDisplayPlaneAlphaFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) {
25042      PRINT_SPACE
25043      if (str != "") _OUT << "\"" << str << "\"" << " : ";
25044      if (commaNeeded)
25045          _OUT << "\"" <<  VkDisplayPlaneAlphaFlagBitsKHR_map[*obj] << "\"," << std::endl;
25046      else
25047          _OUT << "\"" << VkDisplayPlaneAlphaFlagBitsKHR_map[*obj] << "\"" << std::endl;
25048 }
25049
25050 static void print_VkDisplayModeCreateFlagsKHR(VkDisplayModeCreateFlagsKHR obj, const std::string& str, bool commaNeeded=true) {
25051      PRINT_SPACE
25052      if (commaNeeded)
25053          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
25054      else
25055          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
25056 }
25057 static void print_VkDisplayModeCreateFlagsKHR(const VkDisplayModeCreateFlagsKHR * obj, const std::string& str, bool commaNeeded=true) {
25058      PRINT_SPACE
25059      if (commaNeeded)
25060          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
25061      else
25062          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
25063 }
25064
25065 static void print_VkDisplayPlaneAlphaFlagsKHR(VkDisplayPlaneAlphaFlagsKHR obj, const std::string& str, bool commaNeeded=true) {
25066      PRINT_SPACE
25067      if (str != "") _OUT << "\"" << str << "\"" << " : ";
25068      const int max_bits = 64; // We don't expect the number to be larger.
25069      std::bitset<max_bits> b(obj);
25070      _OUT << "\"";
25071      if (obj == 0) _OUT << "0";
25072      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
25073          if (b[i] == 1) {
25074              bitCount++;
25075              if (bitCount < b.count())
25076                  _OUT << VkDisplayPlaneAlphaFlagBitsKHR_map[1ULL<<i] << " | ";
25077              else
25078                  _OUT << VkDisplayPlaneAlphaFlagBitsKHR_map[1ULL<<i];
25079          }
25080      }
25081      if (commaNeeded)
25082        _OUT << "\"" << ",";
25083      else
25084        _OUT << "\""<< "";
25085      _OUT << std::endl;
25086 }
25087 static void print_VkDisplayPlaneAlphaFlagsKHR(const VkDisplayPlaneAlphaFlagsKHR * obj, const std::string& str, bool commaNeeded=true) {
25088      PRINT_SPACE
25089      if (str != "") _OUT << "\"" << str << "\"" << " : ";
25090      const int max_bits = 64; // We don't expect the number to be larger.
25091      std::bitset<max_bits> b(obj);
25092      _OUT << "\"";
25093      if (obj == 0) _OUT << "0";
25094      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
25095          if (b[i] == 1) {
25096              bitCount++;
25097              if (bitCount < b.count())
25098                  _OUT << VkDisplayPlaneAlphaFlagBitsKHR_map[1ULL<<i] << " | ";
25099              else
25100                  _OUT << VkDisplayPlaneAlphaFlagBitsKHR_map[1ULL<<i];
25101          }
25102      }
25103      if (commaNeeded)
25104        _OUT << "\"" << ",";
25105      else
25106        _OUT << "\""<< "";
25107      _OUT << std::endl;
25108 }
25109
25110 static void print_VkDisplaySurfaceCreateFlagsKHR(VkDisplaySurfaceCreateFlagsKHR obj, const std::string& str, bool commaNeeded=true) {
25111      PRINT_SPACE
25112      if (commaNeeded)
25113          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
25114      else
25115          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
25116 }
25117 static void print_VkDisplaySurfaceCreateFlagsKHR(const VkDisplaySurfaceCreateFlagsKHR * obj, const std::string& str, bool commaNeeded=true) {
25118      PRINT_SPACE
25119      if (commaNeeded)
25120          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
25121      else
25122          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
25123 }
25124
25125 static void print_VkDisplayModeParametersKHR(VkDisplayModeParametersKHR obj, const std::string& s, bool commaNeeded=true) {
25126      PRINT_SPACE
25127      _OUT << "{" << std::endl;
25128      INDENT(4);
25129
25130      PRINT_SPACE
25131      _OUT << "\"visibleRegion\": " << std::endl;
25132      {
25133            print_VkExtent2D(obj.visibleRegion, "visibleRegion", 1);
25134      }
25135
25136      print_uint32_t(obj.refreshRate, "refreshRate", 0);
25137
25138      INDENT(-4);
25139      PRINT_SPACE
25140      if (commaNeeded)
25141          _OUT << "}," << std::endl;
25142      else
25143          _OUT << "}" << std::endl;
25144 }
25145 static void print_VkDisplayModeParametersKHR(const VkDisplayModeParametersKHR * obj, const std::string& s, bool commaNeeded=true) {
25146      PRINT_SPACE
25147      _OUT << "{" << std::endl;
25148      INDENT(4);
25149
25150      PRINT_SPACE
25151      _OUT << "\"visibleRegion\": " << std::endl;
25152      {
25153            print_VkExtent2D(obj->visibleRegion, "visibleRegion", 1);
25154      }
25155
25156      print_uint32_t(obj->refreshRate, "refreshRate", 0);
25157
25158      INDENT(-4);
25159      PRINT_SPACE
25160      if (commaNeeded)
25161          _OUT << "}," << std::endl;
25162      else
25163          _OUT << "}" << std::endl;
25164 }
25165
25166 static void print_VkDisplayModeCreateInfoKHR(VkDisplayModeCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) {
25167      PRINT_SPACE
25168      _OUT << "{" << std::endl;
25169      INDENT(4);
25170
25171      print_VkStructureType(obj.sType, "sType", 1);
25172
25173       if (obj.pNext) {
25174          dumpPNextChain(obj.pNext);
25175       } else {
25176          PRINT_SPACE
25177          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25178      }
25179
25180      print_VkDisplayModeCreateFlagsKHR(obj.flags, "flags", 1);
25181
25182      PRINT_SPACE
25183      _OUT << "\"parameters\": " << std::endl;
25184      {
25185            print_VkDisplayModeParametersKHR(obj.parameters, "parameters", 0);
25186      }
25187
25188      INDENT(-4);
25189      PRINT_SPACE
25190      if (commaNeeded)
25191          _OUT << "}," << std::endl;
25192      else
25193          _OUT << "}" << std::endl;
25194 }
25195 static void print_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
25196      PRINT_SPACE
25197      _OUT << "{" << std::endl;
25198      INDENT(4);
25199
25200      print_VkStructureType(obj->sType, "sType", 1);
25201
25202       if (obj->pNext) {
25203          dumpPNextChain(obj->pNext);
25204       } else {
25205          PRINT_SPACE
25206          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25207      }
25208
25209      print_VkDisplayModeCreateFlagsKHR(obj->flags, "flags", 1);
25210
25211      PRINT_SPACE
25212      _OUT << "\"parameters\": " << std::endl;
25213      {
25214            print_VkDisplayModeParametersKHR(obj->parameters, "parameters", 0);
25215      }
25216
25217      INDENT(-4);
25218      PRINT_SPACE
25219      if (commaNeeded)
25220          _OUT << "}," << std::endl;
25221      else
25222          _OUT << "}" << std::endl;
25223 }
25224
25225 static void print_VkDisplayModePropertiesKHR(VkDisplayModePropertiesKHR obj, const std::string& s, bool commaNeeded=true) {
25226      PRINT_SPACE
25227      _OUT << "{" << std::endl;
25228      INDENT(4);
25229
25230      // CTS : required value
25231      PRINT_SPACE    _OUT << "\"" << "displayMode" << "\"" << " : " << "\"" << "\"," << std::endl;
25232
25233      PRINT_SPACE
25234      _OUT << "\"parameters\": " << std::endl;
25235      {
25236            print_VkDisplayModeParametersKHR(obj.parameters, "parameters", 0);
25237      }
25238
25239      INDENT(-4);
25240      PRINT_SPACE
25241      if (commaNeeded)
25242          _OUT << "}," << std::endl;
25243      else
25244          _OUT << "}" << std::endl;
25245 }
25246 static void print_VkDisplayModePropertiesKHR(const VkDisplayModePropertiesKHR * obj, const std::string& s, bool commaNeeded=true) {
25247      PRINT_SPACE
25248      _OUT << "{" << std::endl;
25249      INDENT(4);
25250
25251      // CTS : required value
25252      PRINT_SPACE    _OUT << "\"" << "displayMode" << "\"" << " : " << "\"" << "\"," << std::endl;
25253
25254      PRINT_SPACE
25255      _OUT << "\"parameters\": " << std::endl;
25256      {
25257            print_VkDisplayModeParametersKHR(obj->parameters, "parameters", 0);
25258      }
25259
25260      INDENT(-4);
25261      PRINT_SPACE
25262      if (commaNeeded)
25263          _OUT << "}," << std::endl;
25264      else
25265          _OUT << "}" << std::endl;
25266 }
25267
25268 static void print_VkDisplayPlaneCapabilitiesKHR(VkDisplayPlaneCapabilitiesKHR obj, const std::string& s, bool commaNeeded=true) {
25269      PRINT_SPACE
25270      _OUT << "{" << std::endl;
25271      INDENT(4);
25272
25273      print_VkDisplayPlaneAlphaFlagsKHR(obj.supportedAlpha, "supportedAlpha", 1);
25274
25275      PRINT_SPACE
25276      _OUT << "\"minSrcPosition\": " << std::endl;
25277      {
25278            print_VkOffset2D(obj.minSrcPosition, "minSrcPosition", 1);
25279      }
25280
25281      PRINT_SPACE
25282      _OUT << "\"maxSrcPosition\": " << std::endl;
25283      {
25284            print_VkOffset2D(obj.maxSrcPosition, "maxSrcPosition", 1);
25285      }
25286
25287      PRINT_SPACE
25288      _OUT << "\"minSrcExtent\": " << std::endl;
25289      {
25290            print_VkExtent2D(obj.minSrcExtent, "minSrcExtent", 1);
25291      }
25292
25293      PRINT_SPACE
25294      _OUT << "\"maxSrcExtent\": " << std::endl;
25295      {
25296            print_VkExtent2D(obj.maxSrcExtent, "maxSrcExtent", 1);
25297      }
25298
25299      PRINT_SPACE
25300      _OUT << "\"minDstPosition\": " << std::endl;
25301      {
25302            print_VkOffset2D(obj.minDstPosition, "minDstPosition", 1);
25303      }
25304
25305      PRINT_SPACE
25306      _OUT << "\"maxDstPosition\": " << std::endl;
25307      {
25308            print_VkOffset2D(obj.maxDstPosition, "maxDstPosition", 1);
25309      }
25310
25311      PRINT_SPACE
25312      _OUT << "\"minDstExtent\": " << std::endl;
25313      {
25314            print_VkExtent2D(obj.minDstExtent, "minDstExtent", 1);
25315      }
25316
25317      PRINT_SPACE
25318      _OUT << "\"maxDstExtent\": " << std::endl;
25319      {
25320            print_VkExtent2D(obj.maxDstExtent, "maxDstExtent", 0);
25321      }
25322
25323      INDENT(-4);
25324      PRINT_SPACE
25325      if (commaNeeded)
25326          _OUT << "}," << std::endl;
25327      else
25328          _OUT << "}" << std::endl;
25329 }
25330 static void print_VkDisplayPlaneCapabilitiesKHR(const VkDisplayPlaneCapabilitiesKHR * obj, const std::string& s, bool commaNeeded=true) {
25331      PRINT_SPACE
25332      _OUT << "{" << std::endl;
25333      INDENT(4);
25334
25335      print_VkDisplayPlaneAlphaFlagsKHR(obj->supportedAlpha, "supportedAlpha", 1);
25336
25337      PRINT_SPACE
25338      _OUT << "\"minSrcPosition\": " << std::endl;
25339      {
25340            print_VkOffset2D(obj->minSrcPosition, "minSrcPosition", 1);
25341      }
25342
25343      PRINT_SPACE
25344      _OUT << "\"maxSrcPosition\": " << std::endl;
25345      {
25346            print_VkOffset2D(obj->maxSrcPosition, "maxSrcPosition", 1);
25347      }
25348
25349      PRINT_SPACE
25350      _OUT << "\"minSrcExtent\": " << std::endl;
25351      {
25352            print_VkExtent2D(obj->minSrcExtent, "minSrcExtent", 1);
25353      }
25354
25355      PRINT_SPACE
25356      _OUT << "\"maxSrcExtent\": " << std::endl;
25357      {
25358            print_VkExtent2D(obj->maxSrcExtent, "maxSrcExtent", 1);
25359      }
25360
25361      PRINT_SPACE
25362      _OUT << "\"minDstPosition\": " << std::endl;
25363      {
25364            print_VkOffset2D(obj->minDstPosition, "minDstPosition", 1);
25365      }
25366
25367      PRINT_SPACE
25368      _OUT << "\"maxDstPosition\": " << std::endl;
25369      {
25370            print_VkOffset2D(obj->maxDstPosition, "maxDstPosition", 1);
25371      }
25372
25373      PRINT_SPACE
25374      _OUT << "\"minDstExtent\": " << std::endl;
25375      {
25376            print_VkExtent2D(obj->minDstExtent, "minDstExtent", 1);
25377      }
25378
25379      PRINT_SPACE
25380      _OUT << "\"maxDstExtent\": " << std::endl;
25381      {
25382            print_VkExtent2D(obj->maxDstExtent, "maxDstExtent", 0);
25383      }
25384
25385      INDENT(-4);
25386      PRINT_SPACE
25387      if (commaNeeded)
25388          _OUT << "}," << std::endl;
25389      else
25390          _OUT << "}" << std::endl;
25391 }
25392
25393 static void print_VkDisplayPlanePropertiesKHR(VkDisplayPlanePropertiesKHR obj, const std::string& s, bool commaNeeded=true) {
25394      PRINT_SPACE
25395      _OUT << "{" << std::endl;
25396      INDENT(4);
25397
25398      // CTS : required value
25399      PRINT_SPACE    _OUT << "\"" << "currentDisplay" << "\"" << " : " << "\"" << "\"," << std::endl;
25400
25401      print_uint32_t(obj.currentStackIndex, "currentStackIndex", 0);
25402
25403      INDENT(-4);
25404      PRINT_SPACE
25405      if (commaNeeded)
25406          _OUT << "}," << std::endl;
25407      else
25408          _OUT << "}" << std::endl;
25409 }
25410 static void print_VkDisplayPlanePropertiesKHR(const VkDisplayPlanePropertiesKHR * obj, const std::string& s, bool commaNeeded=true) {
25411      PRINT_SPACE
25412      _OUT << "{" << std::endl;
25413      INDENT(4);
25414
25415      // CTS : required value
25416      PRINT_SPACE    _OUT << "\"" << "currentDisplay" << "\"" << " : " << "\"" << "\"," << std::endl;
25417
25418      print_uint32_t(obj->currentStackIndex, "currentStackIndex", 0);
25419
25420      INDENT(-4);
25421      PRINT_SPACE
25422      if (commaNeeded)
25423          _OUT << "}," << std::endl;
25424      else
25425          _OUT << "}" << std::endl;
25426 }
25427
25428 static void print_VkDisplayPropertiesKHR(VkDisplayPropertiesKHR obj, const std::string& s, bool commaNeeded=true) {
25429      PRINT_SPACE
25430      _OUT << "{" << std::endl;
25431      INDENT(4);
25432
25433      // CTS : required value
25434      PRINT_SPACE    _OUT << "\"" << "display" << "\"" << " : " << "\"" << "\"," << std::endl;
25435
25436      print_char(obj.displayName, "displayName", 1);
25437
25438      PRINT_SPACE
25439      _OUT << "\"physicalDimensions\": " << std::endl;
25440      {
25441            print_VkExtent2D(obj.physicalDimensions, "physicalDimensions", 1);
25442      }
25443
25444      PRINT_SPACE
25445      _OUT << "\"physicalResolution\": " << std::endl;
25446      {
25447            print_VkExtent2D(obj.physicalResolution, "physicalResolution", 1);
25448      }
25449
25450      print_VkSurfaceTransformFlagsKHR(obj.supportedTransforms, "supportedTransforms", 1);
25451
25452      print_VkBool32(obj.planeReorderPossible, "planeReorderPossible", 1);
25453
25454      print_VkBool32(obj.persistentContent, "persistentContent", 0);
25455
25456      INDENT(-4);
25457      PRINT_SPACE
25458      if (commaNeeded)
25459          _OUT << "}," << std::endl;
25460      else
25461          _OUT << "}" << std::endl;
25462 }
25463 static void print_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR * obj, const std::string& s, bool commaNeeded=true) {
25464      PRINT_SPACE
25465      _OUT << "{" << std::endl;
25466      INDENT(4);
25467
25468      // CTS : required value
25469      PRINT_SPACE    _OUT << "\"" << "display" << "\"" << " : " << "\"" << "\"," << std::endl;
25470
25471      print_char(obj->displayName, "displayName", 1);
25472
25473      PRINT_SPACE
25474      _OUT << "\"physicalDimensions\": " << std::endl;
25475      {
25476            print_VkExtent2D(obj->physicalDimensions, "physicalDimensions", 1);
25477      }
25478
25479      PRINT_SPACE
25480      _OUT << "\"physicalResolution\": " << std::endl;
25481      {
25482            print_VkExtent2D(obj->physicalResolution, "physicalResolution", 1);
25483      }
25484
25485      print_VkSurfaceTransformFlagsKHR(obj->supportedTransforms, "supportedTransforms", 1);
25486
25487      print_VkBool32(obj->planeReorderPossible, "planeReorderPossible", 1);
25488
25489      print_VkBool32(obj->persistentContent, "persistentContent", 0);
25490
25491      INDENT(-4);
25492      PRINT_SPACE
25493      if (commaNeeded)
25494          _OUT << "}," << std::endl;
25495      else
25496          _OUT << "}" << std::endl;
25497 }
25498
25499 static void print_VkDisplaySurfaceCreateInfoKHR(VkDisplaySurfaceCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) {
25500      PRINT_SPACE
25501      _OUT << "{" << std::endl;
25502      INDENT(4);
25503
25504      print_VkStructureType(obj.sType, "sType", 1);
25505
25506       if (obj.pNext) {
25507          dumpPNextChain(obj.pNext);
25508       } else {
25509          PRINT_SPACE
25510          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25511      }
25512
25513      print_VkDisplaySurfaceCreateFlagsKHR(obj.flags, "flags", 1);
25514
25515      // CTS : required value
25516      PRINT_SPACE    _OUT << "\"" << "displayMode" << "\"" << " : " << "\"" << "\"," << std::endl;
25517
25518      print_uint32_t(obj.planeIndex, "planeIndex", 1);
25519
25520      print_uint32_t(obj.planeStackIndex, "planeStackIndex", 1);
25521
25522      print_VkSurfaceTransformFlagBitsKHR(obj.transform, "transform", 1);
25523
25524      print_float(obj.globalAlpha, "globalAlpha", 1);
25525
25526      print_VkDisplayPlaneAlphaFlagBitsKHR(obj.alphaMode, "alphaMode", 1);
25527
25528      PRINT_SPACE
25529      _OUT << "\"imageExtent\": " << std::endl;
25530      {
25531            print_VkExtent2D(obj.imageExtent, "imageExtent", 0);
25532      }
25533
25534      INDENT(-4);
25535      PRINT_SPACE
25536      if (commaNeeded)
25537          _OUT << "}," << std::endl;
25538      else
25539          _OUT << "}" << std::endl;
25540 }
25541 static void print_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
25542      PRINT_SPACE
25543      _OUT << "{" << std::endl;
25544      INDENT(4);
25545
25546      print_VkStructureType(obj->sType, "sType", 1);
25547
25548       if (obj->pNext) {
25549          dumpPNextChain(obj->pNext);
25550       } else {
25551          PRINT_SPACE
25552          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25553      }
25554
25555      print_VkDisplaySurfaceCreateFlagsKHR(obj->flags, "flags", 1);
25556
25557      // CTS : required value
25558      PRINT_SPACE    _OUT << "\"" << "displayMode" << "\"" << " : " << "\"" << "\"," << std::endl;
25559
25560      print_uint32_t(obj->planeIndex, "planeIndex", 1);
25561
25562      print_uint32_t(obj->planeStackIndex, "planeStackIndex", 1);
25563
25564      print_VkSurfaceTransformFlagBitsKHR(obj->transform, "transform", 1);
25565
25566      print_float(obj->globalAlpha, "globalAlpha", 1);
25567
25568      print_VkDisplayPlaneAlphaFlagBitsKHR(obj->alphaMode, "alphaMode", 1);
25569
25570      PRINT_SPACE
25571      _OUT << "\"imageExtent\": " << std::endl;
25572      {
25573            print_VkExtent2D(obj->imageExtent, "imageExtent", 0);
25574      }
25575
25576      INDENT(-4);
25577      PRINT_SPACE
25578      if (commaNeeded)
25579          _OUT << "}," << std::endl;
25580      else
25581          _OUT << "}" << std::endl;
25582 }
25583
25584 static void print_VkDisplayPresentInfoKHR(VkDisplayPresentInfoKHR obj, const std::string& s, bool commaNeeded=true) {
25585      PRINT_SPACE
25586      _OUT << "{" << std::endl;
25587      INDENT(4);
25588
25589      print_VkStructureType(obj.sType, "sType", 1);
25590
25591       if (obj.pNext) {
25592          dumpPNextChain(obj.pNext);
25593       } else {
25594          PRINT_SPACE
25595          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25596      }
25597
25598      PRINT_SPACE
25599      _OUT << "\"srcRect\": " << std::endl;
25600      {
25601            print_VkRect2D(obj.srcRect, "srcRect", 1);
25602      }
25603
25604      PRINT_SPACE
25605      _OUT << "\"dstRect\": " << std::endl;
25606      {
25607            print_VkRect2D(obj.dstRect, "dstRect", 1);
25608      }
25609
25610      print_VkBool32(obj.persistent, "persistent", 0);
25611
25612      INDENT(-4);
25613      PRINT_SPACE
25614      if (commaNeeded)
25615          _OUT << "}," << std::endl;
25616      else
25617          _OUT << "}" << std::endl;
25618 }
25619 static void print_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
25620      PRINT_SPACE
25621      _OUT << "{" << std::endl;
25622      INDENT(4);
25623
25624      print_VkStructureType(obj->sType, "sType", 1);
25625
25626       if (obj->pNext) {
25627          dumpPNextChain(obj->pNext);
25628       } else {
25629          PRINT_SPACE
25630          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25631      }
25632
25633      PRINT_SPACE
25634      _OUT << "\"srcRect\": " << std::endl;
25635      {
25636            print_VkRect2D(obj->srcRect, "srcRect", 1);
25637      }
25638
25639      PRINT_SPACE
25640      _OUT << "\"dstRect\": " << std::endl;
25641      {
25642            print_VkRect2D(obj->dstRect, "dstRect", 1);
25643      }
25644
25645      print_VkBool32(obj->persistent, "persistent", 0);
25646
25647      INDENT(-4);
25648      PRINT_SPACE
25649      if (commaNeeded)
25650          _OUT << "}," << std::endl;
25651      else
25652          _OUT << "}" << std::endl;
25653 }
25654
25655 static void print_VkImportMemoryFdInfoKHR(VkImportMemoryFdInfoKHR obj, const std::string& s, bool commaNeeded=true) {
25656      PRINT_SPACE
25657      _OUT << "{" << std::endl;
25658      INDENT(4);
25659
25660      print_VkStructureType(obj.sType, "sType", 1);
25661
25662       if (obj.pNext) {
25663          dumpPNextChain(obj.pNext);
25664       } else {
25665          PRINT_SPACE
25666          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25667      }
25668
25669      print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 1);
25670
25671      print_int(obj.fd, "fd", 0);
25672
25673      INDENT(-4);
25674      PRINT_SPACE
25675      if (commaNeeded)
25676          _OUT << "}," << std::endl;
25677      else
25678          _OUT << "}" << std::endl;
25679 }
25680 static void print_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
25681      PRINT_SPACE
25682      _OUT << "{" << std::endl;
25683      INDENT(4);
25684
25685      print_VkStructureType(obj->sType, "sType", 1);
25686
25687       if (obj->pNext) {
25688          dumpPNextChain(obj->pNext);
25689       } else {
25690          PRINT_SPACE
25691          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25692      }
25693
25694      print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 1);
25695
25696      print_int(obj->fd, "fd", 0);
25697
25698      INDENT(-4);
25699      PRINT_SPACE
25700      if (commaNeeded)
25701          _OUT << "}," << std::endl;
25702      else
25703          _OUT << "}" << std::endl;
25704 }
25705
25706 static void print_VkMemoryFdPropertiesKHR(VkMemoryFdPropertiesKHR obj, const std::string& s, bool commaNeeded=true) {
25707      PRINT_SPACE
25708      _OUT << "{" << std::endl;
25709      INDENT(4);
25710
25711      print_VkStructureType(obj.sType, "sType", 1);
25712
25713       if (obj.pNext) {
25714          dumpPNextChain(obj.pNext);
25715       } else {
25716          PRINT_SPACE
25717          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25718      }
25719
25720      print_uint32_t(obj.memoryTypeBits, "memoryTypeBits", 0);
25721
25722      INDENT(-4);
25723      PRINT_SPACE
25724      if (commaNeeded)
25725          _OUT << "}," << std::endl;
25726      else
25727          _OUT << "}" << std::endl;
25728 }
25729 static void print_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR * obj, const std::string& s, bool commaNeeded=true) {
25730      PRINT_SPACE
25731      _OUT << "{" << std::endl;
25732      INDENT(4);
25733
25734      print_VkStructureType(obj->sType, "sType", 1);
25735
25736       if (obj->pNext) {
25737          dumpPNextChain(obj->pNext);
25738       } else {
25739          PRINT_SPACE
25740          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25741      }
25742
25743      print_uint32_t(obj->memoryTypeBits, "memoryTypeBits", 0);
25744
25745      INDENT(-4);
25746      PRINT_SPACE
25747      if (commaNeeded)
25748          _OUT << "}," << std::endl;
25749      else
25750          _OUT << "}" << std::endl;
25751 }
25752
25753 static void print_VkMemoryGetFdInfoKHR(VkMemoryGetFdInfoKHR obj, const std::string& s, bool commaNeeded=true) {
25754      PRINT_SPACE
25755      _OUT << "{" << std::endl;
25756      INDENT(4);
25757
25758      print_VkStructureType(obj.sType, "sType", 1);
25759
25760       if (obj.pNext) {
25761          dumpPNextChain(obj.pNext);
25762       } else {
25763          PRINT_SPACE
25764          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25765      }
25766
25767      // CTS : required value
25768      PRINT_SPACE    _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl;
25769
25770      print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 0);
25771
25772      INDENT(-4);
25773      PRINT_SPACE
25774      if (commaNeeded)
25775          _OUT << "}," << std::endl;
25776      else
25777          _OUT << "}" << std::endl;
25778 }
25779 static void print_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
25780      PRINT_SPACE
25781      _OUT << "{" << std::endl;
25782      INDENT(4);
25783
25784      print_VkStructureType(obj->sType, "sType", 1);
25785
25786       if (obj->pNext) {
25787          dumpPNextChain(obj->pNext);
25788       } else {
25789          PRINT_SPACE
25790          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25791      }
25792
25793      // CTS : required value
25794      PRINT_SPACE    _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl;
25795
25796      print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 0);
25797
25798      INDENT(-4);
25799      PRINT_SPACE
25800      if (commaNeeded)
25801          _OUT << "}," << std::endl;
25802      else
25803          _OUT << "}" << std::endl;
25804 }
25805
25806 static void print_VkImportSemaphoreFdInfoKHR(VkImportSemaphoreFdInfoKHR obj, const std::string& s, bool commaNeeded=true) {
25807      PRINT_SPACE
25808      _OUT << "{" << std::endl;
25809      INDENT(4);
25810
25811      print_VkStructureType(obj.sType, "sType", 1);
25812
25813       if (obj.pNext) {
25814          dumpPNextChain(obj.pNext);
25815       } else {
25816          PRINT_SPACE
25817          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25818      }
25819
25820      // CTS : required value
25821      PRINT_SPACE    _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl;
25822
25823      print_VkSemaphoreImportFlags(obj.flags, "flags", 1);
25824
25825      print_VkExternalSemaphoreHandleTypeFlagBits(obj.handleType, "handleType", 1);
25826
25827      print_int(obj.fd, "fd", 0);
25828
25829      INDENT(-4);
25830      PRINT_SPACE
25831      if (commaNeeded)
25832          _OUT << "}," << std::endl;
25833      else
25834          _OUT << "}" << std::endl;
25835 }
25836 static void print_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
25837      PRINT_SPACE
25838      _OUT << "{" << std::endl;
25839      INDENT(4);
25840
25841      print_VkStructureType(obj->sType, "sType", 1);
25842
25843       if (obj->pNext) {
25844          dumpPNextChain(obj->pNext);
25845       } else {
25846          PRINT_SPACE
25847          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25848      }
25849
25850      // CTS : required value
25851      PRINT_SPACE    _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl;
25852
25853      print_VkSemaphoreImportFlags(obj->flags, "flags", 1);
25854
25855      print_VkExternalSemaphoreHandleTypeFlagBits(obj->handleType, "handleType", 1);
25856
25857      print_int(obj->fd, "fd", 0);
25858
25859      INDENT(-4);
25860      PRINT_SPACE
25861      if (commaNeeded)
25862          _OUT << "}," << std::endl;
25863      else
25864          _OUT << "}" << std::endl;
25865 }
25866
25867 static void print_VkSemaphoreGetFdInfoKHR(VkSemaphoreGetFdInfoKHR obj, const std::string& s, bool commaNeeded=true) {
25868      PRINT_SPACE
25869      _OUT << "{" << std::endl;
25870      INDENT(4);
25871
25872      print_VkStructureType(obj.sType, "sType", 1);
25873
25874       if (obj.pNext) {
25875          dumpPNextChain(obj.pNext);
25876       } else {
25877          PRINT_SPACE
25878          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25879      }
25880
25881      // CTS : required value
25882      PRINT_SPACE    _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl;
25883
25884      print_VkExternalSemaphoreHandleTypeFlagBits(obj.handleType, "handleType", 0);
25885
25886      INDENT(-4);
25887      PRINT_SPACE
25888      if (commaNeeded)
25889          _OUT << "}," << std::endl;
25890      else
25891          _OUT << "}" << std::endl;
25892 }
25893 static void print_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
25894      PRINT_SPACE
25895      _OUT << "{" << std::endl;
25896      INDENT(4);
25897
25898      print_VkStructureType(obj->sType, "sType", 1);
25899
25900       if (obj->pNext) {
25901          dumpPNextChain(obj->pNext);
25902       } else {
25903          PRINT_SPACE
25904          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
25905      }
25906
25907      // CTS : required value
25908      PRINT_SPACE    _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl;
25909
25910      print_VkExternalSemaphoreHandleTypeFlagBits(obj->handleType, "handleType", 0);
25911
25912      INDENT(-4);
25913      PRINT_SPACE
25914      if (commaNeeded)
25915          _OUT << "}," << std::endl;
25916      else
25917          _OUT << "}" << std::endl;
25918 }
25919
25920 static void print_VkRectLayerKHR(VkRectLayerKHR obj, const std::string& s, bool commaNeeded=true) {
25921      PRINT_SPACE
25922      _OUT << "{" << std::endl;
25923      INDENT(4);
25924
25925      PRINT_SPACE
25926      _OUT << "\"offset\": " << std::endl;
25927      {
25928            print_VkOffset2D(obj.offset, "offset", 1);
25929      }
25930
25931      PRINT_SPACE
25932      _OUT << "\"extent\": " << std::endl;
25933      {
25934            print_VkExtent2D(obj.extent, "extent", 1);
25935      }
25936
25937      print_uint32_t(obj.layer, "layer", 0);
25938
25939      INDENT(-4);
25940      PRINT_SPACE
25941      if (commaNeeded)
25942          _OUT << "}," << std::endl;
25943      else
25944          _OUT << "}" << std::endl;
25945 }
25946 static void print_VkRectLayerKHR(const VkRectLayerKHR * obj, const std::string& s, bool commaNeeded=true) {
25947      PRINT_SPACE
25948      _OUT << "{" << std::endl;
25949      INDENT(4);
25950
25951      PRINT_SPACE
25952      _OUT << "\"offset\": " << std::endl;
25953      {
25954            print_VkOffset2D(obj->offset, "offset", 1);
25955      }
25956
25957      PRINT_SPACE
25958      _OUT << "\"extent\": " << std::endl;
25959      {
25960            print_VkExtent2D(obj->extent, "extent", 1);
25961      }
25962
25963      print_uint32_t(obj->layer, "layer", 0);
25964
25965      INDENT(-4);
25966      PRINT_SPACE
25967      if (commaNeeded)
25968          _OUT << "}," << std::endl;
25969      else
25970          _OUT << "}" << std::endl;
25971 }
25972
25973 static void print_VkPresentRegionKHR(VkPresentRegionKHR obj, const std::string& s, bool commaNeeded=true) {
25974      PRINT_SPACE
25975      _OUT << "{" << std::endl;
25976      INDENT(4);
25977
25978      print_uint32_t(obj.rectangleCount, "rectangleCount", 1);
25979
25980      PRINT_SPACE
25981      _OUT << "\"pRectangles\": " << std::endl;
25982      if (obj.pRectangles) {
25983          PRINT_SPACE
25984          _OUT << "[" << std::endl;
25985          for (unsigned int i = 0; i < obj.rectangleCount; i++) {
25986            if (i+1 == obj.rectangleCount)
25987                print_VkRectLayerKHR(obj.pRectangles[i], "pRectangles", 0);
25988            else
25989                print_VkRectLayerKHR(obj.pRectangles[i], "pRectangles", 1);
25990          }
25991          PRINT_SPACE
25992          _OUT << "]" << std::endl;
25993     }
25994      else
25995      {
25996          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
25997      }
25998
25999      INDENT(-4);
26000      PRINT_SPACE
26001      if (commaNeeded)
26002          _OUT << "}," << std::endl;
26003      else
26004          _OUT << "}" << std::endl;
26005 }
26006 static void print_VkPresentRegionKHR(const VkPresentRegionKHR * obj, const std::string& s, bool commaNeeded=true) {
26007      PRINT_SPACE
26008      _OUT << "{" << std::endl;
26009      INDENT(4);
26010
26011      print_uint32_t(obj->rectangleCount, "rectangleCount", 1);
26012
26013      PRINT_SPACE
26014      _OUT << "\"pRectangles\": " << std::endl;
26015      if (obj->pRectangles) {
26016          PRINT_SPACE
26017          _OUT << "[" << std::endl;
26018          for (unsigned int i = 0; i < obj->rectangleCount; i++) {
26019            if (i+1 == obj->rectangleCount)
26020                print_VkRectLayerKHR(obj->pRectangles[i], "pRectangles", 0);
26021            else
26022                print_VkRectLayerKHR(obj->pRectangles[i], "pRectangles", 1);
26023          }
26024          PRINT_SPACE
26025          _OUT << "]" << std::endl;
26026     }
26027      else
26028      {
26029          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
26030      }
26031
26032      INDENT(-4);
26033      PRINT_SPACE
26034      if (commaNeeded)
26035          _OUT << "}," << std::endl;
26036      else
26037          _OUT << "}" << std::endl;
26038 }
26039
26040 static void print_VkPresentRegionsKHR(VkPresentRegionsKHR obj, const std::string& s, bool commaNeeded=true) {
26041      PRINT_SPACE
26042      _OUT << "{" << std::endl;
26043      INDENT(4);
26044
26045      print_VkStructureType(obj.sType, "sType", 1);
26046
26047       if (obj.pNext) {
26048          dumpPNextChain(obj.pNext);
26049       } else {
26050          PRINT_SPACE
26051          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26052      }
26053
26054      print_uint32_t(obj.swapchainCount, "swapchainCount", 1);
26055
26056      PRINT_SPACE
26057      _OUT << "\"pRegions\": " << std::endl;
26058      if (obj.pRegions) {
26059          PRINT_SPACE
26060          _OUT << "[" << std::endl;
26061          for (unsigned int i = 0; i < obj.swapchainCount; i++) {
26062            if (i+1 == obj.swapchainCount)
26063                print_VkPresentRegionKHR(obj.pRegions[i], "pRegions", 0);
26064            else
26065                print_VkPresentRegionKHR(obj.pRegions[i], "pRegions", 1);
26066          }
26067          PRINT_SPACE
26068          _OUT << "]" << std::endl;
26069     }
26070      else
26071      {
26072          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
26073      }
26074
26075      INDENT(-4);
26076      PRINT_SPACE
26077      if (commaNeeded)
26078          _OUT << "}," << std::endl;
26079      else
26080          _OUT << "}" << std::endl;
26081 }
26082 static void print_VkPresentRegionsKHR(const VkPresentRegionsKHR * obj, const std::string& s, bool commaNeeded=true) {
26083      PRINT_SPACE
26084      _OUT << "{" << std::endl;
26085      INDENT(4);
26086
26087      print_VkStructureType(obj->sType, "sType", 1);
26088
26089       if (obj->pNext) {
26090          dumpPNextChain(obj->pNext);
26091       } else {
26092          PRINT_SPACE
26093          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26094      }
26095
26096      print_uint32_t(obj->swapchainCount, "swapchainCount", 1);
26097
26098      PRINT_SPACE
26099      _OUT << "\"pRegions\": " << std::endl;
26100      if (obj->pRegions) {
26101          PRINT_SPACE
26102          _OUT << "[" << std::endl;
26103          for (unsigned int i = 0; i < obj->swapchainCount; i++) {
26104            if (i+1 == obj->swapchainCount)
26105                print_VkPresentRegionKHR(obj->pRegions[i], "pRegions", 0);
26106            else
26107                print_VkPresentRegionKHR(obj->pRegions[i], "pRegions", 1);
26108          }
26109          PRINT_SPACE
26110          _OUT << "]" << std::endl;
26111     }
26112      else
26113      {
26114          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
26115      }
26116
26117      INDENT(-4);
26118      PRINT_SPACE
26119      if (commaNeeded)
26120          _OUT << "}," << std::endl;
26121      else
26122          _OUT << "}" << std::endl;
26123 }
26124
26125 static void print_VkSharedPresentSurfaceCapabilitiesKHR(VkSharedPresentSurfaceCapabilitiesKHR obj, const std::string& s, bool commaNeeded=true) {
26126      PRINT_SPACE
26127      _OUT << "{" << std::endl;
26128      INDENT(4);
26129
26130      print_VkStructureType(obj.sType, "sType", 1);
26131
26132       if (obj.pNext) {
26133          dumpPNextChain(obj.pNext);
26134       } else {
26135          PRINT_SPACE
26136          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26137      }
26138
26139      print_VkImageUsageFlags(obj.sharedPresentSupportedUsageFlags, "sharedPresentSupportedUsageFlags", 0);
26140
26141      INDENT(-4);
26142      PRINT_SPACE
26143      if (commaNeeded)
26144          _OUT << "}," << std::endl;
26145      else
26146          _OUT << "}" << std::endl;
26147 }
26148 static void print_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR * obj, const std::string& s, bool commaNeeded=true) {
26149      PRINT_SPACE
26150      _OUT << "{" << std::endl;
26151      INDENT(4);
26152
26153      print_VkStructureType(obj->sType, "sType", 1);
26154
26155       if (obj->pNext) {
26156          dumpPNextChain(obj->pNext);
26157       } else {
26158          PRINT_SPACE
26159          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26160      }
26161
26162      print_VkImageUsageFlags(obj->sharedPresentSupportedUsageFlags, "sharedPresentSupportedUsageFlags", 0);
26163
26164      INDENT(-4);
26165      PRINT_SPACE
26166      if (commaNeeded)
26167          _OUT << "}," << std::endl;
26168      else
26169          _OUT << "}" << std::endl;
26170 }
26171
26172 static void print_VkImportFenceFdInfoKHR(VkImportFenceFdInfoKHR obj, const std::string& s, bool commaNeeded=true) {
26173      PRINT_SPACE
26174      _OUT << "{" << std::endl;
26175      INDENT(4);
26176
26177      print_VkStructureType(obj.sType, "sType", 1);
26178
26179       if (obj.pNext) {
26180          dumpPNextChain(obj.pNext);
26181       } else {
26182          PRINT_SPACE
26183          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26184      }
26185
26186      // CTS : required value
26187      PRINT_SPACE    _OUT << "\"" << "fence" << "\"" << " : " << "\"" << "\"," << std::endl;
26188
26189      print_VkFenceImportFlags(obj.flags, "flags", 1);
26190
26191      print_VkExternalFenceHandleTypeFlagBits(obj.handleType, "handleType", 1);
26192
26193      print_int(obj.fd, "fd", 0);
26194
26195      INDENT(-4);
26196      PRINT_SPACE
26197      if (commaNeeded)
26198          _OUT << "}," << std::endl;
26199      else
26200          _OUT << "}" << std::endl;
26201 }
26202 static void print_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
26203      PRINT_SPACE
26204      _OUT << "{" << std::endl;
26205      INDENT(4);
26206
26207      print_VkStructureType(obj->sType, "sType", 1);
26208
26209       if (obj->pNext) {
26210          dumpPNextChain(obj->pNext);
26211       } else {
26212          PRINT_SPACE
26213          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26214      }
26215
26216      // CTS : required value
26217      PRINT_SPACE    _OUT << "\"" << "fence" << "\"" << " : " << "\"" << "\"," << std::endl;
26218
26219      print_VkFenceImportFlags(obj->flags, "flags", 1);
26220
26221      print_VkExternalFenceHandleTypeFlagBits(obj->handleType, "handleType", 1);
26222
26223      print_int(obj->fd, "fd", 0);
26224
26225      INDENT(-4);
26226      PRINT_SPACE
26227      if (commaNeeded)
26228          _OUT << "}," << std::endl;
26229      else
26230          _OUT << "}" << std::endl;
26231 }
26232
26233 static void print_VkFenceGetFdInfoKHR(VkFenceGetFdInfoKHR obj, const std::string& s, bool commaNeeded=true) {
26234      PRINT_SPACE
26235      _OUT << "{" << std::endl;
26236      INDENT(4);
26237
26238      print_VkStructureType(obj.sType, "sType", 1);
26239
26240       if (obj.pNext) {
26241          dumpPNextChain(obj.pNext);
26242       } else {
26243          PRINT_SPACE
26244          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26245      }
26246
26247      // CTS : required value
26248      PRINT_SPACE    _OUT << "\"" << "fence" << "\"" << " : " << "\"" << "\"," << std::endl;
26249
26250      print_VkExternalFenceHandleTypeFlagBits(obj.handleType, "handleType", 0);
26251
26252      INDENT(-4);
26253      PRINT_SPACE
26254      if (commaNeeded)
26255          _OUT << "}," << std::endl;
26256      else
26257          _OUT << "}" << std::endl;
26258 }
26259 static void print_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
26260      PRINT_SPACE
26261      _OUT << "{" << std::endl;
26262      INDENT(4);
26263
26264      print_VkStructureType(obj->sType, "sType", 1);
26265
26266       if (obj->pNext) {
26267          dumpPNextChain(obj->pNext);
26268       } else {
26269          PRINT_SPACE
26270          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26271      }
26272
26273      // CTS : required value
26274      PRINT_SPACE    _OUT << "\"" << "fence" << "\"" << " : " << "\"" << "\"," << std::endl;
26275
26276      print_VkExternalFenceHandleTypeFlagBits(obj->handleType, "handleType", 0);
26277
26278      INDENT(-4);
26279      PRINT_SPACE
26280      if (commaNeeded)
26281          _OUT << "}," << std::endl;
26282      else
26283          _OUT << "}" << std::endl;
26284 }
26285
26286 static std::map<deUint64, std::string> VkPerformanceCounterUnitKHR_map = {
26287     std::make_pair(0, "VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR"),
26288     std::make_pair(1, "VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR"),
26289     std::make_pair(2, "VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR"),
26290     std::make_pair(3, "VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR"),
26291     std::make_pair(4, "VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR"),
26292     std::make_pair(5, "VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR"),
26293     std::make_pair(6, "VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR"),
26294     std::make_pair(7, "VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR"),
26295     std::make_pair(8, "VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR"),
26296     std::make_pair(9, "VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR"),
26297     std::make_pair(10, "VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR"),
26298 };
26299 static void print_VkPerformanceCounterUnitKHR(VkPerformanceCounterUnitKHR obj, const std::string& str, bool commaNeeded=true) {
26300      PRINT_SPACE
26301      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26302      if (commaNeeded)
26303          _OUT << "\"" <<  VkPerformanceCounterUnitKHR_map[obj] << "\"," << std::endl;
26304      else
26305          _OUT << "\"" << VkPerformanceCounterUnitKHR_map[obj] << "\"" << std::endl;
26306 }
26307 static void print_VkPerformanceCounterUnitKHR(const VkPerformanceCounterUnitKHR * obj, const std::string& str, bool commaNeeded=true) {
26308      PRINT_SPACE
26309      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26310      if (commaNeeded)
26311          _OUT << "\"" <<  VkPerformanceCounterUnitKHR_map[*obj] << "\"," << std::endl;
26312      else
26313          _OUT << "\"" << VkPerformanceCounterUnitKHR_map[*obj] << "\"" << std::endl;
26314 }
26315
26316 static std::map<deUint64, std::string> VkPerformanceCounterScopeKHR_map = {
26317     std::make_pair(0, "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR"),
26318     std::make_pair(1, "VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR"),
26319     std::make_pair(2, "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR"),
26320 };
26321 static void print_VkPerformanceCounterScopeKHR(VkPerformanceCounterScopeKHR obj, const std::string& str, bool commaNeeded=true) {
26322      PRINT_SPACE
26323      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26324      if (commaNeeded)
26325          _OUT << "\"" <<  VkPerformanceCounterScopeKHR_map[obj] << "\"," << std::endl;
26326      else
26327          _OUT << "\"" << VkPerformanceCounterScopeKHR_map[obj] << "\"" << std::endl;
26328 }
26329 static void print_VkPerformanceCounterScopeKHR(const VkPerformanceCounterScopeKHR * obj, const std::string& str, bool commaNeeded=true) {
26330      PRINT_SPACE
26331      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26332      if (commaNeeded)
26333          _OUT << "\"" <<  VkPerformanceCounterScopeKHR_map[*obj] << "\"," << std::endl;
26334      else
26335          _OUT << "\"" << VkPerformanceCounterScopeKHR_map[*obj] << "\"" << std::endl;
26336 }
26337
26338 static std::map<deUint64, std::string> VkPerformanceCounterStorageKHR_map = {
26339     std::make_pair(0, "VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR"),
26340     std::make_pair(1, "VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR"),
26341     std::make_pair(2, "VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR"),
26342     std::make_pair(3, "VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR"),
26343     std::make_pair(4, "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR"),
26344     std::make_pair(5, "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR"),
26345 };
26346 static void print_VkPerformanceCounterStorageKHR(VkPerformanceCounterStorageKHR obj, const std::string& str, bool commaNeeded=true) {
26347      PRINT_SPACE
26348      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26349      if (commaNeeded)
26350          _OUT << "\"" <<  VkPerformanceCounterStorageKHR_map[obj] << "\"," << std::endl;
26351      else
26352          _OUT << "\"" << VkPerformanceCounterStorageKHR_map[obj] << "\"" << std::endl;
26353 }
26354 static void print_VkPerformanceCounterStorageKHR(const VkPerformanceCounterStorageKHR * obj, const std::string& str, bool commaNeeded=true) {
26355      PRINT_SPACE
26356      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26357      if (commaNeeded)
26358          _OUT << "\"" <<  VkPerformanceCounterStorageKHR_map[*obj] << "\"," << std::endl;
26359      else
26360          _OUT << "\"" << VkPerformanceCounterStorageKHR_map[*obj] << "\"" << std::endl;
26361 }
26362
26363 static std::map<deUint64, std::string> VkPerformanceCounterDescriptionFlagBitsKHR_map = {
26364     std::make_pair(1ULL << 0, "VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR"),
26365     std::make_pair(1ULL << 1, "VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR"),
26366 };
26367 static void print_VkPerformanceCounterDescriptionFlagBitsKHR(VkPerformanceCounterDescriptionFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) {
26368      PRINT_SPACE
26369      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26370      if (commaNeeded)
26371          _OUT << "\"" <<  VkPerformanceCounterDescriptionFlagBitsKHR_map[obj] << "\"," << std::endl;
26372      else
26373          _OUT << "\"" << VkPerformanceCounterDescriptionFlagBitsKHR_map[obj] << "\"" << std::endl;
26374 }
26375 static void print_VkPerformanceCounterDescriptionFlagBitsKHR(const VkPerformanceCounterDescriptionFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) {
26376      PRINT_SPACE
26377      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26378      if (commaNeeded)
26379          _OUT << "\"" <<  VkPerformanceCounterDescriptionFlagBitsKHR_map[*obj] << "\"," << std::endl;
26380      else
26381          _OUT << "\"" << VkPerformanceCounterDescriptionFlagBitsKHR_map[*obj] << "\"" << std::endl;
26382 }
26383
26384 static std::map<deUint64, std::string> VkAcquireProfilingLockFlagBitsKHR_map = {
26385 };
26386 static void print_VkAcquireProfilingLockFlagBitsKHR(VkAcquireProfilingLockFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) {
26387      PRINT_SPACE
26388      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26389      if (commaNeeded)
26390          _OUT << "\"" <<  VkAcquireProfilingLockFlagBitsKHR_map[obj] << "\"," << std::endl;
26391      else
26392          _OUT << "\"" << VkAcquireProfilingLockFlagBitsKHR_map[obj] << "\"" << std::endl;
26393 }
26394 static void print_VkAcquireProfilingLockFlagBitsKHR(const VkAcquireProfilingLockFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) {
26395      PRINT_SPACE
26396      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26397      if (commaNeeded)
26398          _OUT << "\"" <<  VkAcquireProfilingLockFlagBitsKHR_map[*obj] << "\"," << std::endl;
26399      else
26400          _OUT << "\"" << VkAcquireProfilingLockFlagBitsKHR_map[*obj] << "\"" << std::endl;
26401 }
26402
26403 static void print_VkPerformanceCounterDescriptionFlagsKHR(VkPerformanceCounterDescriptionFlagsKHR obj, const std::string& str, bool commaNeeded=true) {
26404      PRINT_SPACE
26405      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26406      const int max_bits = 64; // We don't expect the number to be larger.
26407      std::bitset<max_bits> b(obj);
26408      _OUT << "\"";
26409      if (obj == 0) _OUT << "0";
26410      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
26411          if (b[i] == 1) {
26412              bitCount++;
26413              if (bitCount < b.count())
26414                  _OUT << VkPerformanceCounterDescriptionFlagBitsKHR_map[1ULL<<i] << " | ";
26415              else
26416                  _OUT << VkPerformanceCounterDescriptionFlagBitsKHR_map[1ULL<<i];
26417          }
26418      }
26419      if (commaNeeded)
26420        _OUT << "\"" << ",";
26421      else
26422        _OUT << "\""<< "";
26423      _OUT << std::endl;
26424 }
26425 static void print_VkPerformanceCounterDescriptionFlagsKHR(const VkPerformanceCounterDescriptionFlagsKHR * obj, const std::string& str, bool commaNeeded=true) {
26426      PRINT_SPACE
26427      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26428      const int max_bits = 64; // We don't expect the number to be larger.
26429      std::bitset<max_bits> b(obj);
26430      _OUT << "\"";
26431      if (obj == 0) _OUT << "0";
26432      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
26433          if (b[i] == 1) {
26434              bitCount++;
26435              if (bitCount < b.count())
26436                  _OUT << VkPerformanceCounterDescriptionFlagBitsKHR_map[1ULL<<i] << " | ";
26437              else
26438                  _OUT << VkPerformanceCounterDescriptionFlagBitsKHR_map[1ULL<<i];
26439          }
26440      }
26441      if (commaNeeded)
26442        _OUT << "\"" << ",";
26443      else
26444        _OUT << "\""<< "";
26445      _OUT << std::endl;
26446 }
26447
26448 static void print_VkAcquireProfilingLockFlagsKHR(VkAcquireProfilingLockFlagsKHR obj, const std::string& str, bool commaNeeded=true) {
26449      PRINT_SPACE
26450      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26451      const int max_bits = 64; // We don't expect the number to be larger.
26452      std::bitset<max_bits> b(obj);
26453      _OUT << "\"";
26454      if (obj == 0) _OUT << "0";
26455      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
26456          if (b[i] == 1) {
26457              bitCount++;
26458              if (bitCount < b.count())
26459                  _OUT << VkAcquireProfilingLockFlagBitsKHR_map[1ULL<<i] << " | ";
26460              else
26461                  _OUT << VkAcquireProfilingLockFlagBitsKHR_map[1ULL<<i];
26462          }
26463      }
26464      if (commaNeeded)
26465        _OUT << "\"" << ",";
26466      else
26467        _OUT << "\""<< "";
26468      _OUT << std::endl;
26469 }
26470 static void print_VkAcquireProfilingLockFlagsKHR(const VkAcquireProfilingLockFlagsKHR * obj, const std::string& str, bool commaNeeded=true) {
26471      PRINT_SPACE
26472      if (str != "") _OUT << "\"" << str << "\"" << " : ";
26473      const int max_bits = 64; // We don't expect the number to be larger.
26474      std::bitset<max_bits> b(obj);
26475      _OUT << "\"";
26476      if (obj == 0) _OUT << "0";
26477      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
26478          if (b[i] == 1) {
26479              bitCount++;
26480              if (bitCount < b.count())
26481                  _OUT << VkAcquireProfilingLockFlagBitsKHR_map[1ULL<<i] << " | ";
26482              else
26483                  _OUT << VkAcquireProfilingLockFlagBitsKHR_map[1ULL<<i];
26484          }
26485      }
26486      if (commaNeeded)
26487        _OUT << "\"" << ",";
26488      else
26489        _OUT << "\""<< "";
26490      _OUT << std::endl;
26491 }
26492
26493 static void print_VkPhysicalDevicePerformanceQueryFeaturesKHR(VkPhysicalDevicePerformanceQueryFeaturesKHR obj, const std::string& s, bool commaNeeded=true) {
26494      PRINT_SPACE
26495      _OUT << "{" << std::endl;
26496      INDENT(4);
26497
26498      print_VkStructureType(obj.sType, "sType", 1);
26499
26500       if (obj.pNext) {
26501          dumpPNextChain(obj.pNext);
26502       } else {
26503          PRINT_SPACE
26504          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26505      }
26506
26507      print_VkBool32(obj.performanceCounterQueryPools, "performanceCounterQueryPools", 1);
26508
26509      print_VkBool32(obj.performanceCounterMultipleQueryPools, "performanceCounterMultipleQueryPools", 0);
26510
26511      INDENT(-4);
26512      PRINT_SPACE
26513      if (commaNeeded)
26514          _OUT << "}," << std::endl;
26515      else
26516          _OUT << "}" << std::endl;
26517 }
26518 static void print_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR * obj, const std::string& s, bool commaNeeded=true) {
26519      PRINT_SPACE
26520      _OUT << "{" << std::endl;
26521      INDENT(4);
26522
26523      print_VkStructureType(obj->sType, "sType", 1);
26524
26525       if (obj->pNext) {
26526          dumpPNextChain(obj->pNext);
26527       } else {
26528          PRINT_SPACE
26529          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26530      }
26531
26532      print_VkBool32(obj->performanceCounterQueryPools, "performanceCounterQueryPools", 1);
26533
26534      print_VkBool32(obj->performanceCounterMultipleQueryPools, "performanceCounterMultipleQueryPools", 0);
26535
26536      INDENT(-4);
26537      PRINT_SPACE
26538      if (commaNeeded)
26539          _OUT << "}," << std::endl;
26540      else
26541          _OUT << "}" << std::endl;
26542 }
26543
26544 static void print_VkPhysicalDevicePerformanceQueryPropertiesKHR(VkPhysicalDevicePerformanceQueryPropertiesKHR obj, const std::string& s, bool commaNeeded=true) {
26545      PRINT_SPACE
26546      _OUT << "{" << std::endl;
26547      INDENT(4);
26548
26549      print_VkStructureType(obj.sType, "sType", 1);
26550
26551       if (obj.pNext) {
26552          dumpPNextChain(obj.pNext);
26553       } else {
26554          PRINT_SPACE
26555          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26556      }
26557
26558      print_VkBool32(obj.allowCommandBufferQueryCopies, "allowCommandBufferQueryCopies", 0);
26559
26560      INDENT(-4);
26561      PRINT_SPACE
26562      if (commaNeeded)
26563          _OUT << "}," << std::endl;
26564      else
26565          _OUT << "}" << std::endl;
26566 }
26567 static void print_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR * obj, const std::string& s, bool commaNeeded=true) {
26568      PRINT_SPACE
26569      _OUT << "{" << std::endl;
26570      INDENT(4);
26571
26572      print_VkStructureType(obj->sType, "sType", 1);
26573
26574       if (obj->pNext) {
26575          dumpPNextChain(obj->pNext);
26576       } else {
26577          PRINT_SPACE
26578          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26579      }
26580
26581      print_VkBool32(obj->allowCommandBufferQueryCopies, "allowCommandBufferQueryCopies", 0);
26582
26583      INDENT(-4);
26584      PRINT_SPACE
26585      if (commaNeeded)
26586          _OUT << "}," << std::endl;
26587      else
26588          _OUT << "}" << std::endl;
26589 }
26590
26591 static void print_VkPerformanceCounterKHR(VkPerformanceCounterKHR obj, const std::string& s, bool commaNeeded=true) {
26592      PRINT_SPACE
26593      _OUT << "{" << std::endl;
26594      INDENT(4);
26595
26596      print_VkStructureType(obj.sType, "sType", 1);
26597
26598       if (obj.pNext) {
26599          dumpPNextChain(obj.pNext);
26600       } else {
26601          PRINT_SPACE
26602          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26603      }
26604
26605      print_VkPerformanceCounterUnitKHR(obj.unit, "unit", 1);
26606
26607      print_VkPerformanceCounterScopeKHR(obj.scope, "scope", 1);
26608
26609      print_VkPerformanceCounterStorageKHR(obj.storage, "storage", 1);
26610
26611      PRINT_SPACE
26612      _OUT << "\"uuid\":" << std::endl;
26613      PRINT_SPACE
26614      if (obj.uuid) {
26615        _OUT << "[" << std::endl;
26616        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
26617            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
26618            print_uint8_t(obj.uuid[i], "", isCommaNeeded);
26619        }
26620        PRINT_SPACE
26621        _OUT << "]" << "" << std::endl;
26622      } else {
26623        _OUT << "\"NULL\"" << "" << std::endl;
26624      }
26625
26626      INDENT(-4);
26627      PRINT_SPACE
26628      if (commaNeeded)
26629          _OUT << "}," << std::endl;
26630      else
26631          _OUT << "}" << std::endl;
26632 }
26633 static void print_VkPerformanceCounterKHR(const VkPerformanceCounterKHR * obj, const std::string& s, bool commaNeeded=true) {
26634      PRINT_SPACE
26635      _OUT << "{" << std::endl;
26636      INDENT(4);
26637
26638      print_VkStructureType(obj->sType, "sType", 1);
26639
26640       if (obj->pNext) {
26641          dumpPNextChain(obj->pNext);
26642       } else {
26643          PRINT_SPACE
26644          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26645      }
26646
26647      print_VkPerformanceCounterUnitKHR(obj->unit, "unit", 1);
26648
26649      print_VkPerformanceCounterScopeKHR(obj->scope, "scope", 1);
26650
26651      print_VkPerformanceCounterStorageKHR(obj->storage, "storage", 1);
26652
26653      PRINT_SPACE
26654      _OUT << "\"uuid\":" << std::endl;
26655      PRINT_SPACE
26656      if (obj->uuid) {
26657        _OUT << "[" << std::endl;
26658        for (unsigned int i = 0; i < VK_UUID_SIZE; i++) {
26659            bool isCommaNeeded = (i+1) != VK_UUID_SIZE;
26660            print_uint8_t(obj->uuid[i], "", isCommaNeeded);
26661        }
26662        PRINT_SPACE
26663        _OUT << "]" << "" << std::endl;
26664      } else {
26665        _OUT << "\"NULL\"" << "" << std::endl;
26666      }
26667
26668      INDENT(-4);
26669      PRINT_SPACE
26670      if (commaNeeded)
26671          _OUT << "}," << std::endl;
26672      else
26673          _OUT << "}" << std::endl;
26674 }
26675
26676 static void print_VkPerformanceCounterDescriptionKHR(VkPerformanceCounterDescriptionKHR obj, const std::string& s, bool commaNeeded=true) {
26677      PRINT_SPACE
26678      _OUT << "{" << std::endl;
26679      INDENT(4);
26680
26681      print_VkStructureType(obj.sType, "sType", 1);
26682
26683       if (obj.pNext) {
26684          dumpPNextChain(obj.pNext);
26685       } else {
26686          PRINT_SPACE
26687          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26688      }
26689
26690      print_VkPerformanceCounterDescriptionFlagsKHR(obj.flags, "flags", 1);
26691
26692      PRINT_SPACE
26693      _OUT << "\"name\":" << std::endl;
26694      PRINT_SPACE
26695      if (obj.name) {
26696        _OUT << "[" << std::endl;
26697        for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) {
26698            bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE;
26699            print_char(obj.name[i], "", isCommaNeeded);
26700        }
26701        PRINT_SPACE
26702        _OUT << "]" << "," << std::endl;
26703      } else {
26704        _OUT << "\"NULL\"" << "," << std::endl;
26705      }
26706
26707      PRINT_SPACE
26708      _OUT << "\"category\":" << std::endl;
26709      PRINT_SPACE
26710      if (obj.category) {
26711        _OUT << "[" << std::endl;
26712        for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) {
26713            bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE;
26714            print_char(obj.category[i], "", isCommaNeeded);
26715        }
26716        PRINT_SPACE
26717        _OUT << "]" << "," << std::endl;
26718      } else {
26719        _OUT << "\"NULL\"" << "," << std::endl;
26720      }
26721
26722      PRINT_SPACE
26723      _OUT << "\"description\":" << std::endl;
26724      PRINT_SPACE
26725      if (obj.description) {
26726        _OUT << "[" << std::endl;
26727        for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) {
26728            bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE;
26729            print_char(obj.description[i], "", isCommaNeeded);
26730        }
26731        PRINT_SPACE
26732        _OUT << "]" << "" << std::endl;
26733      } else {
26734        _OUT << "\"NULL\"" << "" << std::endl;
26735      }
26736
26737      INDENT(-4);
26738      PRINT_SPACE
26739      if (commaNeeded)
26740          _OUT << "}," << std::endl;
26741      else
26742          _OUT << "}" << std::endl;
26743 }
26744 static void print_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR * obj, const std::string& s, bool commaNeeded=true) {
26745      PRINT_SPACE
26746      _OUT << "{" << std::endl;
26747      INDENT(4);
26748
26749      print_VkStructureType(obj->sType, "sType", 1);
26750
26751       if (obj->pNext) {
26752          dumpPNextChain(obj->pNext);
26753       } else {
26754          PRINT_SPACE
26755          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26756      }
26757
26758      print_VkPerformanceCounterDescriptionFlagsKHR(obj->flags, "flags", 1);
26759
26760      PRINT_SPACE
26761      _OUT << "\"name\":" << std::endl;
26762      PRINT_SPACE
26763      if (obj->name) {
26764        _OUT << "[" << std::endl;
26765        for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) {
26766            bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE;
26767            print_char(obj->name[i], "", isCommaNeeded);
26768        }
26769        PRINT_SPACE
26770        _OUT << "]" << "," << std::endl;
26771      } else {
26772        _OUT << "\"NULL\"" << "," << std::endl;
26773      }
26774
26775      PRINT_SPACE
26776      _OUT << "\"category\":" << std::endl;
26777      PRINT_SPACE
26778      if (obj->category) {
26779        _OUT << "[" << std::endl;
26780        for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) {
26781            bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE;
26782            print_char(obj->category[i], "", isCommaNeeded);
26783        }
26784        PRINT_SPACE
26785        _OUT << "]" << "," << std::endl;
26786      } else {
26787        _OUT << "\"NULL\"" << "," << std::endl;
26788      }
26789
26790      PRINT_SPACE
26791      _OUT << "\"description\":" << std::endl;
26792      PRINT_SPACE
26793      if (obj->description) {
26794        _OUT << "[" << std::endl;
26795        for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) {
26796            bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE;
26797            print_char(obj->description[i], "", isCommaNeeded);
26798        }
26799        PRINT_SPACE
26800        _OUT << "]" << "" << std::endl;
26801      } else {
26802        _OUT << "\"NULL\"" << "" << std::endl;
26803      }
26804
26805      INDENT(-4);
26806      PRINT_SPACE
26807      if (commaNeeded)
26808          _OUT << "}," << std::endl;
26809      else
26810          _OUT << "}" << std::endl;
26811 }
26812
26813 static void print_VkQueryPoolPerformanceCreateInfoKHR(VkQueryPoolPerformanceCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) {
26814      PRINT_SPACE
26815      _OUT << "{" << std::endl;
26816      INDENT(4);
26817
26818      print_VkStructureType(obj.sType, "sType", 1);
26819
26820       if (obj.pNext) {
26821          dumpPNextChain(obj.pNext);
26822       } else {
26823          PRINT_SPACE
26824          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26825      }
26826
26827      print_uint32_t(obj.queueFamilyIndex, "queueFamilyIndex", 1);
26828
26829      print_uint32_t(obj.counterIndexCount, "counterIndexCount", 1);
26830
26831      PRINT_SPACE
26832      _OUT << "\"pCounterIndices\":" << std::endl;
26833      PRINT_SPACE
26834      if (obj.pCounterIndices) {
26835        _OUT << "[" << std::endl;
26836        for (unsigned int i = 0; i < obj.counterIndexCount; i++) {
26837            bool isCommaNeeded = (i+1) != obj.counterIndexCount;
26838            print_uint32_t(obj.pCounterIndices[i], "", isCommaNeeded);
26839        }
26840        PRINT_SPACE
26841        _OUT << "]" << "" << std::endl;
26842      } else {
26843        _OUT << "\"NULL\"" << "" << std::endl;
26844      }
26845
26846      INDENT(-4);
26847      PRINT_SPACE
26848      if (commaNeeded)
26849          _OUT << "}," << std::endl;
26850      else
26851          _OUT << "}" << std::endl;
26852 }
26853 static void print_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
26854      PRINT_SPACE
26855      _OUT << "{" << std::endl;
26856      INDENT(4);
26857
26858      print_VkStructureType(obj->sType, "sType", 1);
26859
26860       if (obj->pNext) {
26861          dumpPNextChain(obj->pNext);
26862       } else {
26863          PRINT_SPACE
26864          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26865      }
26866
26867      print_uint32_t(obj->queueFamilyIndex, "queueFamilyIndex", 1);
26868
26869      print_uint32_t(obj->counterIndexCount, "counterIndexCount", 1);
26870
26871      PRINT_SPACE
26872      _OUT << "\"pCounterIndices\":" << std::endl;
26873      PRINT_SPACE
26874      if (obj->pCounterIndices) {
26875        _OUT << "[" << std::endl;
26876        for (unsigned int i = 0; i < obj->counterIndexCount; i++) {
26877            bool isCommaNeeded = (i+1) != obj->counterIndexCount;
26878            print_uint32_t(obj->pCounterIndices[i], "", isCommaNeeded);
26879        }
26880        PRINT_SPACE
26881        _OUT << "]" << "" << std::endl;
26882      } else {
26883        _OUT << "\"NULL\"" << "" << std::endl;
26884      }
26885
26886      INDENT(-4);
26887      PRINT_SPACE
26888      if (commaNeeded)
26889          _OUT << "}," << std::endl;
26890      else
26891          _OUT << "}" << std::endl;
26892 }
26893
26894 static void print_VkPerformanceCounterResultKHR(VkPerformanceCounterResultKHR obj, const std::string& s, bool commaNeeded=true) {
26895      PRINT_SPACE
26896      _OUT << "{" << std::endl;
26897      INDENT(4);
26898
26899      print_int32_t(obj.int32, "int32", 1);
26900
26901      print_int64_t(obj.int64, "int64", 1);
26902
26903      print_uint32_t(obj.uint32, "uint32", 1);
26904
26905      print_uint64_t(obj.uint64, "uint64", 1);
26906
26907      print_float(obj.float32, "float32", 1);
26908
26909      print_double(obj.float64, "float64", 0);
26910
26911      INDENT(-4);
26912      PRINT_SPACE
26913      if (commaNeeded)
26914          _OUT << "}," << std::endl;
26915      else
26916          _OUT << "}" << std::endl;
26917 }
26918 static void print_VkPerformanceCounterResultKHR(const VkPerformanceCounterResultKHR * obj, const std::string& s, bool commaNeeded=true) {
26919      PRINT_SPACE
26920      _OUT << "{" << std::endl;
26921      INDENT(4);
26922
26923      print_int32_t(obj->int32, "int32", 1);
26924
26925      print_int64_t(obj->int64, "int64", 1);
26926
26927      print_uint32_t(obj->uint32, "uint32", 1);
26928
26929      print_uint64_t(obj->uint64, "uint64", 1);
26930
26931      print_float(obj->float32, "float32", 1);
26932
26933      print_double(obj->float64, "float64", 0);
26934
26935      INDENT(-4);
26936      PRINT_SPACE
26937      if (commaNeeded)
26938          _OUT << "}," << std::endl;
26939      else
26940          _OUT << "}" << std::endl;
26941 }
26942
26943 static void print_VkAcquireProfilingLockInfoKHR(VkAcquireProfilingLockInfoKHR obj, const std::string& s, bool commaNeeded=true) {
26944      PRINT_SPACE
26945      _OUT << "{" << std::endl;
26946      INDENT(4);
26947
26948      print_VkStructureType(obj.sType, "sType", 1);
26949
26950       if (obj.pNext) {
26951          dumpPNextChain(obj.pNext);
26952       } else {
26953          PRINT_SPACE
26954          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26955      }
26956
26957      print_VkAcquireProfilingLockFlagsKHR(obj.flags, "flags", 1);
26958
26959      print_uint64_t(obj.timeout, "timeout", 0);
26960
26961      INDENT(-4);
26962      PRINT_SPACE
26963      if (commaNeeded)
26964          _OUT << "}," << std::endl;
26965      else
26966          _OUT << "}" << std::endl;
26967 }
26968 static void print_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
26969      PRINT_SPACE
26970      _OUT << "{" << std::endl;
26971      INDENT(4);
26972
26973      print_VkStructureType(obj->sType, "sType", 1);
26974
26975       if (obj->pNext) {
26976          dumpPNextChain(obj->pNext);
26977       } else {
26978          PRINT_SPACE
26979          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
26980      }
26981
26982      print_VkAcquireProfilingLockFlagsKHR(obj->flags, "flags", 1);
26983
26984      print_uint64_t(obj->timeout, "timeout", 0);
26985
26986      INDENT(-4);
26987      PRINT_SPACE
26988      if (commaNeeded)
26989          _OUT << "}," << std::endl;
26990      else
26991          _OUT << "}" << std::endl;
26992 }
26993
26994 static void print_VkPerformanceQuerySubmitInfoKHR(VkPerformanceQuerySubmitInfoKHR obj, const std::string& s, bool commaNeeded=true) {
26995      PRINT_SPACE
26996      _OUT << "{" << std::endl;
26997      INDENT(4);
26998
26999      print_VkStructureType(obj.sType, "sType", 1);
27000
27001       if (obj.pNext) {
27002          dumpPNextChain(obj.pNext);
27003       } else {
27004          PRINT_SPACE
27005          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27006      }
27007
27008      print_uint32_t(obj.counterPassIndex, "counterPassIndex", 0);
27009
27010      INDENT(-4);
27011      PRINT_SPACE
27012      if (commaNeeded)
27013          _OUT << "}," << std::endl;
27014      else
27015          _OUT << "}" << std::endl;
27016 }
27017 static void print_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
27018      PRINT_SPACE
27019      _OUT << "{" << std::endl;
27020      INDENT(4);
27021
27022      print_VkStructureType(obj->sType, "sType", 1);
27023
27024       if (obj->pNext) {
27025          dumpPNextChain(obj->pNext);
27026       } else {
27027          PRINT_SPACE
27028          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27029      }
27030
27031      print_uint32_t(obj->counterPassIndex, "counterPassIndex", 0);
27032
27033      INDENT(-4);
27034      PRINT_SPACE
27035      if (commaNeeded)
27036          _OUT << "}," << std::endl;
27037      else
27038          _OUT << "}" << std::endl;
27039 }
27040
27041 static void print_VkPerformanceQueryReservationInfoKHR(VkPerformanceQueryReservationInfoKHR obj, const std::string& s, bool commaNeeded=true) {
27042      PRINT_SPACE
27043      _OUT << "{" << std::endl;
27044      INDENT(4);
27045
27046      print_VkStructureType(obj.sType, "sType", 1);
27047
27048       if (obj.pNext) {
27049          dumpPNextChain(obj.pNext);
27050       } else {
27051          PRINT_SPACE
27052          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27053      }
27054
27055      print_uint32_t(obj.maxPerformanceQueriesPerPool, "maxPerformanceQueriesPerPool", 0);
27056
27057      INDENT(-4);
27058      PRINT_SPACE
27059      if (commaNeeded)
27060          _OUT << "}," << std::endl;
27061      else
27062          _OUT << "}" << std::endl;
27063 }
27064 static void print_VkPerformanceQueryReservationInfoKHR(const VkPerformanceQueryReservationInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
27065      PRINT_SPACE
27066      _OUT << "{" << std::endl;
27067      INDENT(4);
27068
27069      print_VkStructureType(obj->sType, "sType", 1);
27070
27071       if (obj->pNext) {
27072          dumpPNextChain(obj->pNext);
27073       } else {
27074          PRINT_SPACE
27075          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27076      }
27077
27078      print_uint32_t(obj->maxPerformanceQueriesPerPool, "maxPerformanceQueriesPerPool", 0);
27079
27080      INDENT(-4);
27081      PRINT_SPACE
27082      if (commaNeeded)
27083          _OUT << "}," << std::endl;
27084      else
27085          _OUT << "}" << std::endl;
27086 }
27087
27088 static void print_VkPhysicalDeviceSurfaceInfo2KHR(VkPhysicalDeviceSurfaceInfo2KHR obj, const std::string& s, bool commaNeeded=true) {
27089      PRINT_SPACE
27090      _OUT << "{" << std::endl;
27091      INDENT(4);
27092
27093      print_VkStructureType(obj.sType, "sType", 1);
27094
27095       if (obj.pNext) {
27096          dumpPNextChain(obj.pNext);
27097       } else {
27098          PRINT_SPACE
27099          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27100      }
27101
27102      // CTS : required value
27103      PRINT_SPACE    _OUT << "\"" << "surface" << "\"" << " : " << "\"" << "\"" << std::endl;
27104
27105      INDENT(-4);
27106      PRINT_SPACE
27107      if (commaNeeded)
27108          _OUT << "}," << std::endl;
27109      else
27110          _OUT << "}" << std::endl;
27111 }
27112 static void print_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR * obj, const std::string& s, bool commaNeeded=true) {
27113      PRINT_SPACE
27114      _OUT << "{" << std::endl;
27115      INDENT(4);
27116
27117      print_VkStructureType(obj->sType, "sType", 1);
27118
27119       if (obj->pNext) {
27120          dumpPNextChain(obj->pNext);
27121       } else {
27122          PRINT_SPACE
27123          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27124      }
27125
27126      // CTS : required value
27127      PRINT_SPACE    _OUT << "\"" << "surface" << "\"" << " : " << "\"" << "\"" << std::endl;
27128
27129      INDENT(-4);
27130      PRINT_SPACE
27131      if (commaNeeded)
27132          _OUT << "}," << std::endl;
27133      else
27134          _OUT << "}" << std::endl;
27135 }
27136
27137 static void print_VkSurfaceCapabilities2KHR(VkSurfaceCapabilities2KHR obj, const std::string& s, bool commaNeeded=true) {
27138      PRINT_SPACE
27139      _OUT << "{" << std::endl;
27140      INDENT(4);
27141
27142      print_VkStructureType(obj.sType, "sType", 1);
27143
27144       if (obj.pNext) {
27145          dumpPNextChain(obj.pNext);
27146       } else {
27147          PRINT_SPACE
27148          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27149      }
27150
27151      PRINT_SPACE
27152      _OUT << "\"surfaceCapabilities\": " << std::endl;
27153      {
27154            print_VkSurfaceCapabilitiesKHR(obj.surfaceCapabilities, "surfaceCapabilities", 0);
27155      }
27156
27157      INDENT(-4);
27158      PRINT_SPACE
27159      if (commaNeeded)
27160          _OUT << "}," << std::endl;
27161      else
27162          _OUT << "}" << std::endl;
27163 }
27164 static void print_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR * obj, const std::string& s, bool commaNeeded=true) {
27165      PRINT_SPACE
27166      _OUT << "{" << std::endl;
27167      INDENT(4);
27168
27169      print_VkStructureType(obj->sType, "sType", 1);
27170
27171       if (obj->pNext) {
27172          dumpPNextChain(obj->pNext);
27173       } else {
27174          PRINT_SPACE
27175          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27176      }
27177
27178      PRINT_SPACE
27179      _OUT << "\"surfaceCapabilities\": " << std::endl;
27180      {
27181            print_VkSurfaceCapabilitiesKHR(obj->surfaceCapabilities, "surfaceCapabilities", 0);
27182      }
27183
27184      INDENT(-4);
27185      PRINT_SPACE
27186      if (commaNeeded)
27187          _OUT << "}," << std::endl;
27188      else
27189          _OUT << "}" << std::endl;
27190 }
27191
27192 static void print_VkSurfaceFormat2KHR(VkSurfaceFormat2KHR obj, const std::string& s, bool commaNeeded=true) {
27193      PRINT_SPACE
27194      _OUT << "{" << std::endl;
27195      INDENT(4);
27196
27197      print_VkStructureType(obj.sType, "sType", 1);
27198
27199       if (obj.pNext) {
27200          dumpPNextChain(obj.pNext);
27201       } else {
27202          PRINT_SPACE
27203          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27204      }
27205
27206      PRINT_SPACE
27207      _OUT << "\"surfaceFormat\": " << std::endl;
27208      {
27209            print_VkSurfaceFormatKHR(obj.surfaceFormat, "surfaceFormat", 0);
27210      }
27211
27212      INDENT(-4);
27213      PRINT_SPACE
27214      if (commaNeeded)
27215          _OUT << "}," << std::endl;
27216      else
27217          _OUT << "}" << std::endl;
27218 }
27219 static void print_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR * obj, const std::string& s, bool commaNeeded=true) {
27220      PRINT_SPACE
27221      _OUT << "{" << std::endl;
27222      INDENT(4);
27223
27224      print_VkStructureType(obj->sType, "sType", 1);
27225
27226       if (obj->pNext) {
27227          dumpPNextChain(obj->pNext);
27228       } else {
27229          PRINT_SPACE
27230          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27231      }
27232
27233      PRINT_SPACE
27234      _OUT << "\"surfaceFormat\": " << std::endl;
27235      {
27236            print_VkSurfaceFormatKHR(obj->surfaceFormat, "surfaceFormat", 0);
27237      }
27238
27239      INDENT(-4);
27240      PRINT_SPACE
27241      if (commaNeeded)
27242          _OUT << "}," << std::endl;
27243      else
27244          _OUT << "}" << std::endl;
27245 }
27246
27247 static void print_VkDisplayProperties2KHR(VkDisplayProperties2KHR obj, const std::string& s, bool commaNeeded=true) {
27248      PRINT_SPACE
27249      _OUT << "{" << std::endl;
27250      INDENT(4);
27251
27252      print_VkStructureType(obj.sType, "sType", 1);
27253
27254       if (obj.pNext) {
27255          dumpPNextChain(obj.pNext);
27256       } else {
27257          PRINT_SPACE
27258          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27259      }
27260
27261      PRINT_SPACE
27262      _OUT << "\"displayProperties\": " << std::endl;
27263      {
27264            print_VkDisplayPropertiesKHR(obj.displayProperties, "displayProperties", 0);
27265      }
27266
27267      INDENT(-4);
27268      PRINT_SPACE
27269      if (commaNeeded)
27270          _OUT << "}," << std::endl;
27271      else
27272          _OUT << "}" << std::endl;
27273 }
27274 static void print_VkDisplayProperties2KHR(const VkDisplayProperties2KHR * obj, const std::string& s, bool commaNeeded=true) {
27275      PRINT_SPACE
27276      _OUT << "{" << std::endl;
27277      INDENT(4);
27278
27279      print_VkStructureType(obj->sType, "sType", 1);
27280
27281       if (obj->pNext) {
27282          dumpPNextChain(obj->pNext);
27283       } else {
27284          PRINT_SPACE
27285          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27286      }
27287
27288      PRINT_SPACE
27289      _OUT << "\"displayProperties\": " << std::endl;
27290      {
27291            print_VkDisplayPropertiesKHR(obj->displayProperties, "displayProperties", 0);
27292      }
27293
27294      INDENT(-4);
27295      PRINT_SPACE
27296      if (commaNeeded)
27297          _OUT << "}," << std::endl;
27298      else
27299          _OUT << "}" << std::endl;
27300 }
27301
27302 static void print_VkDisplayPlaneProperties2KHR(VkDisplayPlaneProperties2KHR obj, const std::string& s, bool commaNeeded=true) {
27303      PRINT_SPACE
27304      _OUT << "{" << std::endl;
27305      INDENT(4);
27306
27307      print_VkStructureType(obj.sType, "sType", 1);
27308
27309       if (obj.pNext) {
27310          dumpPNextChain(obj.pNext);
27311       } else {
27312          PRINT_SPACE
27313          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27314      }
27315
27316      PRINT_SPACE
27317      _OUT << "\"displayPlaneProperties\": " << std::endl;
27318      {
27319            print_VkDisplayPlanePropertiesKHR(obj.displayPlaneProperties, "displayPlaneProperties", 0);
27320      }
27321
27322      INDENT(-4);
27323      PRINT_SPACE
27324      if (commaNeeded)
27325          _OUT << "}," << std::endl;
27326      else
27327          _OUT << "}" << std::endl;
27328 }
27329 static void print_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR * obj, const std::string& s, bool commaNeeded=true) {
27330      PRINT_SPACE
27331      _OUT << "{" << std::endl;
27332      INDENT(4);
27333
27334      print_VkStructureType(obj->sType, "sType", 1);
27335
27336       if (obj->pNext) {
27337          dumpPNextChain(obj->pNext);
27338       } else {
27339          PRINT_SPACE
27340          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27341      }
27342
27343      PRINT_SPACE
27344      _OUT << "\"displayPlaneProperties\": " << std::endl;
27345      {
27346            print_VkDisplayPlanePropertiesKHR(obj->displayPlaneProperties, "displayPlaneProperties", 0);
27347      }
27348
27349      INDENT(-4);
27350      PRINT_SPACE
27351      if (commaNeeded)
27352          _OUT << "}," << std::endl;
27353      else
27354          _OUT << "}" << std::endl;
27355 }
27356
27357 static void print_VkDisplayModeProperties2KHR(VkDisplayModeProperties2KHR obj, const std::string& s, bool commaNeeded=true) {
27358      PRINT_SPACE
27359      _OUT << "{" << std::endl;
27360      INDENT(4);
27361
27362      print_VkStructureType(obj.sType, "sType", 1);
27363
27364       if (obj.pNext) {
27365          dumpPNextChain(obj.pNext);
27366       } else {
27367          PRINT_SPACE
27368          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27369      }
27370
27371      PRINT_SPACE
27372      _OUT << "\"displayModeProperties\": " << std::endl;
27373      {
27374            print_VkDisplayModePropertiesKHR(obj.displayModeProperties, "displayModeProperties", 0);
27375      }
27376
27377      INDENT(-4);
27378      PRINT_SPACE
27379      if (commaNeeded)
27380          _OUT << "}," << std::endl;
27381      else
27382          _OUT << "}" << std::endl;
27383 }
27384 static void print_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR * obj, const std::string& s, bool commaNeeded=true) {
27385      PRINT_SPACE
27386      _OUT << "{" << std::endl;
27387      INDENT(4);
27388
27389      print_VkStructureType(obj->sType, "sType", 1);
27390
27391       if (obj->pNext) {
27392          dumpPNextChain(obj->pNext);
27393       } else {
27394          PRINT_SPACE
27395          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27396      }
27397
27398      PRINT_SPACE
27399      _OUT << "\"displayModeProperties\": " << std::endl;
27400      {
27401            print_VkDisplayModePropertiesKHR(obj->displayModeProperties, "displayModeProperties", 0);
27402      }
27403
27404      INDENT(-4);
27405      PRINT_SPACE
27406      if (commaNeeded)
27407          _OUT << "}," << std::endl;
27408      else
27409          _OUT << "}" << std::endl;
27410 }
27411
27412 static void print_VkDisplayPlaneInfo2KHR(VkDisplayPlaneInfo2KHR obj, const std::string& s, bool commaNeeded=true) {
27413      PRINT_SPACE
27414      _OUT << "{" << std::endl;
27415      INDENT(4);
27416
27417      print_VkStructureType(obj.sType, "sType", 1);
27418
27419       if (obj.pNext) {
27420          dumpPNextChain(obj.pNext);
27421       } else {
27422          PRINT_SPACE
27423          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27424      }
27425
27426      // CTS : required value
27427      PRINT_SPACE    _OUT << "\"" << "mode" << "\"" << " : " << "\"" << "\"," << std::endl;
27428
27429      print_uint32_t(obj.planeIndex, "planeIndex", 0);
27430
27431      INDENT(-4);
27432      PRINT_SPACE
27433      if (commaNeeded)
27434          _OUT << "}," << std::endl;
27435      else
27436          _OUT << "}" << std::endl;
27437 }
27438 static void print_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR * obj, const std::string& s, bool commaNeeded=true) {
27439      PRINT_SPACE
27440      _OUT << "{" << std::endl;
27441      INDENT(4);
27442
27443      print_VkStructureType(obj->sType, "sType", 1);
27444
27445       if (obj->pNext) {
27446          dumpPNextChain(obj->pNext);
27447       } else {
27448          PRINT_SPACE
27449          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27450      }
27451
27452      // CTS : required value
27453      PRINT_SPACE    _OUT << "\"" << "mode" << "\"" << " : " << "\"" << "\"," << std::endl;
27454
27455      print_uint32_t(obj->planeIndex, "planeIndex", 0);
27456
27457      INDENT(-4);
27458      PRINT_SPACE
27459      if (commaNeeded)
27460          _OUT << "}," << std::endl;
27461      else
27462          _OUT << "}" << std::endl;
27463 }
27464
27465 static void print_VkDisplayPlaneCapabilities2KHR(VkDisplayPlaneCapabilities2KHR obj, const std::string& s, bool commaNeeded=true) {
27466      PRINT_SPACE
27467      _OUT << "{" << std::endl;
27468      INDENT(4);
27469
27470      print_VkStructureType(obj.sType, "sType", 1);
27471
27472       if (obj.pNext) {
27473          dumpPNextChain(obj.pNext);
27474       } else {
27475          PRINT_SPACE
27476          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27477      }
27478
27479      PRINT_SPACE
27480      _OUT << "\"capabilities\": " << std::endl;
27481      {
27482            print_VkDisplayPlaneCapabilitiesKHR(obj.capabilities, "capabilities", 0);
27483      }
27484
27485      INDENT(-4);
27486      PRINT_SPACE
27487      if (commaNeeded)
27488          _OUT << "}," << std::endl;
27489      else
27490          _OUT << "}" << std::endl;
27491 }
27492 static void print_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR * obj, const std::string& s, bool commaNeeded=true) {
27493      PRINT_SPACE
27494      _OUT << "{" << std::endl;
27495      INDENT(4);
27496
27497      print_VkStructureType(obj->sType, "sType", 1);
27498
27499       if (obj->pNext) {
27500          dumpPNextChain(obj->pNext);
27501       } else {
27502          PRINT_SPACE
27503          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27504      }
27505
27506      PRINT_SPACE
27507      _OUT << "\"capabilities\": " << std::endl;
27508      {
27509            print_VkDisplayPlaneCapabilitiesKHR(obj->capabilities, "capabilities", 0);
27510      }
27511
27512      INDENT(-4);
27513      PRINT_SPACE
27514      if (commaNeeded)
27515          _OUT << "}," << std::endl;
27516      else
27517          _OUT << "}" << std::endl;
27518 }
27519
27520 static void print_VkPhysicalDeviceShaderClockFeaturesKHR(VkPhysicalDeviceShaderClockFeaturesKHR obj, const std::string& s, bool commaNeeded=true) {
27521      PRINT_SPACE
27522      _OUT << "{" << std::endl;
27523      INDENT(4);
27524
27525      print_VkStructureType(obj.sType, "sType", 1);
27526
27527       if (obj.pNext) {
27528          dumpPNextChain(obj.pNext);
27529       } else {
27530          PRINT_SPACE
27531          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27532      }
27533
27534      print_VkBool32(obj.shaderSubgroupClock, "shaderSubgroupClock", 1);
27535
27536      print_VkBool32(obj.shaderDeviceClock, "shaderDeviceClock", 0);
27537
27538      INDENT(-4);
27539      PRINT_SPACE
27540      if (commaNeeded)
27541          _OUT << "}," << std::endl;
27542      else
27543          _OUT << "}" << std::endl;
27544 }
27545 static void print_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR * obj, const std::string& s, bool commaNeeded=true) {
27546      PRINT_SPACE
27547      _OUT << "{" << std::endl;
27548      INDENT(4);
27549
27550      print_VkStructureType(obj->sType, "sType", 1);
27551
27552       if (obj->pNext) {
27553          dumpPNextChain(obj->pNext);
27554       } else {
27555          PRINT_SPACE
27556          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27557      }
27558
27559      print_VkBool32(obj->shaderSubgroupClock, "shaderSubgroupClock", 1);
27560
27561      print_VkBool32(obj->shaderDeviceClock, "shaderDeviceClock", 0);
27562
27563      INDENT(-4);
27564      PRINT_SPACE
27565      if (commaNeeded)
27566          _OUT << "}," << std::endl;
27567      else
27568          _OUT << "}" << std::endl;
27569 }
27570
27571 static void print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR obj, const std::string& s, bool commaNeeded=true) {
27572      PRINT_SPACE
27573      _OUT << "{" << std::endl;
27574      INDENT(4);
27575
27576      print_VkStructureType(obj.sType, "sType", 1);
27577
27578       if (obj.pNext) {
27579          dumpPNextChain(obj.pNext);
27580       } else {
27581          PRINT_SPACE
27582          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27583      }
27584
27585      print_VkBool32(obj.shaderTerminateInvocation, "shaderTerminateInvocation", 0);
27586
27587      INDENT(-4);
27588      PRINT_SPACE
27589      if (commaNeeded)
27590          _OUT << "}," << std::endl;
27591      else
27592          _OUT << "}" << std::endl;
27593 }
27594 static void print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR * obj, const std::string& s, bool commaNeeded=true) {
27595      PRINT_SPACE
27596      _OUT << "{" << std::endl;
27597      INDENT(4);
27598
27599      print_VkStructureType(obj->sType, "sType", 1);
27600
27601       if (obj->pNext) {
27602          dumpPNextChain(obj->pNext);
27603       } else {
27604          PRINT_SPACE
27605          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27606      }
27607
27608      print_VkBool32(obj->shaderTerminateInvocation, "shaderTerminateInvocation", 0);
27609
27610      INDENT(-4);
27611      PRINT_SPACE
27612      if (commaNeeded)
27613          _OUT << "}," << std::endl;
27614      else
27615          _OUT << "}" << std::endl;
27616 }
27617
27618 static std::map<deUint64, std::string> VkFragmentShadingRateCombinerOpKHR_map = {
27619     std::make_pair(0, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR"),
27620     std::make_pair(1, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR"),
27621     std::make_pair(2, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR"),
27622     std::make_pair(3, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR"),
27623     std::make_pair(4, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR"),
27624 };
27625 static void print_VkFragmentShadingRateCombinerOpKHR(VkFragmentShadingRateCombinerOpKHR obj, const std::string& str, bool commaNeeded=true) {
27626      PRINT_SPACE
27627      if (str != "") _OUT << "\"" << str << "\"" << " : ";
27628      if (commaNeeded)
27629          _OUT << "\"" <<  VkFragmentShadingRateCombinerOpKHR_map[obj] << "\"," << std::endl;
27630      else
27631          _OUT << "\"" << VkFragmentShadingRateCombinerOpKHR_map[obj] << "\"" << std::endl;
27632 }
27633 static void print_VkFragmentShadingRateCombinerOpKHR(const VkFragmentShadingRateCombinerOpKHR * obj, const std::string& str, bool commaNeeded=true) {
27634      PRINT_SPACE
27635      if (str != "") _OUT << "\"" << str << "\"" << " : ";
27636      if (commaNeeded)
27637          _OUT << "\"" <<  VkFragmentShadingRateCombinerOpKHR_map[*obj] << "\"," << std::endl;
27638      else
27639          _OUT << "\"" << VkFragmentShadingRateCombinerOpKHR_map[*obj] << "\"" << std::endl;
27640 }
27641
27642 static void print_VkFragmentShadingRateAttachmentInfoKHR(VkFragmentShadingRateAttachmentInfoKHR obj, const std::string& s, bool commaNeeded=true) {
27643      PRINT_SPACE
27644      _OUT << "{" << std::endl;
27645      INDENT(4);
27646
27647      print_VkStructureType(obj.sType, "sType", 1);
27648
27649       if (obj.pNext) {
27650          dumpPNextChain(obj.pNext);
27651       } else {
27652          PRINT_SPACE
27653          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27654      }
27655
27656      PRINT_SPACE
27657      _OUT << "\"pFragmentShadingRateAttachment\": " << std::endl;
27658      if (obj.pFragmentShadingRateAttachment) {
27659            print_VkAttachmentReference2(obj.pFragmentShadingRateAttachment, "pFragmentShadingRateAttachment", 1);
27660      }
27661      else
27662      {
27663          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
27664      }
27665
27666      PRINT_SPACE
27667      _OUT << "\"shadingRateAttachmentTexelSize\": " << std::endl;
27668      {
27669            print_VkExtent2D(obj.shadingRateAttachmentTexelSize, "shadingRateAttachmentTexelSize", 0);
27670      }
27671
27672      INDENT(-4);
27673      PRINT_SPACE
27674      if (commaNeeded)
27675          _OUT << "}," << std::endl;
27676      else
27677          _OUT << "}" << std::endl;
27678 }
27679 static void print_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
27680      PRINT_SPACE
27681      _OUT << "{" << std::endl;
27682      INDENT(4);
27683
27684      print_VkStructureType(obj->sType, "sType", 1);
27685
27686       if (obj->pNext) {
27687          dumpPNextChain(obj->pNext);
27688       } else {
27689          PRINT_SPACE
27690          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27691      }
27692
27693      PRINT_SPACE
27694      _OUT << "\"pFragmentShadingRateAttachment\": " << std::endl;
27695      if (obj->pFragmentShadingRateAttachment) {
27696            print_VkAttachmentReference2(obj->pFragmentShadingRateAttachment, "pFragmentShadingRateAttachment", 1);
27697      }
27698      else
27699      {
27700          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
27701      }
27702
27703      PRINT_SPACE
27704      _OUT << "\"shadingRateAttachmentTexelSize\": " << std::endl;
27705      {
27706            print_VkExtent2D(obj->shadingRateAttachmentTexelSize, "shadingRateAttachmentTexelSize", 0);
27707      }
27708
27709      INDENT(-4);
27710      PRINT_SPACE
27711      if (commaNeeded)
27712          _OUT << "}," << std::endl;
27713      else
27714          _OUT << "}" << std::endl;
27715 }
27716
27717 static void print_VkPipelineFragmentShadingRateStateCreateInfoKHR(VkPipelineFragmentShadingRateStateCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) {
27718      PRINT_SPACE
27719      _OUT << "{" << std::endl;
27720      INDENT(4);
27721
27722      print_VkStructureType(obj.sType, "sType", 1);
27723
27724       if (obj.pNext) {
27725          dumpPNextChain(obj.pNext);
27726       } else {
27727          PRINT_SPACE
27728          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27729      }
27730
27731      PRINT_SPACE
27732      _OUT << "\"fragmentSize\": " << std::endl;
27733      {
27734            print_VkExtent2D(obj.fragmentSize, "fragmentSize", 1);
27735      }
27736
27737      PRINT_SPACE
27738      _OUT << "\"combinerOps\":" << std::endl;
27739      PRINT_SPACE
27740      if (obj.combinerOps) {
27741        _OUT << "[" << std::endl;
27742        for (unsigned int i = 0; i < 2; i++) {
27743            bool isCommaNeeded = (i+1) != 2;
27744            print_VkFragmentShadingRateCombinerOpKHR(obj.combinerOps[i], "", isCommaNeeded);
27745        }
27746        PRINT_SPACE
27747        _OUT << "]" << "" << std::endl;
27748      } else {
27749        _OUT << "\"NULL\"" << "" << std::endl;
27750      }
27751
27752      INDENT(-4);
27753      PRINT_SPACE
27754      if (commaNeeded)
27755          _OUT << "}," << std::endl;
27756      else
27757          _OUT << "}" << std::endl;
27758 }
27759 static void print_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
27760      PRINT_SPACE
27761      _OUT << "{" << std::endl;
27762      INDENT(4);
27763
27764      print_VkStructureType(obj->sType, "sType", 1);
27765
27766       if (obj->pNext) {
27767          dumpPNextChain(obj->pNext);
27768       } else {
27769          PRINT_SPACE
27770          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27771      }
27772
27773      PRINT_SPACE
27774      _OUT << "\"fragmentSize\": " << std::endl;
27775      {
27776            print_VkExtent2D(obj->fragmentSize, "fragmentSize", 1);
27777      }
27778
27779      PRINT_SPACE
27780      _OUT << "\"combinerOps\":" << std::endl;
27781      PRINT_SPACE
27782      if (obj->combinerOps) {
27783        _OUT << "[" << std::endl;
27784        for (unsigned int i = 0; i < 2; i++) {
27785            bool isCommaNeeded = (i+1) != 2;
27786            print_VkFragmentShadingRateCombinerOpKHR(obj->combinerOps[i], "", isCommaNeeded);
27787        }
27788        PRINT_SPACE
27789        _OUT << "]" << "" << std::endl;
27790      } else {
27791        _OUT << "\"NULL\"" << "" << std::endl;
27792      }
27793
27794      INDENT(-4);
27795      PRINT_SPACE
27796      if (commaNeeded)
27797          _OUT << "}," << std::endl;
27798      else
27799          _OUT << "}" << std::endl;
27800 }
27801
27802 static void print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(VkPhysicalDeviceFragmentShadingRateFeaturesKHR obj, const std::string& s, bool commaNeeded=true) {
27803      PRINT_SPACE
27804      _OUT << "{" << std::endl;
27805      INDENT(4);
27806
27807      print_VkStructureType(obj.sType, "sType", 1);
27808
27809       if (obj.pNext) {
27810          dumpPNextChain(obj.pNext);
27811       } else {
27812          PRINT_SPACE
27813          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27814      }
27815
27816      print_VkBool32(obj.pipelineFragmentShadingRate, "pipelineFragmentShadingRate", 1);
27817
27818      print_VkBool32(obj.primitiveFragmentShadingRate, "primitiveFragmentShadingRate", 1);
27819
27820      print_VkBool32(obj.attachmentFragmentShadingRate, "attachmentFragmentShadingRate", 0);
27821
27822      INDENT(-4);
27823      PRINT_SPACE
27824      if (commaNeeded)
27825          _OUT << "}," << std::endl;
27826      else
27827          _OUT << "}" << std::endl;
27828 }
27829 static void print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR * obj, const std::string& s, bool commaNeeded=true) {
27830      PRINT_SPACE
27831      _OUT << "{" << std::endl;
27832      INDENT(4);
27833
27834      print_VkStructureType(obj->sType, "sType", 1);
27835
27836       if (obj->pNext) {
27837          dumpPNextChain(obj->pNext);
27838       } else {
27839          PRINT_SPACE
27840          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27841      }
27842
27843      print_VkBool32(obj->pipelineFragmentShadingRate, "pipelineFragmentShadingRate", 1);
27844
27845      print_VkBool32(obj->primitiveFragmentShadingRate, "primitiveFragmentShadingRate", 1);
27846
27847      print_VkBool32(obj->attachmentFragmentShadingRate, "attachmentFragmentShadingRate", 0);
27848
27849      INDENT(-4);
27850      PRINT_SPACE
27851      if (commaNeeded)
27852          _OUT << "}," << std::endl;
27853      else
27854          _OUT << "}" << std::endl;
27855 }
27856
27857 static void print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(VkPhysicalDeviceFragmentShadingRatePropertiesKHR obj, const std::string& s, bool commaNeeded=true) {
27858      PRINT_SPACE
27859      _OUT << "{" << std::endl;
27860      INDENT(4);
27861
27862      print_VkStructureType(obj.sType, "sType", 1);
27863
27864       if (obj.pNext) {
27865          dumpPNextChain(obj.pNext);
27866       } else {
27867          PRINT_SPACE
27868          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27869      }
27870
27871      PRINT_SPACE
27872      _OUT << "\"minFragmentShadingRateAttachmentTexelSize\": " << std::endl;
27873      {
27874            print_VkExtent2D(obj.minFragmentShadingRateAttachmentTexelSize, "minFragmentShadingRateAttachmentTexelSize", 1);
27875      }
27876
27877      PRINT_SPACE
27878      _OUT << "\"maxFragmentShadingRateAttachmentTexelSize\": " << std::endl;
27879      {
27880            print_VkExtent2D(obj.maxFragmentShadingRateAttachmentTexelSize, "maxFragmentShadingRateAttachmentTexelSize", 1);
27881      }
27882
27883      print_uint32_t(obj.maxFragmentShadingRateAttachmentTexelSizeAspectRatio, "maxFragmentShadingRateAttachmentTexelSizeAspectRatio", 1);
27884
27885      print_VkBool32(obj.primitiveFragmentShadingRateWithMultipleViewports, "primitiveFragmentShadingRateWithMultipleViewports", 1);
27886
27887      print_VkBool32(obj.layeredShadingRateAttachments, "layeredShadingRateAttachments", 1);
27888
27889      print_VkBool32(obj.fragmentShadingRateNonTrivialCombinerOps, "fragmentShadingRateNonTrivialCombinerOps", 1);
27890
27891      PRINT_SPACE
27892      _OUT << "\"maxFragmentSize\": " << std::endl;
27893      {
27894            print_VkExtent2D(obj.maxFragmentSize, "maxFragmentSize", 1);
27895      }
27896
27897      print_uint32_t(obj.maxFragmentSizeAspectRatio, "maxFragmentSizeAspectRatio", 1);
27898
27899      print_uint32_t(obj.maxFragmentShadingRateCoverageSamples, "maxFragmentShadingRateCoverageSamples", 1);
27900
27901      print_VkSampleCountFlagBits(obj.maxFragmentShadingRateRasterizationSamples, "maxFragmentShadingRateRasterizationSamples", 1);
27902
27903      print_VkBool32(obj.fragmentShadingRateWithShaderDepthStencilWrites, "fragmentShadingRateWithShaderDepthStencilWrites", 1);
27904
27905      print_VkBool32(obj.fragmentShadingRateWithSampleMask, "fragmentShadingRateWithSampleMask", 1);
27906
27907      print_VkBool32(obj.fragmentShadingRateWithShaderSampleMask, "fragmentShadingRateWithShaderSampleMask", 1);
27908
27909      print_VkBool32(obj.fragmentShadingRateWithConservativeRasterization, "fragmentShadingRateWithConservativeRasterization", 1);
27910
27911      print_VkBool32(obj.fragmentShadingRateWithFragmentShaderInterlock, "fragmentShadingRateWithFragmentShaderInterlock", 1);
27912
27913      print_VkBool32(obj.fragmentShadingRateWithCustomSampleLocations, "fragmentShadingRateWithCustomSampleLocations", 1);
27914
27915      print_VkBool32(obj.fragmentShadingRateStrictMultiplyCombiner, "fragmentShadingRateStrictMultiplyCombiner", 0);
27916
27917      INDENT(-4);
27918      PRINT_SPACE
27919      if (commaNeeded)
27920          _OUT << "}," << std::endl;
27921      else
27922          _OUT << "}" << std::endl;
27923 }
27924 static void print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR * obj, const std::string& s, bool commaNeeded=true) {
27925      PRINT_SPACE
27926      _OUT << "{" << std::endl;
27927      INDENT(4);
27928
27929      print_VkStructureType(obj->sType, "sType", 1);
27930
27931       if (obj->pNext) {
27932          dumpPNextChain(obj->pNext);
27933       } else {
27934          PRINT_SPACE
27935          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
27936      }
27937
27938      PRINT_SPACE
27939      _OUT << "\"minFragmentShadingRateAttachmentTexelSize\": " << std::endl;
27940      {
27941            print_VkExtent2D(obj->minFragmentShadingRateAttachmentTexelSize, "minFragmentShadingRateAttachmentTexelSize", 1);
27942      }
27943
27944      PRINT_SPACE
27945      _OUT << "\"maxFragmentShadingRateAttachmentTexelSize\": " << std::endl;
27946      {
27947            print_VkExtent2D(obj->maxFragmentShadingRateAttachmentTexelSize, "maxFragmentShadingRateAttachmentTexelSize", 1);
27948      }
27949
27950      print_uint32_t(obj->maxFragmentShadingRateAttachmentTexelSizeAspectRatio, "maxFragmentShadingRateAttachmentTexelSizeAspectRatio", 1);
27951
27952      print_VkBool32(obj->primitiveFragmentShadingRateWithMultipleViewports, "primitiveFragmentShadingRateWithMultipleViewports", 1);
27953
27954      print_VkBool32(obj->layeredShadingRateAttachments, "layeredShadingRateAttachments", 1);
27955
27956      print_VkBool32(obj->fragmentShadingRateNonTrivialCombinerOps, "fragmentShadingRateNonTrivialCombinerOps", 1);
27957
27958      PRINT_SPACE
27959      _OUT << "\"maxFragmentSize\": " << std::endl;
27960      {
27961            print_VkExtent2D(obj->maxFragmentSize, "maxFragmentSize", 1);
27962      }
27963
27964      print_uint32_t(obj->maxFragmentSizeAspectRatio, "maxFragmentSizeAspectRatio", 1);
27965
27966      print_uint32_t(obj->maxFragmentShadingRateCoverageSamples, "maxFragmentShadingRateCoverageSamples", 1);
27967
27968      print_VkSampleCountFlagBits(obj->maxFragmentShadingRateRasterizationSamples, "maxFragmentShadingRateRasterizationSamples", 1);
27969
27970      print_VkBool32(obj->fragmentShadingRateWithShaderDepthStencilWrites, "fragmentShadingRateWithShaderDepthStencilWrites", 1);
27971
27972      print_VkBool32(obj->fragmentShadingRateWithSampleMask, "fragmentShadingRateWithSampleMask", 1);
27973
27974      print_VkBool32(obj->fragmentShadingRateWithShaderSampleMask, "fragmentShadingRateWithShaderSampleMask", 1);
27975
27976      print_VkBool32(obj->fragmentShadingRateWithConservativeRasterization, "fragmentShadingRateWithConservativeRasterization", 1);
27977
27978      print_VkBool32(obj->fragmentShadingRateWithFragmentShaderInterlock, "fragmentShadingRateWithFragmentShaderInterlock", 1);
27979
27980      print_VkBool32(obj->fragmentShadingRateWithCustomSampleLocations, "fragmentShadingRateWithCustomSampleLocations", 1);
27981
27982      print_VkBool32(obj->fragmentShadingRateStrictMultiplyCombiner, "fragmentShadingRateStrictMultiplyCombiner", 0);
27983
27984      INDENT(-4);
27985      PRINT_SPACE
27986      if (commaNeeded)
27987          _OUT << "}," << std::endl;
27988      else
27989          _OUT << "}" << std::endl;
27990 }
27991
27992 static void print_VkPhysicalDeviceFragmentShadingRateKHR(VkPhysicalDeviceFragmentShadingRateKHR obj, const std::string& s, bool commaNeeded=true) {
27993      PRINT_SPACE
27994      _OUT << "{" << std::endl;
27995      INDENT(4);
27996
27997      print_VkStructureType(obj.sType, "sType", 1);
27998
27999       if (obj.pNext) {
28000          dumpPNextChain(obj.pNext);
28001       } else {
28002          PRINT_SPACE
28003          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28004      }
28005
28006      print_VkSampleCountFlags(obj.sampleCounts, "sampleCounts", 1);
28007
28008      PRINT_SPACE
28009      _OUT << "\"fragmentSize\": " << std::endl;
28010      {
28011            print_VkExtent2D(obj.fragmentSize, "fragmentSize", 0);
28012      }
28013
28014      INDENT(-4);
28015      PRINT_SPACE
28016      if (commaNeeded)
28017          _OUT << "}," << std::endl;
28018      else
28019          _OUT << "}" << std::endl;
28020 }
28021 static void print_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR * obj, const std::string& s, bool commaNeeded=true) {
28022      PRINT_SPACE
28023      _OUT << "{" << std::endl;
28024      INDENT(4);
28025
28026      print_VkStructureType(obj->sType, "sType", 1);
28027
28028       if (obj->pNext) {
28029          dumpPNextChain(obj->pNext);
28030       } else {
28031          PRINT_SPACE
28032          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28033      }
28034
28035      print_VkSampleCountFlags(obj->sampleCounts, "sampleCounts", 1);
28036
28037      PRINT_SPACE
28038      _OUT << "\"fragmentSize\": " << std::endl;
28039      {
28040            print_VkExtent2D(obj->fragmentSize, "fragmentSize", 0);
28041      }
28042
28043      INDENT(-4);
28044      PRINT_SPACE
28045      if (commaNeeded)
28046          _OUT << "}," << std::endl;
28047      else
28048          _OUT << "}" << std::endl;
28049 }
28050
28051 static std::map<deUint64, std::string> VkRefreshObjectFlagBitsKHR_map = {
28052 };
28053 static void print_VkRefreshObjectFlagBitsKHR(VkRefreshObjectFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) {
28054      PRINT_SPACE
28055      if (str != "") _OUT << "\"" << str << "\"" << " : ";
28056      if (commaNeeded)
28057          _OUT << "\"" <<  VkRefreshObjectFlagBitsKHR_map[obj] << "\"," << std::endl;
28058      else
28059          _OUT << "\"" << VkRefreshObjectFlagBitsKHR_map[obj] << "\"" << std::endl;
28060 }
28061 static void print_VkRefreshObjectFlagBitsKHR(const VkRefreshObjectFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) {
28062      PRINT_SPACE
28063      if (str != "") _OUT << "\"" << str << "\"" << " : ";
28064      if (commaNeeded)
28065          _OUT << "\"" <<  VkRefreshObjectFlagBitsKHR_map[*obj] << "\"," << std::endl;
28066      else
28067          _OUT << "\"" << VkRefreshObjectFlagBitsKHR_map[*obj] << "\"" << std::endl;
28068 }
28069
28070 static void print_VkRefreshObjectFlagsKHR(VkRefreshObjectFlagsKHR obj, const std::string& str, bool commaNeeded=true) {
28071      PRINT_SPACE
28072      if (str != "") _OUT << "\"" << str << "\"" << " : ";
28073      const int max_bits = 64; // We don't expect the number to be larger.
28074      std::bitset<max_bits> b(obj);
28075      _OUT << "\"";
28076      if (obj == 0) _OUT << "0";
28077      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
28078          if (b[i] == 1) {
28079              bitCount++;
28080              if (bitCount < b.count())
28081                  _OUT << VkRefreshObjectFlagBitsKHR_map[1ULL<<i] << " | ";
28082              else
28083                  _OUT << VkRefreshObjectFlagBitsKHR_map[1ULL<<i];
28084          }
28085      }
28086      if (commaNeeded)
28087        _OUT << "\"" << ",";
28088      else
28089        _OUT << "\""<< "";
28090      _OUT << std::endl;
28091 }
28092 static void print_VkRefreshObjectFlagsKHR(const VkRefreshObjectFlagsKHR * obj, const std::string& str, bool commaNeeded=true) {
28093      PRINT_SPACE
28094      if (str != "") _OUT << "\"" << str << "\"" << " : ";
28095      const int max_bits = 64; // We don't expect the number to be larger.
28096      std::bitset<max_bits> b(obj);
28097      _OUT << "\"";
28098      if (obj == 0) _OUT << "0";
28099      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
28100          if (b[i] == 1) {
28101              bitCount++;
28102              if (bitCount < b.count())
28103                  _OUT << VkRefreshObjectFlagBitsKHR_map[1ULL<<i] << " | ";
28104              else
28105                  _OUT << VkRefreshObjectFlagBitsKHR_map[1ULL<<i];
28106          }
28107      }
28108      if (commaNeeded)
28109        _OUT << "\"" << ",";
28110      else
28111        _OUT << "\""<< "";
28112      _OUT << std::endl;
28113 }
28114
28115 static void print_VkRefreshObjectKHR(VkRefreshObjectKHR obj, const std::string& s, bool commaNeeded=true) {
28116      PRINT_SPACE
28117      _OUT << "{" << std::endl;
28118      INDENT(4);
28119
28120      print_VkObjectType(obj.objectType, "objectType", 1);
28121
28122      print_uint64_t(obj.objectHandle, "objectHandle", 1);
28123
28124      print_VkRefreshObjectFlagsKHR(obj.flags, "flags", 0);
28125
28126      INDENT(-4);
28127      PRINT_SPACE
28128      if (commaNeeded)
28129          _OUT << "}," << std::endl;
28130      else
28131          _OUT << "}" << std::endl;
28132 }
28133 static void print_VkRefreshObjectKHR(const VkRefreshObjectKHR * obj, const std::string& s, bool commaNeeded=true) {
28134      PRINT_SPACE
28135      _OUT << "{" << std::endl;
28136      INDENT(4);
28137
28138      print_VkObjectType(obj->objectType, "objectType", 1);
28139
28140      print_uint64_t(obj->objectHandle, "objectHandle", 1);
28141
28142      print_VkRefreshObjectFlagsKHR(obj->flags, "flags", 0);
28143
28144      INDENT(-4);
28145      PRINT_SPACE
28146      if (commaNeeded)
28147          _OUT << "}," << std::endl;
28148      else
28149          _OUT << "}" << std::endl;
28150 }
28151
28152 static void print_VkRefreshObjectListKHR(VkRefreshObjectListKHR obj, const std::string& s, bool commaNeeded=true) {
28153      PRINT_SPACE
28154      _OUT << "{" << std::endl;
28155      INDENT(4);
28156
28157      print_VkStructureType(obj.sType, "sType", 1);
28158
28159       if (obj.pNext) {
28160          dumpPNextChain(obj.pNext);
28161       } else {
28162          PRINT_SPACE
28163          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28164      }
28165
28166      print_uint32_t(obj.objectCount, "objectCount", 1);
28167
28168      PRINT_SPACE
28169      _OUT << "\"pObjects\": " << std::endl;
28170      if (obj.pObjects) {
28171          PRINT_SPACE
28172          _OUT << "[" << std::endl;
28173          for (unsigned int i = 0; i < obj.objectCount; i++) {
28174            if (i+1 == obj.objectCount)
28175                print_VkRefreshObjectKHR(obj.pObjects[i], "pObjects", 0);
28176            else
28177                print_VkRefreshObjectKHR(obj.pObjects[i], "pObjects", 1);
28178          }
28179          PRINT_SPACE
28180          _OUT << "]" << std::endl;
28181     }
28182      else
28183      {
28184          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
28185      }
28186
28187      INDENT(-4);
28188      PRINT_SPACE
28189      if (commaNeeded)
28190          _OUT << "}," << std::endl;
28191      else
28192          _OUT << "}" << std::endl;
28193 }
28194 static void print_VkRefreshObjectListKHR(const VkRefreshObjectListKHR * obj, const std::string& s, bool commaNeeded=true) {
28195      PRINT_SPACE
28196      _OUT << "{" << std::endl;
28197      INDENT(4);
28198
28199      print_VkStructureType(obj->sType, "sType", 1);
28200
28201       if (obj->pNext) {
28202          dumpPNextChain(obj->pNext);
28203       } else {
28204          PRINT_SPACE
28205          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28206      }
28207
28208      print_uint32_t(obj->objectCount, "objectCount", 1);
28209
28210      PRINT_SPACE
28211      _OUT << "\"pObjects\": " << std::endl;
28212      if (obj->pObjects) {
28213          PRINT_SPACE
28214          _OUT << "[" << std::endl;
28215          for (unsigned int i = 0; i < obj->objectCount; i++) {
28216            if (i+1 == obj->objectCount)
28217                print_VkRefreshObjectKHR(obj->pObjects[i], "pObjects", 0);
28218            else
28219                print_VkRefreshObjectKHR(obj->pObjects[i], "pObjects", 1);
28220          }
28221          PRINT_SPACE
28222          _OUT << "]" << std::endl;
28223     }
28224      else
28225      {
28226          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
28227      }
28228
28229      INDENT(-4);
28230      PRINT_SPACE
28231      if (commaNeeded)
28232          _OUT << "}," << std::endl;
28233      else
28234          _OUT << "}" << std::endl;
28235 }
28236
28237 static void print_VkFlags64(VkFlags64 obj, const std::string& str, bool commaNeeded=true) {
28238      PRINT_SPACE
28239      _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
28240 }
28241 static void print_VkFlags64(const VkFlags64 * obj, const std::string& str, bool commaNeeded=true) {
28242      PRINT_SPACE
28243      _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
28244 }
28245
28246 static std::map<deUint64, std::string> VkPipelineStageFlagBits2KHR_map = {
28247     std::make_pair(0, "VK_PIPELINE_STAGE_2_NONE_KHR"),
28248     std::make_pair(1ULL << 0, "VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR"),
28249     std::make_pair(1ULL << 1, "VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR"),
28250     std::make_pair(1ULL << 2, "VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR"),
28251     std::make_pair(1ULL << 3, "VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR"),
28252     std::make_pair(1ULL << 4, "VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR"),
28253     std::make_pair(1ULL << 5, "VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR"),
28254     std::make_pair(1ULL << 6, "VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR"),
28255     std::make_pair(1ULL << 7, "VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR"),
28256     std::make_pair(1ULL << 8, "VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR"),
28257     std::make_pair(1ULL << 9, "VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR"),
28258     std::make_pair(1ULL << 10, "VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR"),
28259     std::make_pair(1ULL << 11, "VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR"),
28260     std::make_pair(1ULL << 12, "VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR"),
28261     std::make_pair(1ULL << 13, "VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR"),
28262     std::make_pair(1ULL << 14, "VK_PIPELINE_STAGE_2_HOST_BIT_KHR"),
28263     std::make_pair(1ULL << 15, "VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR"),
28264     std::make_pair(1ULL << 16, "VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR"),
28265     std::make_pair(1ULL << 32, "VK_PIPELINE_STAGE_2_COPY_BIT_KHR"),
28266     std::make_pair(1ULL << 33, "VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR"),
28267     std::make_pair(1ULL << 34, "VK_PIPELINE_STAGE_2_BLIT_BIT_KHR"),
28268     std::make_pair(1ULL << 35, "VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR"),
28269     std::make_pair(1ULL << 36, "VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR"),
28270     std::make_pair(1ULL << 37, "VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR"),
28271     std::make_pair(1ULL << 38, "VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR"),
28272     std::make_pair(1ULL << 26, "VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR"),
28273     std::make_pair(1ULL << 27, "VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR"),
28274     std::make_pair(1ULL << 24, "VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT"),
28275     std::make_pair(1ULL << 18, "VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT"),
28276     std::make_pair(1ULL << 17, "VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV"),
28277     std::make_pair(1ULL << 22, "VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"),
28278     std::make_pair(1ULL << 25, "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"),
28279     std::make_pair(1ULL << 21, "VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR"),
28280     std::make_pair(1ULL << 23, "VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT"),
28281     std::make_pair(1ULL << 19, "VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV"),
28282     std::make_pair(1ULL << 20, "VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV"),
28283     std::make_pair(1ULL << 39, "VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI"),
28284     std::make_pair(1ULL << 40, "VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI"),
28285     std::make_pair(1ULL << 28, "VK_PIPELINE_STAGE_2_RESERVED_387_BIT_KHR"),
28286 };
28287 static void print_VkPipelineStageFlagBits2KHR(VkPipelineStageFlagBits2KHR obj, const std::string& str, bool commaNeeded=true) {
28288      PRINT_SPACE
28289      if (str != "") _OUT << "\"" << str << "\"" << " : ";
28290      if (commaNeeded)
28291          _OUT << "\"" <<  VkPipelineStageFlagBits2KHR_map[obj] << "\"," << std::endl;
28292      else
28293          _OUT << "\"" << VkPipelineStageFlagBits2KHR_map[obj] << "\"" << std::endl;
28294 }
28295 static void print_VkPipelineStageFlagBits2KHR(const VkPipelineStageFlagBits2KHR * obj, const std::string& str, bool commaNeeded=true) {
28296      PRINT_SPACE
28297      if (str != "") _OUT << "\"" << str << "\"" << " : ";
28298      if (commaNeeded)
28299          _OUT << "\"" <<  VkPipelineStageFlagBits2KHR_map[*obj] << "\"," << std::endl;
28300      else
28301          _OUT << "\"" << VkPipelineStageFlagBits2KHR_map[*obj] << "\"" << std::endl;
28302 }
28303
28304 static std::map<deUint64, std::string> VkAccessFlagBits2KHR_map = {
28305     std::make_pair(0, "VK_ACCESS_2_NONE_KHR"),
28306     std::make_pair(1ULL << 0, "VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR"),
28307     std::make_pair(1ULL << 1, "VK_ACCESS_2_INDEX_READ_BIT_KHR"),
28308     std::make_pair(1ULL << 2, "VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR"),
28309     std::make_pair(1ULL << 3, "VK_ACCESS_2_UNIFORM_READ_BIT_KHR"),
28310     std::make_pair(1ULL << 4, "VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR"),
28311     std::make_pair(1ULL << 5, "VK_ACCESS_2_SHADER_READ_BIT_KHR"),
28312     std::make_pair(1ULL << 6, "VK_ACCESS_2_SHADER_WRITE_BIT_KHR"),
28313     std::make_pair(1ULL << 7, "VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR"),
28314     std::make_pair(1ULL << 8, "VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR"),
28315     std::make_pair(1ULL << 9, "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR"),
28316     std::make_pair(1ULL << 10, "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR"),
28317     std::make_pair(1ULL << 11, "VK_ACCESS_2_TRANSFER_READ_BIT_KHR"),
28318     std::make_pair(1ULL << 12, "VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR"),
28319     std::make_pair(1ULL << 13, "VK_ACCESS_2_HOST_READ_BIT_KHR"),
28320     std::make_pair(1ULL << 14, "VK_ACCESS_2_HOST_WRITE_BIT_KHR"),
28321     std::make_pair(1ULL << 15, "VK_ACCESS_2_MEMORY_READ_BIT_KHR"),
28322     std::make_pair(1ULL << 16, "VK_ACCESS_2_MEMORY_WRITE_BIT_KHR"),
28323     std::make_pair(1ULL << 32, "VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR"),
28324     std::make_pair(1ULL << 33, "VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR"),
28325     std::make_pair(1ULL << 34, "VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR"),
28326     std::make_pair(1ULL << 35, "VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR"),
28327     std::make_pair(1ULL << 36, "VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR"),
28328     std::make_pair(1ULL << 37, "VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR"),
28329     std::make_pair(1ULL << 38, "VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR"),
28330     std::make_pair(1ULL << 25, "VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"),
28331     std::make_pair(1ULL << 26, "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"),
28332     std::make_pair(1ULL << 27, "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"),
28333     std::make_pair(1ULL << 20, "VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT"),
28334     std::make_pair(1ULL << 17, "VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV"),
28335     std::make_pair(1ULL << 18, "VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV"),
28336     std::make_pair(1ULL << 23, "VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"),
28337     std::make_pair(1ULL << 21, "VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR"),
28338     std::make_pair(1ULL << 22, "VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"),
28339     std::make_pair(1ULL << 24, "VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"),
28340     std::make_pair(1ULL << 19, "VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"),
28341     std::make_pair(1ULL << 41, "VK_ACCESS_2_RESERVED_41_BIT_AMD"),
28342     std::make_pair(1ULL << 39, "VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI"),
28343     std::make_pair(1ULL << 40, "VK_ACCESS_2_RESERVED_387_BIT_KHR"),
28344 };
28345 static void print_VkAccessFlagBits2KHR(VkAccessFlagBits2KHR obj, const std::string& str, bool commaNeeded=true) {
28346      PRINT_SPACE
28347      if (str != "") _OUT << "\"" << str << "\"" << " : ";
28348      if (commaNeeded)
28349          _OUT << "\"" <<  VkAccessFlagBits2KHR_map[obj] << "\"," << std::endl;
28350      else
28351          _OUT << "\"" << VkAccessFlagBits2KHR_map[obj] << "\"" << std::endl;
28352 }
28353 static void print_VkAccessFlagBits2KHR(const VkAccessFlagBits2KHR * obj, const std::string& str, bool commaNeeded=true) {
28354      PRINT_SPACE
28355      if (str != "") _OUT << "\"" << str << "\"" << " : ";
28356      if (commaNeeded)
28357          _OUT << "\"" <<  VkAccessFlagBits2KHR_map[*obj] << "\"," << std::endl;
28358      else
28359          _OUT << "\"" << VkAccessFlagBits2KHR_map[*obj] << "\"" << std::endl;
28360 }
28361
28362 static std::map<deUint64, std::string> VkSubmitFlagBitsKHR_map = {
28363     std::make_pair(1ULL << 0, "VK_SUBMIT_PROTECTED_BIT_KHR"),
28364 };
28365 static void print_VkSubmitFlagBitsKHR(VkSubmitFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) {
28366      PRINT_SPACE
28367      if (str != "") _OUT << "\"" << str << "\"" << " : ";
28368      if (commaNeeded)
28369          _OUT << "\"" <<  VkSubmitFlagBitsKHR_map[obj] << "\"," << std::endl;
28370      else
28371          _OUT << "\"" << VkSubmitFlagBitsKHR_map[obj] << "\"" << std::endl;
28372 }
28373 static void print_VkSubmitFlagBitsKHR(const VkSubmitFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) {
28374      PRINT_SPACE
28375      if (str != "") _OUT << "\"" << str << "\"" << " : ";
28376      if (commaNeeded)
28377          _OUT << "\"" <<  VkSubmitFlagBitsKHR_map[*obj] << "\"," << std::endl;
28378      else
28379          _OUT << "\"" << VkSubmitFlagBitsKHR_map[*obj] << "\"" << std::endl;
28380 }
28381
28382 static void print_VkPipelineStageFlags2KHR(VkPipelineStageFlags2KHR obj, const std::string& str, bool commaNeeded=true) {
28383      PRINT_SPACE
28384      if (commaNeeded)
28385          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
28386      else
28387          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
28388 }
28389 static void print_VkPipelineStageFlags2KHR(const VkPipelineStageFlags2KHR * obj, const std::string& str, bool commaNeeded=true) {
28390      PRINT_SPACE
28391      if (commaNeeded)
28392          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
28393      else
28394          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
28395 }
28396
28397 static void print_VkAccessFlags2KHR(VkAccessFlags2KHR obj, const std::string& str, bool commaNeeded=true) {
28398      PRINT_SPACE
28399      if (commaNeeded)
28400          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
28401      else
28402          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
28403 }
28404 static void print_VkAccessFlags2KHR(const VkAccessFlags2KHR * obj, const std::string& str, bool commaNeeded=true) {
28405      PRINT_SPACE
28406      if (commaNeeded)
28407          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
28408      else
28409          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
28410 }
28411
28412 static void print_VkSubmitFlagsKHR(VkSubmitFlagsKHR obj, const std::string& str, bool commaNeeded=true) {
28413      PRINT_SPACE
28414      if (str != "") _OUT << "\"" << str << "\"" << " : ";
28415      const int max_bits = 64; // We don't expect the number to be larger.
28416      std::bitset<max_bits> b(obj);
28417      _OUT << "\"";
28418      if (obj == 0) _OUT << "0";
28419      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
28420          if (b[i] == 1) {
28421              bitCount++;
28422              if (bitCount < b.count())
28423                  _OUT << VkSubmitFlagBitsKHR_map[1ULL<<i] << " | ";
28424              else
28425                  _OUT << VkSubmitFlagBitsKHR_map[1ULL<<i];
28426          }
28427      }
28428      if (commaNeeded)
28429        _OUT << "\"" << ",";
28430      else
28431        _OUT << "\""<< "";
28432      _OUT << std::endl;
28433 }
28434 static void print_VkSubmitFlagsKHR(const VkSubmitFlagsKHR * obj, const std::string& str, bool commaNeeded=true) {
28435      PRINT_SPACE
28436      if (str != "") _OUT << "\"" << str << "\"" << " : ";
28437      const int max_bits = 64; // We don't expect the number to be larger.
28438      std::bitset<max_bits> b(obj);
28439      _OUT << "\"";
28440      if (obj == 0) _OUT << "0";
28441      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
28442          if (b[i] == 1) {
28443              bitCount++;
28444              if (bitCount < b.count())
28445                  _OUT << VkSubmitFlagBitsKHR_map[1ULL<<i] << " | ";
28446              else
28447                  _OUT << VkSubmitFlagBitsKHR_map[1ULL<<i];
28448          }
28449      }
28450      if (commaNeeded)
28451        _OUT << "\"" << ",";
28452      else
28453        _OUT << "\""<< "";
28454      _OUT << std::endl;
28455 }
28456
28457 static void print_VkMemoryBarrier2KHR(VkMemoryBarrier2KHR obj, const std::string& s, bool commaNeeded=true) {
28458      PRINT_SPACE
28459      _OUT << "{" << std::endl;
28460      INDENT(4);
28461
28462      print_VkStructureType(obj.sType, "sType", 1);
28463
28464       if (obj.pNext) {
28465          dumpPNextChain(obj.pNext);
28466       } else {
28467          PRINT_SPACE
28468          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28469      }
28470
28471      print_VkPipelineStageFlags2KHR(obj.srcStageMask, "srcStageMask", 1);
28472
28473      print_VkAccessFlags2KHR(obj.srcAccessMask, "srcAccessMask", 1);
28474
28475      print_VkPipelineStageFlags2KHR(obj.dstStageMask, "dstStageMask", 1);
28476
28477      print_VkAccessFlags2KHR(obj.dstAccessMask, "dstAccessMask", 0);
28478
28479      INDENT(-4);
28480      PRINT_SPACE
28481      if (commaNeeded)
28482          _OUT << "}," << std::endl;
28483      else
28484          _OUT << "}" << std::endl;
28485 }
28486 static void print_VkMemoryBarrier2KHR(const VkMemoryBarrier2KHR * obj, const std::string& s, bool commaNeeded=true) {
28487      PRINT_SPACE
28488      _OUT << "{" << std::endl;
28489      INDENT(4);
28490
28491      print_VkStructureType(obj->sType, "sType", 1);
28492
28493       if (obj->pNext) {
28494          dumpPNextChain(obj->pNext);
28495       } else {
28496          PRINT_SPACE
28497          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28498      }
28499
28500      print_VkPipelineStageFlags2KHR(obj->srcStageMask, "srcStageMask", 1);
28501
28502      print_VkAccessFlags2KHR(obj->srcAccessMask, "srcAccessMask", 1);
28503
28504      print_VkPipelineStageFlags2KHR(obj->dstStageMask, "dstStageMask", 1);
28505
28506      print_VkAccessFlags2KHR(obj->dstAccessMask, "dstAccessMask", 0);
28507
28508      INDENT(-4);
28509      PRINT_SPACE
28510      if (commaNeeded)
28511          _OUT << "}," << std::endl;
28512      else
28513          _OUT << "}" << std::endl;
28514 }
28515
28516 static void print_VkBufferMemoryBarrier2KHR(VkBufferMemoryBarrier2KHR obj, const std::string& s, bool commaNeeded=true) {
28517      PRINT_SPACE
28518      _OUT << "{" << std::endl;
28519      INDENT(4);
28520
28521      print_VkStructureType(obj.sType, "sType", 1);
28522
28523       if (obj.pNext) {
28524          dumpPNextChain(obj.pNext);
28525       } else {
28526          PRINT_SPACE
28527          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28528      }
28529
28530      print_VkPipelineStageFlags2KHR(obj.srcStageMask, "srcStageMask", 1);
28531
28532      print_VkAccessFlags2KHR(obj.srcAccessMask, "srcAccessMask", 1);
28533
28534      print_VkPipelineStageFlags2KHR(obj.dstStageMask, "dstStageMask", 1);
28535
28536      print_VkAccessFlags2KHR(obj.dstAccessMask, "dstAccessMask", 1);
28537
28538      print_uint32_t(obj.srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
28539
28540      print_uint32_t(obj.dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
28541
28542      // CTS : required value
28543      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl;
28544
28545      print_VkDeviceSize(obj.offset, "offset", 1);
28546
28547      print_VkDeviceSize(obj.size, "size", 0);
28548
28549      INDENT(-4);
28550      PRINT_SPACE
28551      if (commaNeeded)
28552          _OUT << "}," << std::endl;
28553      else
28554          _OUT << "}" << std::endl;
28555 }
28556 static void print_VkBufferMemoryBarrier2KHR(const VkBufferMemoryBarrier2KHR * obj, const std::string& s, bool commaNeeded=true) {
28557      PRINT_SPACE
28558      _OUT << "{" << std::endl;
28559      INDENT(4);
28560
28561      print_VkStructureType(obj->sType, "sType", 1);
28562
28563       if (obj->pNext) {
28564          dumpPNextChain(obj->pNext);
28565       } else {
28566          PRINT_SPACE
28567          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28568      }
28569
28570      print_VkPipelineStageFlags2KHR(obj->srcStageMask, "srcStageMask", 1);
28571
28572      print_VkAccessFlags2KHR(obj->srcAccessMask, "srcAccessMask", 1);
28573
28574      print_VkPipelineStageFlags2KHR(obj->dstStageMask, "dstStageMask", 1);
28575
28576      print_VkAccessFlags2KHR(obj->dstAccessMask, "dstAccessMask", 1);
28577
28578      print_uint32_t(obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
28579
28580      print_uint32_t(obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
28581
28582      // CTS : required value
28583      PRINT_SPACE    _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl;
28584
28585      print_VkDeviceSize(obj->offset, "offset", 1);
28586
28587      print_VkDeviceSize(obj->size, "size", 0);
28588
28589      INDENT(-4);
28590      PRINT_SPACE
28591      if (commaNeeded)
28592          _OUT << "}," << std::endl;
28593      else
28594          _OUT << "}" << std::endl;
28595 }
28596
28597 static void print_VkImageMemoryBarrier2KHR(VkImageMemoryBarrier2KHR obj, const std::string& s, bool commaNeeded=true) {
28598      PRINT_SPACE
28599      _OUT << "{" << std::endl;
28600      INDENT(4);
28601
28602      print_VkStructureType(obj.sType, "sType", 1);
28603
28604       if (obj.pNext) {
28605          dumpPNextChain(obj.pNext);
28606       } else {
28607          PRINT_SPACE
28608          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28609      }
28610
28611      print_VkPipelineStageFlags2KHR(obj.srcStageMask, "srcStageMask", 1);
28612
28613      print_VkAccessFlags2KHR(obj.srcAccessMask, "srcAccessMask", 1);
28614
28615      print_VkPipelineStageFlags2KHR(obj.dstStageMask, "dstStageMask", 1);
28616
28617      print_VkAccessFlags2KHR(obj.dstAccessMask, "dstAccessMask", 1);
28618
28619      print_VkImageLayout(obj.oldLayout, "oldLayout", 1);
28620
28621      print_VkImageLayout(obj.newLayout, "newLayout", 1);
28622
28623      print_uint32_t(obj.srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
28624
28625      print_uint32_t(obj.dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
28626
28627      // CTS : required value
28628      PRINT_SPACE    _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl;
28629
28630      PRINT_SPACE
28631      _OUT << "\"subresourceRange\": " << std::endl;
28632      {
28633            print_VkImageSubresourceRange(obj.subresourceRange, "subresourceRange", 0);
28634      }
28635
28636      INDENT(-4);
28637      PRINT_SPACE
28638      if (commaNeeded)
28639          _OUT << "}," << std::endl;
28640      else
28641          _OUT << "}" << std::endl;
28642 }
28643 static void print_VkImageMemoryBarrier2KHR(const VkImageMemoryBarrier2KHR * obj, const std::string& s, bool commaNeeded=true) {
28644      PRINT_SPACE
28645      _OUT << "{" << std::endl;
28646      INDENT(4);
28647
28648      print_VkStructureType(obj->sType, "sType", 1);
28649
28650       if (obj->pNext) {
28651          dumpPNextChain(obj->pNext);
28652       } else {
28653          PRINT_SPACE
28654          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28655      }
28656
28657      print_VkPipelineStageFlags2KHR(obj->srcStageMask, "srcStageMask", 1);
28658
28659      print_VkAccessFlags2KHR(obj->srcAccessMask, "srcAccessMask", 1);
28660
28661      print_VkPipelineStageFlags2KHR(obj->dstStageMask, "dstStageMask", 1);
28662
28663      print_VkAccessFlags2KHR(obj->dstAccessMask, "dstAccessMask", 1);
28664
28665      print_VkImageLayout(obj->oldLayout, "oldLayout", 1);
28666
28667      print_VkImageLayout(obj->newLayout, "newLayout", 1);
28668
28669      print_uint32_t(obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
28670
28671      print_uint32_t(obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
28672
28673      // CTS : required value
28674      PRINT_SPACE    _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl;
28675
28676      PRINT_SPACE
28677      _OUT << "\"subresourceRange\": " << std::endl;
28678      {
28679            print_VkImageSubresourceRange(obj->subresourceRange, "subresourceRange", 0);
28680      }
28681
28682      INDENT(-4);
28683      PRINT_SPACE
28684      if (commaNeeded)
28685          _OUT << "}," << std::endl;
28686      else
28687          _OUT << "}" << std::endl;
28688 }
28689
28690 static void print_VkDependencyInfoKHR(VkDependencyInfoKHR obj, const std::string& s, bool commaNeeded=true) {
28691      PRINT_SPACE
28692      _OUT << "{" << std::endl;
28693      INDENT(4);
28694
28695      print_VkStructureType(obj.sType, "sType", 1);
28696
28697       if (obj.pNext) {
28698          dumpPNextChain(obj.pNext);
28699       } else {
28700          PRINT_SPACE
28701          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28702      }
28703
28704      print_VkDependencyFlags(obj.dependencyFlags, "dependencyFlags", 1);
28705
28706      print_uint32_t(obj.memoryBarrierCount, "memoryBarrierCount", 1);
28707
28708      PRINT_SPACE
28709      _OUT << "\"pMemoryBarriers\": " << std::endl;
28710      if (obj.pMemoryBarriers) {
28711          PRINT_SPACE
28712          _OUT << "[" << std::endl;
28713          for (unsigned int i = 0; i < obj.memoryBarrierCount; i++) {
28714            if (i+1 == obj.memoryBarrierCount)
28715                print_VkMemoryBarrier2KHR(obj.pMemoryBarriers[i], "pMemoryBarriers", 0);
28716            else
28717                print_VkMemoryBarrier2KHR(obj.pMemoryBarriers[i], "pMemoryBarriers", 1);
28718          }
28719          PRINT_SPACE
28720          _OUT << "]," << std::endl;
28721     }
28722      else
28723      {
28724          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
28725      }
28726
28727      print_uint32_t(obj.bufferMemoryBarrierCount, "bufferMemoryBarrierCount", 1);
28728
28729      PRINT_SPACE
28730      _OUT << "\"pBufferMemoryBarriers\": " << std::endl;
28731      if (obj.pBufferMemoryBarriers) {
28732          PRINT_SPACE
28733          _OUT << "[" << std::endl;
28734          for (unsigned int i = 0; i < obj.bufferMemoryBarrierCount; i++) {
28735            if (i+1 == obj.bufferMemoryBarrierCount)
28736                print_VkBufferMemoryBarrier2KHR(obj.pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 0);
28737            else
28738                print_VkBufferMemoryBarrier2KHR(obj.pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 1);
28739          }
28740          PRINT_SPACE
28741          _OUT << "]," << std::endl;
28742     }
28743      else
28744      {
28745          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
28746      }
28747
28748      print_uint32_t(obj.imageMemoryBarrierCount, "imageMemoryBarrierCount", 1);
28749
28750      PRINT_SPACE
28751      _OUT << "\"pImageMemoryBarriers\": " << std::endl;
28752      if (obj.pImageMemoryBarriers) {
28753          PRINT_SPACE
28754          _OUT << "[" << std::endl;
28755          for (unsigned int i = 0; i < obj.imageMemoryBarrierCount; i++) {
28756            if (i+1 == obj.imageMemoryBarrierCount)
28757                print_VkImageMemoryBarrier2KHR(obj.pImageMemoryBarriers[i], "pImageMemoryBarriers", 0);
28758            else
28759                print_VkImageMemoryBarrier2KHR(obj.pImageMemoryBarriers[i], "pImageMemoryBarriers", 1);
28760          }
28761          PRINT_SPACE
28762          _OUT << "]" << std::endl;
28763     }
28764      else
28765      {
28766          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
28767      }
28768
28769      INDENT(-4);
28770      PRINT_SPACE
28771      if (commaNeeded)
28772          _OUT << "}," << std::endl;
28773      else
28774          _OUT << "}" << std::endl;
28775 }
28776 static void print_VkDependencyInfoKHR(const VkDependencyInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
28777      PRINT_SPACE
28778      _OUT << "{" << std::endl;
28779      INDENT(4);
28780
28781      print_VkStructureType(obj->sType, "sType", 1);
28782
28783       if (obj->pNext) {
28784          dumpPNextChain(obj->pNext);
28785       } else {
28786          PRINT_SPACE
28787          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28788      }
28789
28790      print_VkDependencyFlags(obj->dependencyFlags, "dependencyFlags", 1);
28791
28792      print_uint32_t(obj->memoryBarrierCount, "memoryBarrierCount", 1);
28793
28794      PRINT_SPACE
28795      _OUT << "\"pMemoryBarriers\": " << std::endl;
28796      if (obj->pMemoryBarriers) {
28797          PRINT_SPACE
28798          _OUT << "[" << std::endl;
28799          for (unsigned int i = 0; i < obj->memoryBarrierCount; i++) {
28800            if (i+1 == obj->memoryBarrierCount)
28801                print_VkMemoryBarrier2KHR(obj->pMemoryBarriers[i], "pMemoryBarriers", 0);
28802            else
28803                print_VkMemoryBarrier2KHR(obj->pMemoryBarriers[i], "pMemoryBarriers", 1);
28804          }
28805          PRINT_SPACE
28806          _OUT << "]," << std::endl;
28807     }
28808      else
28809      {
28810          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
28811      }
28812
28813      print_uint32_t(obj->bufferMemoryBarrierCount, "bufferMemoryBarrierCount", 1);
28814
28815      PRINT_SPACE
28816      _OUT << "\"pBufferMemoryBarriers\": " << std::endl;
28817      if (obj->pBufferMemoryBarriers) {
28818          PRINT_SPACE
28819          _OUT << "[" << std::endl;
28820          for (unsigned int i = 0; i < obj->bufferMemoryBarrierCount; i++) {
28821            if (i+1 == obj->bufferMemoryBarrierCount)
28822                print_VkBufferMemoryBarrier2KHR(obj->pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 0);
28823            else
28824                print_VkBufferMemoryBarrier2KHR(obj->pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 1);
28825          }
28826          PRINT_SPACE
28827          _OUT << "]," << std::endl;
28828     }
28829      else
28830      {
28831          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
28832      }
28833
28834      print_uint32_t(obj->imageMemoryBarrierCount, "imageMemoryBarrierCount", 1);
28835
28836      PRINT_SPACE
28837      _OUT << "\"pImageMemoryBarriers\": " << std::endl;
28838      if (obj->pImageMemoryBarriers) {
28839          PRINT_SPACE
28840          _OUT << "[" << std::endl;
28841          for (unsigned int i = 0; i < obj->imageMemoryBarrierCount; i++) {
28842            if (i+1 == obj->imageMemoryBarrierCount)
28843                print_VkImageMemoryBarrier2KHR(obj->pImageMemoryBarriers[i], "pImageMemoryBarriers", 0);
28844            else
28845                print_VkImageMemoryBarrier2KHR(obj->pImageMemoryBarriers[i], "pImageMemoryBarriers", 1);
28846          }
28847          PRINT_SPACE
28848          _OUT << "]" << std::endl;
28849     }
28850      else
28851      {
28852          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
28853      }
28854
28855      INDENT(-4);
28856      PRINT_SPACE
28857      if (commaNeeded)
28858          _OUT << "}," << std::endl;
28859      else
28860          _OUT << "}" << std::endl;
28861 }
28862
28863 static void print_VkSemaphoreSubmitInfoKHR(VkSemaphoreSubmitInfoKHR obj, const std::string& s, bool commaNeeded=true) {
28864      PRINT_SPACE
28865      _OUT << "{" << std::endl;
28866      INDENT(4);
28867
28868      print_VkStructureType(obj.sType, "sType", 1);
28869
28870       if (obj.pNext) {
28871          dumpPNextChain(obj.pNext);
28872       } else {
28873          PRINT_SPACE
28874          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28875      }
28876
28877      // CTS : required value
28878      PRINT_SPACE    _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl;
28879
28880      print_uint64_t(obj.value, "value", 1);
28881
28882      print_VkPipelineStageFlags2KHR(obj.stageMask, "stageMask", 1);
28883
28884      print_uint32_t(obj.deviceIndex, "deviceIndex", 0);
28885
28886      INDENT(-4);
28887      PRINT_SPACE
28888      if (commaNeeded)
28889          _OUT << "}," << std::endl;
28890      else
28891          _OUT << "}" << std::endl;
28892 }
28893 static void print_VkSemaphoreSubmitInfoKHR(const VkSemaphoreSubmitInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
28894      PRINT_SPACE
28895      _OUT << "{" << std::endl;
28896      INDENT(4);
28897
28898      print_VkStructureType(obj->sType, "sType", 1);
28899
28900       if (obj->pNext) {
28901          dumpPNextChain(obj->pNext);
28902       } else {
28903          PRINT_SPACE
28904          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28905      }
28906
28907      // CTS : required value
28908      PRINT_SPACE    _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl;
28909
28910      print_uint64_t(obj->value, "value", 1);
28911
28912      print_VkPipelineStageFlags2KHR(obj->stageMask, "stageMask", 1);
28913
28914      print_uint32_t(obj->deviceIndex, "deviceIndex", 0);
28915
28916      INDENT(-4);
28917      PRINT_SPACE
28918      if (commaNeeded)
28919          _OUT << "}," << std::endl;
28920      else
28921          _OUT << "}" << std::endl;
28922 }
28923
28924 static void print_VkCommandBufferSubmitInfoKHR(VkCommandBufferSubmitInfoKHR obj, const std::string& s, bool commaNeeded=true) {
28925      PRINT_SPACE
28926      _OUT << "{" << std::endl;
28927      INDENT(4);
28928
28929      print_VkStructureType(obj.sType, "sType", 1);
28930
28931       if (obj.pNext) {
28932          dumpPNextChain(obj.pNext);
28933       } else {
28934          PRINT_SPACE
28935          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28936      }
28937
28938      // CTS : required value
28939      PRINT_SPACE    _OUT << "\"" << "commandBuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
28940
28941      print_uint32_t(obj.deviceMask, "deviceMask", 0);
28942
28943      INDENT(-4);
28944      PRINT_SPACE
28945      if (commaNeeded)
28946          _OUT << "}," << std::endl;
28947      else
28948          _OUT << "}" << std::endl;
28949 }
28950 static void print_VkCommandBufferSubmitInfoKHR(const VkCommandBufferSubmitInfoKHR * obj, const std::string& s, bool commaNeeded=true) {
28951      PRINT_SPACE
28952      _OUT << "{" << std::endl;
28953      INDENT(4);
28954
28955      print_VkStructureType(obj->sType, "sType", 1);
28956
28957       if (obj->pNext) {
28958          dumpPNextChain(obj->pNext);
28959       } else {
28960          PRINT_SPACE
28961          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28962      }
28963
28964      // CTS : required value
28965      PRINT_SPACE    _OUT << "\"" << "commandBuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
28966
28967      print_uint32_t(obj->deviceMask, "deviceMask", 0);
28968
28969      INDENT(-4);
28970      PRINT_SPACE
28971      if (commaNeeded)
28972          _OUT << "}," << std::endl;
28973      else
28974          _OUT << "}" << std::endl;
28975 }
28976
28977 static void print_VkSubmitInfo2KHR(VkSubmitInfo2KHR obj, const std::string& s, bool commaNeeded=true) {
28978      PRINT_SPACE
28979      _OUT << "{" << std::endl;
28980      INDENT(4);
28981
28982      print_VkStructureType(obj.sType, "sType", 1);
28983
28984       if (obj.pNext) {
28985          dumpPNextChain(obj.pNext);
28986       } else {
28987          PRINT_SPACE
28988          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
28989      }
28990
28991      print_VkSubmitFlagsKHR(obj.flags, "flags", 1);
28992
28993      print_uint32_t(obj.waitSemaphoreInfoCount, "waitSemaphoreInfoCount", 1);
28994
28995      PRINT_SPACE
28996      _OUT << "\"pWaitSemaphoreInfos\": " << std::endl;
28997      if (obj.pWaitSemaphoreInfos) {
28998          PRINT_SPACE
28999          _OUT << "[" << std::endl;
29000          for (unsigned int i = 0; i < obj.waitSemaphoreInfoCount; i++) {
29001            if (i+1 == obj.waitSemaphoreInfoCount)
29002                print_VkSemaphoreSubmitInfoKHR(obj.pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 0);
29003            else
29004                print_VkSemaphoreSubmitInfoKHR(obj.pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 1);
29005          }
29006          PRINT_SPACE
29007          _OUT << "]," << std::endl;
29008     }
29009      else
29010      {
29011          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
29012      }
29013
29014      print_uint32_t(obj.commandBufferInfoCount, "commandBufferInfoCount", 1);
29015
29016      PRINT_SPACE
29017      _OUT << "\"pCommandBufferInfos\": " << std::endl;
29018      if (obj.pCommandBufferInfos) {
29019          PRINT_SPACE
29020          _OUT << "[" << std::endl;
29021          for (unsigned int i = 0; i < obj.commandBufferInfoCount; i++) {
29022            if (i+1 == obj.commandBufferInfoCount)
29023                print_VkCommandBufferSubmitInfoKHR(obj.pCommandBufferInfos[i], "pCommandBufferInfos", 0);
29024            else
29025                print_VkCommandBufferSubmitInfoKHR(obj.pCommandBufferInfos[i], "pCommandBufferInfos", 1);
29026          }
29027          PRINT_SPACE
29028          _OUT << "]," << std::endl;
29029     }
29030      else
29031      {
29032          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
29033      }
29034
29035      print_uint32_t(obj.signalSemaphoreInfoCount, "signalSemaphoreInfoCount", 1);
29036
29037      PRINT_SPACE
29038      _OUT << "\"pSignalSemaphoreInfos\": " << std::endl;
29039      if (obj.pSignalSemaphoreInfos) {
29040          PRINT_SPACE
29041          _OUT << "[" << std::endl;
29042          for (unsigned int i = 0; i < obj.signalSemaphoreInfoCount; i++) {
29043            if (i+1 == obj.signalSemaphoreInfoCount)
29044                print_VkSemaphoreSubmitInfoKHR(obj.pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 0);
29045            else
29046                print_VkSemaphoreSubmitInfoKHR(obj.pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 1);
29047          }
29048          PRINT_SPACE
29049          _OUT << "]" << std::endl;
29050     }
29051      else
29052      {
29053          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
29054      }
29055
29056      INDENT(-4);
29057      PRINT_SPACE
29058      if (commaNeeded)
29059          _OUT << "}," << std::endl;
29060      else
29061          _OUT << "}" << std::endl;
29062 }
29063 static void print_VkSubmitInfo2KHR(const VkSubmitInfo2KHR * obj, const std::string& s, bool commaNeeded=true) {
29064      PRINT_SPACE
29065      _OUT << "{" << std::endl;
29066      INDENT(4);
29067
29068      print_VkStructureType(obj->sType, "sType", 1);
29069
29070       if (obj->pNext) {
29071          dumpPNextChain(obj->pNext);
29072       } else {
29073          PRINT_SPACE
29074          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29075      }
29076
29077      print_VkSubmitFlagsKHR(obj->flags, "flags", 1);
29078
29079      print_uint32_t(obj->waitSemaphoreInfoCount, "waitSemaphoreInfoCount", 1);
29080
29081      PRINT_SPACE
29082      _OUT << "\"pWaitSemaphoreInfos\": " << std::endl;
29083      if (obj->pWaitSemaphoreInfos) {
29084          PRINT_SPACE
29085          _OUT << "[" << std::endl;
29086          for (unsigned int i = 0; i < obj->waitSemaphoreInfoCount; i++) {
29087            if (i+1 == obj->waitSemaphoreInfoCount)
29088                print_VkSemaphoreSubmitInfoKHR(obj->pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 0);
29089            else
29090                print_VkSemaphoreSubmitInfoKHR(obj->pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 1);
29091          }
29092          PRINT_SPACE
29093          _OUT << "]," << std::endl;
29094     }
29095      else
29096      {
29097          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
29098      }
29099
29100      print_uint32_t(obj->commandBufferInfoCount, "commandBufferInfoCount", 1);
29101
29102      PRINT_SPACE
29103      _OUT << "\"pCommandBufferInfos\": " << std::endl;
29104      if (obj->pCommandBufferInfos) {
29105          PRINT_SPACE
29106          _OUT << "[" << std::endl;
29107          for (unsigned int i = 0; i < obj->commandBufferInfoCount; i++) {
29108            if (i+1 == obj->commandBufferInfoCount)
29109                print_VkCommandBufferSubmitInfoKHR(obj->pCommandBufferInfos[i], "pCommandBufferInfos", 0);
29110            else
29111                print_VkCommandBufferSubmitInfoKHR(obj->pCommandBufferInfos[i], "pCommandBufferInfos", 1);
29112          }
29113          PRINT_SPACE
29114          _OUT << "]," << std::endl;
29115     }
29116      else
29117      {
29118          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
29119      }
29120
29121      print_uint32_t(obj->signalSemaphoreInfoCount, "signalSemaphoreInfoCount", 1);
29122
29123      PRINT_SPACE
29124      _OUT << "\"pSignalSemaphoreInfos\": " << std::endl;
29125      if (obj->pSignalSemaphoreInfos) {
29126          PRINT_SPACE
29127          _OUT << "[" << std::endl;
29128          for (unsigned int i = 0; i < obj->signalSemaphoreInfoCount; i++) {
29129            if (i+1 == obj->signalSemaphoreInfoCount)
29130                print_VkSemaphoreSubmitInfoKHR(obj->pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 0);
29131            else
29132                print_VkSemaphoreSubmitInfoKHR(obj->pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 1);
29133          }
29134          PRINT_SPACE
29135          _OUT << "]" << std::endl;
29136     }
29137      else
29138      {
29139          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
29140      }
29141
29142      INDENT(-4);
29143      PRINT_SPACE
29144      if (commaNeeded)
29145          _OUT << "}," << std::endl;
29146      else
29147          _OUT << "}" << std::endl;
29148 }
29149
29150 static void print_VkPhysicalDeviceSynchronization2FeaturesKHR(VkPhysicalDeviceSynchronization2FeaturesKHR obj, const std::string& s, bool commaNeeded=true) {
29151      PRINT_SPACE
29152      _OUT << "{" << std::endl;
29153      INDENT(4);
29154
29155      print_VkStructureType(obj.sType, "sType", 1);
29156
29157       if (obj.pNext) {
29158          dumpPNextChain(obj.pNext);
29159       } else {
29160          PRINT_SPACE
29161          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29162      }
29163
29164      print_VkBool32(obj.synchronization2, "synchronization2", 0);
29165
29166      INDENT(-4);
29167      PRINT_SPACE
29168      if (commaNeeded)
29169          _OUT << "}," << std::endl;
29170      else
29171          _OUT << "}" << std::endl;
29172 }
29173 static void print_VkPhysicalDeviceSynchronization2FeaturesKHR(const VkPhysicalDeviceSynchronization2FeaturesKHR * obj, const std::string& s, bool commaNeeded=true) {
29174      PRINT_SPACE
29175      _OUT << "{" << std::endl;
29176      INDENT(4);
29177
29178      print_VkStructureType(obj->sType, "sType", 1);
29179
29180       if (obj->pNext) {
29181          dumpPNextChain(obj->pNext);
29182       } else {
29183          PRINT_SPACE
29184          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29185      }
29186
29187      print_VkBool32(obj->synchronization2, "synchronization2", 0);
29188
29189      INDENT(-4);
29190      PRINT_SPACE
29191      if (commaNeeded)
29192          _OUT << "}," << std::endl;
29193      else
29194          _OUT << "}" << std::endl;
29195 }
29196
29197 static void print_VkQueueFamilyCheckpointProperties2NV(VkQueueFamilyCheckpointProperties2NV obj, const std::string& s, bool commaNeeded=true) {
29198      PRINT_SPACE
29199      _OUT << "{" << std::endl;
29200      INDENT(4);
29201
29202      print_VkStructureType(obj.sType, "sType", 1);
29203
29204       if (obj.pNext) {
29205          dumpPNextChain(obj.pNext);
29206       } else {
29207          PRINT_SPACE
29208          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29209      }
29210
29211      print_VkPipelineStageFlags2KHR(obj.checkpointExecutionStageMask, "checkpointExecutionStageMask", 0);
29212
29213      INDENT(-4);
29214      PRINT_SPACE
29215      if (commaNeeded)
29216          _OUT << "}," << std::endl;
29217      else
29218          _OUT << "}" << std::endl;
29219 }
29220 static void print_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV * obj, const std::string& s, bool commaNeeded=true) {
29221      PRINT_SPACE
29222      _OUT << "{" << std::endl;
29223      INDENT(4);
29224
29225      print_VkStructureType(obj->sType, "sType", 1);
29226
29227       if (obj->pNext) {
29228          dumpPNextChain(obj->pNext);
29229       } else {
29230          PRINT_SPACE
29231          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29232      }
29233
29234      print_VkPipelineStageFlags2KHR(obj->checkpointExecutionStageMask, "checkpointExecutionStageMask", 0);
29235
29236      INDENT(-4);
29237      PRINT_SPACE
29238      if (commaNeeded)
29239          _OUT << "}," << std::endl;
29240      else
29241          _OUT << "}" << std::endl;
29242 }
29243
29244 static void print_VkCheckpointData2NV(VkCheckpointData2NV obj, const std::string& s, bool commaNeeded=true) {
29245      PRINT_SPACE
29246      _OUT << "{" << std::endl;
29247      INDENT(4);
29248
29249      print_VkStructureType(obj.sType, "sType", 1);
29250
29251       if (obj.pNext) {
29252          dumpPNextChain(obj.pNext);
29253       } else {
29254          PRINT_SPACE
29255          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29256      }
29257
29258      print_VkPipelineStageFlags2KHR(obj.stage, "stage", 1);
29259
29260      /** Note: Ignoring void* data. **/
29261
29262      INDENT(-4);
29263      PRINT_SPACE
29264      if (commaNeeded)
29265          _OUT << "}," << std::endl;
29266      else
29267          _OUT << "}" << std::endl;
29268 }
29269 static void print_VkCheckpointData2NV(const VkCheckpointData2NV * obj, const std::string& s, bool commaNeeded=true) {
29270      PRINT_SPACE
29271      _OUT << "{" << std::endl;
29272      INDENT(4);
29273
29274      print_VkStructureType(obj->sType, "sType", 1);
29275
29276       if (obj->pNext) {
29277          dumpPNextChain(obj->pNext);
29278       } else {
29279          PRINT_SPACE
29280          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29281      }
29282
29283      print_VkPipelineStageFlags2KHR(obj->stage, "stage", 1);
29284
29285      /** Note: Ignoring void* data. **/
29286
29287      INDENT(-4);
29288      PRINT_SPACE
29289      if (commaNeeded)
29290          _OUT << "}," << std::endl;
29291      else
29292          _OUT << "}" << std::endl;
29293 }
29294
29295 static void print_VkBufferCopy2KHR(VkBufferCopy2KHR obj, const std::string& s, bool commaNeeded=true) {
29296      PRINT_SPACE
29297      _OUT << "{" << std::endl;
29298      INDENT(4);
29299
29300      print_VkStructureType(obj.sType, "sType", 1);
29301
29302       if (obj.pNext) {
29303          dumpPNextChain(obj.pNext);
29304       } else {
29305          PRINT_SPACE
29306          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29307      }
29308
29309      print_VkDeviceSize(obj.srcOffset, "srcOffset", 1);
29310
29311      print_VkDeviceSize(obj.dstOffset, "dstOffset", 1);
29312
29313      print_VkDeviceSize(obj.size, "size", 0);
29314
29315      INDENT(-4);
29316      PRINT_SPACE
29317      if (commaNeeded)
29318          _OUT << "}," << std::endl;
29319      else
29320          _OUT << "}" << std::endl;
29321 }
29322 static void print_VkBufferCopy2KHR(const VkBufferCopy2KHR * obj, const std::string& s, bool commaNeeded=true) {
29323      PRINT_SPACE
29324      _OUT << "{" << std::endl;
29325      INDENT(4);
29326
29327      print_VkStructureType(obj->sType, "sType", 1);
29328
29329       if (obj->pNext) {
29330          dumpPNextChain(obj->pNext);
29331       } else {
29332          PRINT_SPACE
29333          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29334      }
29335
29336      print_VkDeviceSize(obj->srcOffset, "srcOffset", 1);
29337
29338      print_VkDeviceSize(obj->dstOffset, "dstOffset", 1);
29339
29340      print_VkDeviceSize(obj->size, "size", 0);
29341
29342      INDENT(-4);
29343      PRINT_SPACE
29344      if (commaNeeded)
29345          _OUT << "}," << std::endl;
29346      else
29347          _OUT << "}" << std::endl;
29348 }
29349
29350 static void print_VkCopyBufferInfo2KHR(VkCopyBufferInfo2KHR obj, const std::string& s, bool commaNeeded=true) {
29351      PRINT_SPACE
29352      _OUT << "{" << std::endl;
29353      INDENT(4);
29354
29355      print_VkStructureType(obj.sType, "sType", 1);
29356
29357       if (obj.pNext) {
29358          dumpPNextChain(obj.pNext);
29359       } else {
29360          PRINT_SPACE
29361          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29362      }
29363
29364      // CTS : required value
29365      PRINT_SPACE    _OUT << "\"" << "srcBuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
29366
29367      // CTS : required value
29368      PRINT_SPACE    _OUT << "\"" << "dstBuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
29369
29370      print_uint32_t(obj.regionCount, "regionCount", 1);
29371
29372      PRINT_SPACE
29373      _OUT << "\"pRegions\": " << std::endl;
29374      if (obj.pRegions) {
29375          PRINT_SPACE
29376          _OUT << "[" << std::endl;
29377          for (unsigned int i = 0; i < obj.regionCount; i++) {
29378            if (i+1 == obj.regionCount)
29379                print_VkBufferCopy2KHR(obj.pRegions[i], "pRegions", 0);
29380            else
29381                print_VkBufferCopy2KHR(obj.pRegions[i], "pRegions", 1);
29382          }
29383          PRINT_SPACE
29384          _OUT << "]" << std::endl;
29385     }
29386      else
29387      {
29388          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
29389      }
29390
29391      INDENT(-4);
29392      PRINT_SPACE
29393      if (commaNeeded)
29394          _OUT << "}," << std::endl;
29395      else
29396          _OUT << "}" << std::endl;
29397 }
29398 static void print_VkCopyBufferInfo2KHR(const VkCopyBufferInfo2KHR * obj, const std::string& s, bool commaNeeded=true) {
29399      PRINT_SPACE
29400      _OUT << "{" << std::endl;
29401      INDENT(4);
29402
29403      print_VkStructureType(obj->sType, "sType", 1);
29404
29405       if (obj->pNext) {
29406          dumpPNextChain(obj->pNext);
29407       } else {
29408          PRINT_SPACE
29409          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29410      }
29411
29412      // CTS : required value
29413      PRINT_SPACE    _OUT << "\"" << "srcBuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
29414
29415      // CTS : required value
29416      PRINT_SPACE    _OUT << "\"" << "dstBuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
29417
29418      print_uint32_t(obj->regionCount, "regionCount", 1);
29419
29420      PRINT_SPACE
29421      _OUT << "\"pRegions\": " << std::endl;
29422      if (obj->pRegions) {
29423          PRINT_SPACE
29424          _OUT << "[" << std::endl;
29425          for (unsigned int i = 0; i < obj->regionCount; i++) {
29426            if (i+1 == obj->regionCount)
29427                print_VkBufferCopy2KHR(obj->pRegions[i], "pRegions", 0);
29428            else
29429                print_VkBufferCopy2KHR(obj->pRegions[i], "pRegions", 1);
29430          }
29431          PRINT_SPACE
29432          _OUT << "]" << std::endl;
29433     }
29434      else
29435      {
29436          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
29437      }
29438
29439      INDENT(-4);
29440      PRINT_SPACE
29441      if (commaNeeded)
29442          _OUT << "}," << std::endl;
29443      else
29444          _OUT << "}" << std::endl;
29445 }
29446
29447 static void print_VkImageCopy2KHR(VkImageCopy2KHR obj, const std::string& s, bool commaNeeded=true) {
29448      PRINT_SPACE
29449      _OUT << "{" << std::endl;
29450      INDENT(4);
29451
29452      print_VkStructureType(obj.sType, "sType", 1);
29453
29454       if (obj.pNext) {
29455          dumpPNextChain(obj.pNext);
29456       } else {
29457          PRINT_SPACE
29458          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29459      }
29460
29461      PRINT_SPACE
29462      _OUT << "\"srcSubresource\": " << std::endl;
29463      {
29464            print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1);
29465      }
29466
29467      PRINT_SPACE
29468      _OUT << "\"srcOffset\": " << std::endl;
29469      {
29470            print_VkOffset3D(obj.srcOffset, "srcOffset", 1);
29471      }
29472
29473      PRINT_SPACE
29474      _OUT << "\"dstSubresource\": " << std::endl;
29475      {
29476            print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1);
29477      }
29478
29479      PRINT_SPACE
29480      _OUT << "\"dstOffset\": " << std::endl;
29481      {
29482            print_VkOffset3D(obj.dstOffset, "dstOffset", 1);
29483      }
29484
29485      PRINT_SPACE
29486      _OUT << "\"extent\": " << std::endl;
29487      {
29488            print_VkExtent3D(obj.extent, "extent", 0);
29489      }
29490
29491      INDENT(-4);
29492      PRINT_SPACE
29493      if (commaNeeded)
29494          _OUT << "}," << std::endl;
29495      else
29496          _OUT << "}" << std::endl;
29497 }
29498 static void print_VkImageCopy2KHR(const VkImageCopy2KHR * obj, const std::string& s, bool commaNeeded=true) {
29499      PRINT_SPACE
29500      _OUT << "{" << std::endl;
29501      INDENT(4);
29502
29503      print_VkStructureType(obj->sType, "sType", 1);
29504
29505       if (obj->pNext) {
29506          dumpPNextChain(obj->pNext);
29507       } else {
29508          PRINT_SPACE
29509          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29510      }
29511
29512      PRINT_SPACE
29513      _OUT << "\"srcSubresource\": " << std::endl;
29514      {
29515            print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1);
29516      }
29517
29518      PRINT_SPACE
29519      _OUT << "\"srcOffset\": " << std::endl;
29520      {
29521            print_VkOffset3D(obj->srcOffset, "srcOffset", 1);
29522      }
29523
29524      PRINT_SPACE
29525      _OUT << "\"dstSubresource\": " << std::endl;
29526      {
29527            print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1);
29528      }
29529
29530      PRINT_SPACE
29531      _OUT << "\"dstOffset\": " << std::endl;
29532      {
29533            print_VkOffset3D(obj->dstOffset, "dstOffset", 1);
29534      }
29535
29536      PRINT_SPACE
29537      _OUT << "\"extent\": " << std::endl;
29538      {
29539            print_VkExtent3D(obj->extent, "extent", 0);
29540      }
29541
29542      INDENT(-4);
29543      PRINT_SPACE
29544      if (commaNeeded)
29545          _OUT << "}," << std::endl;
29546      else
29547          _OUT << "}" << std::endl;
29548 }
29549
29550 static void print_VkCopyImageInfo2KHR(VkCopyImageInfo2KHR obj, const std::string& s, bool commaNeeded=true) {
29551      PRINT_SPACE
29552      _OUT << "{" << std::endl;
29553      INDENT(4);
29554
29555      print_VkStructureType(obj.sType, "sType", 1);
29556
29557       if (obj.pNext) {
29558          dumpPNextChain(obj.pNext);
29559       } else {
29560          PRINT_SPACE
29561          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29562      }
29563
29564      // CTS : required value
29565      PRINT_SPACE    _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl;
29566
29567      print_VkImageLayout(obj.srcImageLayout, "srcImageLayout", 1);
29568
29569      // CTS : required value
29570      PRINT_SPACE    _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl;
29571
29572      print_VkImageLayout(obj.dstImageLayout, "dstImageLayout", 1);
29573
29574      print_uint32_t(obj.regionCount, "regionCount", 1);
29575
29576      PRINT_SPACE
29577      _OUT << "\"pRegions\": " << std::endl;
29578      if (obj.pRegions) {
29579          PRINT_SPACE
29580          _OUT << "[" << std::endl;
29581          for (unsigned int i = 0; i < obj.regionCount; i++) {
29582            if (i+1 == obj.regionCount)
29583                print_VkImageCopy2KHR(obj.pRegions[i], "pRegions", 0);
29584            else
29585                print_VkImageCopy2KHR(obj.pRegions[i], "pRegions", 1);
29586          }
29587          PRINT_SPACE
29588          _OUT << "]" << std::endl;
29589     }
29590      else
29591      {
29592          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
29593      }
29594
29595      INDENT(-4);
29596      PRINT_SPACE
29597      if (commaNeeded)
29598          _OUT << "}," << std::endl;
29599      else
29600          _OUT << "}" << std::endl;
29601 }
29602 static void print_VkCopyImageInfo2KHR(const VkCopyImageInfo2KHR * obj, const std::string& s, bool commaNeeded=true) {
29603      PRINT_SPACE
29604      _OUT << "{" << std::endl;
29605      INDENT(4);
29606
29607      print_VkStructureType(obj->sType, "sType", 1);
29608
29609       if (obj->pNext) {
29610          dumpPNextChain(obj->pNext);
29611       } else {
29612          PRINT_SPACE
29613          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29614      }
29615
29616      // CTS : required value
29617      PRINT_SPACE    _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl;
29618
29619      print_VkImageLayout(obj->srcImageLayout, "srcImageLayout", 1);
29620
29621      // CTS : required value
29622      PRINT_SPACE    _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl;
29623
29624      print_VkImageLayout(obj->dstImageLayout, "dstImageLayout", 1);
29625
29626      print_uint32_t(obj->regionCount, "regionCount", 1);
29627
29628      PRINT_SPACE
29629      _OUT << "\"pRegions\": " << std::endl;
29630      if (obj->pRegions) {
29631          PRINT_SPACE
29632          _OUT << "[" << std::endl;
29633          for (unsigned int i = 0; i < obj->regionCount; i++) {
29634            if (i+1 == obj->regionCount)
29635                print_VkImageCopy2KHR(obj->pRegions[i], "pRegions", 0);
29636            else
29637                print_VkImageCopy2KHR(obj->pRegions[i], "pRegions", 1);
29638          }
29639          PRINT_SPACE
29640          _OUT << "]" << std::endl;
29641     }
29642      else
29643      {
29644          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
29645      }
29646
29647      INDENT(-4);
29648      PRINT_SPACE
29649      if (commaNeeded)
29650          _OUT << "}," << std::endl;
29651      else
29652          _OUT << "}" << std::endl;
29653 }
29654
29655 static void print_VkBufferImageCopy2KHR(VkBufferImageCopy2KHR obj, const std::string& s, bool commaNeeded=true) {
29656      PRINT_SPACE
29657      _OUT << "{" << std::endl;
29658      INDENT(4);
29659
29660      print_VkStructureType(obj.sType, "sType", 1);
29661
29662       if (obj.pNext) {
29663          dumpPNextChain(obj.pNext);
29664       } else {
29665          PRINT_SPACE
29666          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29667      }
29668
29669      print_VkDeviceSize(obj.bufferOffset, "bufferOffset", 1);
29670
29671      print_uint32_t(obj.bufferRowLength, "bufferRowLength", 1);
29672
29673      print_uint32_t(obj.bufferImageHeight, "bufferImageHeight", 1);
29674
29675      PRINT_SPACE
29676      _OUT << "\"imageSubresource\": " << std::endl;
29677      {
29678            print_VkImageSubresourceLayers(obj.imageSubresource, "imageSubresource", 1);
29679      }
29680
29681      PRINT_SPACE
29682      _OUT << "\"imageOffset\": " << std::endl;
29683      {
29684            print_VkOffset3D(obj.imageOffset, "imageOffset", 1);
29685      }
29686
29687      PRINT_SPACE
29688      _OUT << "\"imageExtent\": " << std::endl;
29689      {
29690            print_VkExtent3D(obj.imageExtent, "imageExtent", 0);
29691      }
29692
29693      INDENT(-4);
29694      PRINT_SPACE
29695      if (commaNeeded)
29696          _OUT << "}," << std::endl;
29697      else
29698          _OUT << "}" << std::endl;
29699 }
29700 static void print_VkBufferImageCopy2KHR(const VkBufferImageCopy2KHR * obj, const std::string& s, bool commaNeeded=true) {
29701      PRINT_SPACE
29702      _OUT << "{" << std::endl;
29703      INDENT(4);
29704
29705      print_VkStructureType(obj->sType, "sType", 1);
29706
29707       if (obj->pNext) {
29708          dumpPNextChain(obj->pNext);
29709       } else {
29710          PRINT_SPACE
29711          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29712      }
29713
29714      print_VkDeviceSize(obj->bufferOffset, "bufferOffset", 1);
29715
29716      print_uint32_t(obj->bufferRowLength, "bufferRowLength", 1);
29717
29718      print_uint32_t(obj->bufferImageHeight, "bufferImageHeight", 1);
29719
29720      PRINT_SPACE
29721      _OUT << "\"imageSubresource\": " << std::endl;
29722      {
29723            print_VkImageSubresourceLayers(obj->imageSubresource, "imageSubresource", 1);
29724      }
29725
29726      PRINT_SPACE
29727      _OUT << "\"imageOffset\": " << std::endl;
29728      {
29729            print_VkOffset3D(obj->imageOffset, "imageOffset", 1);
29730      }
29731
29732      PRINT_SPACE
29733      _OUT << "\"imageExtent\": " << std::endl;
29734      {
29735            print_VkExtent3D(obj->imageExtent, "imageExtent", 0);
29736      }
29737
29738      INDENT(-4);
29739      PRINT_SPACE
29740      if (commaNeeded)
29741          _OUT << "}," << std::endl;
29742      else
29743          _OUT << "}" << std::endl;
29744 }
29745
29746 static void print_VkCopyBufferToImageInfo2KHR(VkCopyBufferToImageInfo2KHR obj, const std::string& s, bool commaNeeded=true) {
29747      PRINT_SPACE
29748      _OUT << "{" << std::endl;
29749      INDENT(4);
29750
29751      print_VkStructureType(obj.sType, "sType", 1);
29752
29753       if (obj.pNext) {
29754          dumpPNextChain(obj.pNext);
29755       } else {
29756          PRINT_SPACE
29757          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29758      }
29759
29760      // CTS : required value
29761      PRINT_SPACE    _OUT << "\"" << "srcBuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
29762
29763      // CTS : required value
29764      PRINT_SPACE    _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl;
29765
29766      print_VkImageLayout(obj.dstImageLayout, "dstImageLayout", 1);
29767
29768      print_uint32_t(obj.regionCount, "regionCount", 1);
29769
29770      PRINT_SPACE
29771      _OUT << "\"pRegions\": " << std::endl;
29772      if (obj.pRegions) {
29773          PRINT_SPACE
29774          _OUT << "[" << std::endl;
29775          for (unsigned int i = 0; i < obj.regionCount; i++) {
29776            if (i+1 == obj.regionCount)
29777                print_VkBufferImageCopy2KHR(obj.pRegions[i], "pRegions", 0);
29778            else
29779                print_VkBufferImageCopy2KHR(obj.pRegions[i], "pRegions", 1);
29780          }
29781          PRINT_SPACE
29782          _OUT << "]" << std::endl;
29783     }
29784      else
29785      {
29786          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
29787      }
29788
29789      INDENT(-4);
29790      PRINT_SPACE
29791      if (commaNeeded)
29792          _OUT << "}," << std::endl;
29793      else
29794          _OUT << "}" << std::endl;
29795 }
29796 static void print_VkCopyBufferToImageInfo2KHR(const VkCopyBufferToImageInfo2KHR * obj, const std::string& s, bool commaNeeded=true) {
29797      PRINT_SPACE
29798      _OUT << "{" << std::endl;
29799      INDENT(4);
29800
29801      print_VkStructureType(obj->sType, "sType", 1);
29802
29803       if (obj->pNext) {
29804          dumpPNextChain(obj->pNext);
29805       } else {
29806          PRINT_SPACE
29807          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29808      }
29809
29810      // CTS : required value
29811      PRINT_SPACE    _OUT << "\"" << "srcBuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
29812
29813      // CTS : required value
29814      PRINT_SPACE    _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl;
29815
29816      print_VkImageLayout(obj->dstImageLayout, "dstImageLayout", 1);
29817
29818      print_uint32_t(obj->regionCount, "regionCount", 1);
29819
29820      PRINT_SPACE
29821      _OUT << "\"pRegions\": " << std::endl;
29822      if (obj->pRegions) {
29823          PRINT_SPACE
29824          _OUT << "[" << std::endl;
29825          for (unsigned int i = 0; i < obj->regionCount; i++) {
29826            if (i+1 == obj->regionCount)
29827                print_VkBufferImageCopy2KHR(obj->pRegions[i], "pRegions", 0);
29828            else
29829                print_VkBufferImageCopy2KHR(obj->pRegions[i], "pRegions", 1);
29830          }
29831          PRINT_SPACE
29832          _OUT << "]" << std::endl;
29833     }
29834      else
29835      {
29836          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
29837      }
29838
29839      INDENT(-4);
29840      PRINT_SPACE
29841      if (commaNeeded)
29842          _OUT << "}," << std::endl;
29843      else
29844          _OUT << "}" << std::endl;
29845 }
29846
29847 static void print_VkCopyImageToBufferInfo2KHR(VkCopyImageToBufferInfo2KHR obj, const std::string& s, bool commaNeeded=true) {
29848      PRINT_SPACE
29849      _OUT << "{" << std::endl;
29850      INDENT(4);
29851
29852      print_VkStructureType(obj.sType, "sType", 1);
29853
29854       if (obj.pNext) {
29855          dumpPNextChain(obj.pNext);
29856       } else {
29857          PRINT_SPACE
29858          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29859      }
29860
29861      // CTS : required value
29862      PRINT_SPACE    _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl;
29863
29864      print_VkImageLayout(obj.srcImageLayout, "srcImageLayout", 1);
29865
29866      // CTS : required value
29867      PRINT_SPACE    _OUT << "\"" << "dstBuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
29868
29869      print_uint32_t(obj.regionCount, "regionCount", 1);
29870
29871      PRINT_SPACE
29872      _OUT << "\"pRegions\": " << std::endl;
29873      if (obj.pRegions) {
29874          PRINT_SPACE
29875          _OUT << "[" << std::endl;
29876          for (unsigned int i = 0; i < obj.regionCount; i++) {
29877            if (i+1 == obj.regionCount)
29878                print_VkBufferImageCopy2KHR(obj.pRegions[i], "pRegions", 0);
29879            else
29880                print_VkBufferImageCopy2KHR(obj.pRegions[i], "pRegions", 1);
29881          }
29882          PRINT_SPACE
29883          _OUT << "]" << std::endl;
29884     }
29885      else
29886      {
29887          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
29888      }
29889
29890      INDENT(-4);
29891      PRINT_SPACE
29892      if (commaNeeded)
29893          _OUT << "}," << std::endl;
29894      else
29895          _OUT << "}" << std::endl;
29896 }
29897 static void print_VkCopyImageToBufferInfo2KHR(const VkCopyImageToBufferInfo2KHR * obj, const std::string& s, bool commaNeeded=true) {
29898      PRINT_SPACE
29899      _OUT << "{" << std::endl;
29900      INDENT(4);
29901
29902      print_VkStructureType(obj->sType, "sType", 1);
29903
29904       if (obj->pNext) {
29905          dumpPNextChain(obj->pNext);
29906       } else {
29907          PRINT_SPACE
29908          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29909      }
29910
29911      // CTS : required value
29912      PRINT_SPACE    _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl;
29913
29914      print_VkImageLayout(obj->srcImageLayout, "srcImageLayout", 1);
29915
29916      // CTS : required value
29917      PRINT_SPACE    _OUT << "\"" << "dstBuffer" << "\"" << " : " << "\"" << "\"," << std::endl;
29918
29919      print_uint32_t(obj->regionCount, "regionCount", 1);
29920
29921      PRINT_SPACE
29922      _OUT << "\"pRegions\": " << std::endl;
29923      if (obj->pRegions) {
29924          PRINT_SPACE
29925          _OUT << "[" << std::endl;
29926          for (unsigned int i = 0; i < obj->regionCount; i++) {
29927            if (i+1 == obj->regionCount)
29928                print_VkBufferImageCopy2KHR(obj->pRegions[i], "pRegions", 0);
29929            else
29930                print_VkBufferImageCopy2KHR(obj->pRegions[i], "pRegions", 1);
29931          }
29932          PRINT_SPACE
29933          _OUT << "]" << std::endl;
29934     }
29935      else
29936      {
29937          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
29938      }
29939
29940      INDENT(-4);
29941      PRINT_SPACE
29942      if (commaNeeded)
29943          _OUT << "}," << std::endl;
29944      else
29945          _OUT << "}" << std::endl;
29946 }
29947
29948 static void print_VkImageBlit2KHR(VkImageBlit2KHR obj, const std::string& s, bool commaNeeded=true) {
29949      PRINT_SPACE
29950      _OUT << "{" << std::endl;
29951      INDENT(4);
29952
29953      print_VkStructureType(obj.sType, "sType", 1);
29954
29955       if (obj.pNext) {
29956          dumpPNextChain(obj.pNext);
29957       } else {
29958          PRINT_SPACE
29959          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
29960      }
29961
29962      PRINT_SPACE
29963      _OUT << "\"srcSubresource\": " << std::endl;
29964      {
29965            print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1);
29966      }
29967
29968      PRINT_SPACE
29969      _OUT << "\"srcOffsets\":" << std::endl;
29970      PRINT_SPACE
29971      if (obj.srcOffsets) {
29972        _OUT << "[" << std::endl;
29973        for (unsigned int i = 0; i < 2; i++) {
29974            bool isCommaNeeded = (i+1) != 2;
29975            print_VkOffset3D(obj.srcOffsets[i], "", isCommaNeeded);
29976        }
29977        PRINT_SPACE
29978        _OUT << "]" << "," << std::endl;
29979      } else {
29980        _OUT << "\"NULL\"" << "," << std::endl;
29981      }
29982
29983      PRINT_SPACE
29984      _OUT << "\"dstSubresource\": " << std::endl;
29985      {
29986            print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1);
29987      }
29988
29989      PRINT_SPACE
29990      _OUT << "\"dstOffsets\":" << std::endl;
29991      PRINT_SPACE
29992      if (obj.dstOffsets) {
29993        _OUT << "[" << std::endl;
29994        for (unsigned int i = 0; i < 2; i++) {
29995            bool isCommaNeeded = (i+1) != 2;
29996            print_VkOffset3D(obj.dstOffsets[i], "", isCommaNeeded);
29997        }
29998        PRINT_SPACE
29999        _OUT << "]" << "" << std::endl;
30000      } else {
30001        _OUT << "\"NULL\"" << "" << std::endl;
30002      }
30003
30004      INDENT(-4);
30005      PRINT_SPACE
30006      if (commaNeeded)
30007          _OUT << "}," << std::endl;
30008      else
30009          _OUT << "}" << std::endl;
30010 }
30011 static void print_VkImageBlit2KHR(const VkImageBlit2KHR * obj, const std::string& s, bool commaNeeded=true) {
30012      PRINT_SPACE
30013      _OUT << "{" << std::endl;
30014      INDENT(4);
30015
30016      print_VkStructureType(obj->sType, "sType", 1);
30017
30018       if (obj->pNext) {
30019          dumpPNextChain(obj->pNext);
30020       } else {
30021          PRINT_SPACE
30022          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30023      }
30024
30025      PRINT_SPACE
30026      _OUT << "\"srcSubresource\": " << std::endl;
30027      {
30028            print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1);
30029      }
30030
30031      PRINT_SPACE
30032      _OUT << "\"srcOffsets\":" << std::endl;
30033      PRINT_SPACE
30034      if (obj->srcOffsets) {
30035        _OUT << "[" << std::endl;
30036        for (unsigned int i = 0; i < 2; i++) {
30037            bool isCommaNeeded = (i+1) != 2;
30038            print_VkOffset3D(obj->srcOffsets[i], "", isCommaNeeded);
30039        }
30040        PRINT_SPACE
30041        _OUT << "]" << "," << std::endl;
30042      } else {
30043        _OUT << "\"NULL\"" << "," << std::endl;
30044      }
30045
30046      PRINT_SPACE
30047      _OUT << "\"dstSubresource\": " << std::endl;
30048      {
30049            print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1);
30050      }
30051
30052      PRINT_SPACE
30053      _OUT << "\"dstOffsets\":" << std::endl;
30054      PRINT_SPACE
30055      if (obj->dstOffsets) {
30056        _OUT << "[" << std::endl;
30057        for (unsigned int i = 0; i < 2; i++) {
30058            bool isCommaNeeded = (i+1) != 2;
30059            print_VkOffset3D(obj->dstOffsets[i], "", isCommaNeeded);
30060        }
30061        PRINT_SPACE
30062        _OUT << "]" << "" << std::endl;
30063      } else {
30064        _OUT << "\"NULL\"" << "" << std::endl;
30065      }
30066
30067      INDENT(-4);
30068      PRINT_SPACE
30069      if (commaNeeded)
30070          _OUT << "}," << std::endl;
30071      else
30072          _OUT << "}" << std::endl;
30073 }
30074
30075 static void print_VkBlitImageInfo2KHR(VkBlitImageInfo2KHR obj, const std::string& s, bool commaNeeded=true) {
30076      PRINT_SPACE
30077      _OUT << "{" << std::endl;
30078      INDENT(4);
30079
30080      print_VkStructureType(obj.sType, "sType", 1);
30081
30082       if (obj.pNext) {
30083          dumpPNextChain(obj.pNext);
30084       } else {
30085          PRINT_SPACE
30086          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30087      }
30088
30089      // CTS : required value
30090      PRINT_SPACE    _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl;
30091
30092      print_VkImageLayout(obj.srcImageLayout, "srcImageLayout", 1);
30093
30094      // CTS : required value
30095      PRINT_SPACE    _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl;
30096
30097      print_VkImageLayout(obj.dstImageLayout, "dstImageLayout", 1);
30098
30099      print_uint32_t(obj.regionCount, "regionCount", 1);
30100
30101      PRINT_SPACE
30102      _OUT << "\"pRegions\": " << std::endl;
30103      if (obj.pRegions) {
30104          PRINT_SPACE
30105          _OUT << "[" << std::endl;
30106          for (unsigned int i = 0; i < obj.regionCount; i++) {
30107            if (i+1 == obj.regionCount)
30108                print_VkImageBlit2KHR(obj.pRegions[i], "pRegions", 0);
30109            else
30110                print_VkImageBlit2KHR(obj.pRegions[i], "pRegions", 1);
30111          }
30112          PRINT_SPACE
30113          _OUT << "]," << std::endl;
30114     }
30115      else
30116      {
30117          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
30118      }
30119
30120      print_VkFilter(obj.filter, "filter", 0);
30121
30122      INDENT(-4);
30123      PRINT_SPACE
30124      if (commaNeeded)
30125          _OUT << "}," << std::endl;
30126      else
30127          _OUT << "}" << std::endl;
30128 }
30129 static void print_VkBlitImageInfo2KHR(const VkBlitImageInfo2KHR * obj, const std::string& s, bool commaNeeded=true) {
30130      PRINT_SPACE
30131      _OUT << "{" << std::endl;
30132      INDENT(4);
30133
30134      print_VkStructureType(obj->sType, "sType", 1);
30135
30136       if (obj->pNext) {
30137          dumpPNextChain(obj->pNext);
30138       } else {
30139          PRINT_SPACE
30140          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30141      }
30142
30143      // CTS : required value
30144      PRINT_SPACE    _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl;
30145
30146      print_VkImageLayout(obj->srcImageLayout, "srcImageLayout", 1);
30147
30148      // CTS : required value
30149      PRINT_SPACE    _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl;
30150
30151      print_VkImageLayout(obj->dstImageLayout, "dstImageLayout", 1);
30152
30153      print_uint32_t(obj->regionCount, "regionCount", 1);
30154
30155      PRINT_SPACE
30156      _OUT << "\"pRegions\": " << std::endl;
30157      if (obj->pRegions) {
30158          PRINT_SPACE
30159          _OUT << "[" << std::endl;
30160          for (unsigned int i = 0; i < obj->regionCount; i++) {
30161            if (i+1 == obj->regionCount)
30162                print_VkImageBlit2KHR(obj->pRegions[i], "pRegions", 0);
30163            else
30164                print_VkImageBlit2KHR(obj->pRegions[i], "pRegions", 1);
30165          }
30166          PRINT_SPACE
30167          _OUT << "]," << std::endl;
30168     }
30169      else
30170      {
30171          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
30172      }
30173
30174      print_VkFilter(obj->filter, "filter", 0);
30175
30176      INDENT(-4);
30177      PRINT_SPACE
30178      if (commaNeeded)
30179          _OUT << "}," << std::endl;
30180      else
30181          _OUT << "}" << std::endl;
30182 }
30183
30184 static void print_VkImageResolve2KHR(VkImageResolve2KHR obj, const std::string& s, bool commaNeeded=true) {
30185      PRINT_SPACE
30186      _OUT << "{" << std::endl;
30187      INDENT(4);
30188
30189      print_VkStructureType(obj.sType, "sType", 1);
30190
30191       if (obj.pNext) {
30192          dumpPNextChain(obj.pNext);
30193       } else {
30194          PRINT_SPACE
30195          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30196      }
30197
30198      PRINT_SPACE
30199      _OUT << "\"srcSubresource\": " << std::endl;
30200      {
30201            print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1);
30202      }
30203
30204      PRINT_SPACE
30205      _OUT << "\"srcOffset\": " << std::endl;
30206      {
30207            print_VkOffset3D(obj.srcOffset, "srcOffset", 1);
30208      }
30209
30210      PRINT_SPACE
30211      _OUT << "\"dstSubresource\": " << std::endl;
30212      {
30213            print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1);
30214      }
30215
30216      PRINT_SPACE
30217      _OUT << "\"dstOffset\": " << std::endl;
30218      {
30219            print_VkOffset3D(obj.dstOffset, "dstOffset", 1);
30220      }
30221
30222      PRINT_SPACE
30223      _OUT << "\"extent\": " << std::endl;
30224      {
30225            print_VkExtent3D(obj.extent, "extent", 0);
30226      }
30227
30228      INDENT(-4);
30229      PRINT_SPACE
30230      if (commaNeeded)
30231          _OUT << "}," << std::endl;
30232      else
30233          _OUT << "}" << std::endl;
30234 }
30235 static void print_VkImageResolve2KHR(const VkImageResolve2KHR * obj, const std::string& s, bool commaNeeded=true) {
30236      PRINT_SPACE
30237      _OUT << "{" << std::endl;
30238      INDENT(4);
30239
30240      print_VkStructureType(obj->sType, "sType", 1);
30241
30242       if (obj->pNext) {
30243          dumpPNextChain(obj->pNext);
30244       } else {
30245          PRINT_SPACE
30246          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30247      }
30248
30249      PRINT_SPACE
30250      _OUT << "\"srcSubresource\": " << std::endl;
30251      {
30252            print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1);
30253      }
30254
30255      PRINT_SPACE
30256      _OUT << "\"srcOffset\": " << std::endl;
30257      {
30258            print_VkOffset3D(obj->srcOffset, "srcOffset", 1);
30259      }
30260
30261      PRINT_SPACE
30262      _OUT << "\"dstSubresource\": " << std::endl;
30263      {
30264            print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1);
30265      }
30266
30267      PRINT_SPACE
30268      _OUT << "\"dstOffset\": " << std::endl;
30269      {
30270            print_VkOffset3D(obj->dstOffset, "dstOffset", 1);
30271      }
30272
30273      PRINT_SPACE
30274      _OUT << "\"extent\": " << std::endl;
30275      {
30276            print_VkExtent3D(obj->extent, "extent", 0);
30277      }
30278
30279      INDENT(-4);
30280      PRINT_SPACE
30281      if (commaNeeded)
30282          _OUT << "}," << std::endl;
30283      else
30284          _OUT << "}" << std::endl;
30285 }
30286
30287 static void print_VkResolveImageInfo2KHR(VkResolveImageInfo2KHR obj, const std::string& s, bool commaNeeded=true) {
30288      PRINT_SPACE
30289      _OUT << "{" << std::endl;
30290      INDENT(4);
30291
30292      print_VkStructureType(obj.sType, "sType", 1);
30293
30294       if (obj.pNext) {
30295          dumpPNextChain(obj.pNext);
30296       } else {
30297          PRINT_SPACE
30298          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30299      }
30300
30301      // CTS : required value
30302      PRINT_SPACE    _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl;
30303
30304      print_VkImageLayout(obj.srcImageLayout, "srcImageLayout", 1);
30305
30306      // CTS : required value
30307      PRINT_SPACE    _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl;
30308
30309      print_VkImageLayout(obj.dstImageLayout, "dstImageLayout", 1);
30310
30311      print_uint32_t(obj.regionCount, "regionCount", 1);
30312
30313      PRINT_SPACE
30314      _OUT << "\"pRegions\": " << std::endl;
30315      if (obj.pRegions) {
30316          PRINT_SPACE
30317          _OUT << "[" << std::endl;
30318          for (unsigned int i = 0; i < obj.regionCount; i++) {
30319            if (i+1 == obj.regionCount)
30320                print_VkImageResolve2KHR(obj.pRegions[i], "pRegions", 0);
30321            else
30322                print_VkImageResolve2KHR(obj.pRegions[i], "pRegions", 1);
30323          }
30324          PRINT_SPACE
30325          _OUT << "]" << std::endl;
30326     }
30327      else
30328      {
30329          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
30330      }
30331
30332      INDENT(-4);
30333      PRINT_SPACE
30334      if (commaNeeded)
30335          _OUT << "}," << std::endl;
30336      else
30337          _OUT << "}" << std::endl;
30338 }
30339 static void print_VkResolveImageInfo2KHR(const VkResolveImageInfo2KHR * obj, const std::string& s, bool commaNeeded=true) {
30340      PRINT_SPACE
30341      _OUT << "{" << std::endl;
30342      INDENT(4);
30343
30344      print_VkStructureType(obj->sType, "sType", 1);
30345
30346       if (obj->pNext) {
30347          dumpPNextChain(obj->pNext);
30348       } else {
30349          PRINT_SPACE
30350          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30351      }
30352
30353      // CTS : required value
30354      PRINT_SPACE    _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl;
30355
30356      print_VkImageLayout(obj->srcImageLayout, "srcImageLayout", 1);
30357
30358      // CTS : required value
30359      PRINT_SPACE    _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl;
30360
30361      print_VkImageLayout(obj->dstImageLayout, "dstImageLayout", 1);
30362
30363      print_uint32_t(obj->regionCount, "regionCount", 1);
30364
30365      PRINT_SPACE
30366      _OUT << "\"pRegions\": " << std::endl;
30367      if (obj->pRegions) {
30368          PRINT_SPACE
30369          _OUT << "[" << std::endl;
30370          for (unsigned int i = 0; i < obj->regionCount; i++) {
30371            if (i+1 == obj->regionCount)
30372                print_VkImageResolve2KHR(obj->pRegions[i], "pRegions", 0);
30373            else
30374                print_VkImageResolve2KHR(obj->pRegions[i], "pRegions", 1);
30375          }
30376          PRINT_SPACE
30377          _OUT << "]" << std::endl;
30378     }
30379      else
30380      {
30381          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
30382      }
30383
30384      INDENT(-4);
30385      PRINT_SPACE
30386      if (commaNeeded)
30387          _OUT << "}," << std::endl;
30388      else
30389          _OUT << "}" << std::endl;
30390 }
30391
30392 static void print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
30393      PRINT_SPACE
30394      _OUT << "{" << std::endl;
30395      INDENT(4);
30396
30397      print_VkStructureType(obj.sType, "sType", 1);
30398
30399       if (obj.pNext) {
30400          dumpPNextChain(obj.pNext);
30401       } else {
30402          PRINT_SPACE
30403          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30404      }
30405
30406      print_VkBool32(obj.textureCompressionASTC_HDR, "textureCompressionASTC_HDR", 0);
30407
30408      INDENT(-4);
30409      PRINT_SPACE
30410      if (commaNeeded)
30411          _OUT << "}," << std::endl;
30412      else
30413          _OUT << "}" << std::endl;
30414 }
30415 static void print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
30416      PRINT_SPACE
30417      _OUT << "{" << std::endl;
30418      INDENT(4);
30419
30420      print_VkStructureType(obj->sType, "sType", 1);
30421
30422       if (obj->pNext) {
30423          dumpPNextChain(obj->pNext);
30424       } else {
30425          PRINT_SPACE
30426          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30427      }
30428
30429      print_VkBool32(obj->textureCompressionASTC_HDR, "textureCompressionASTC_HDR", 0);
30430
30431      INDENT(-4);
30432      PRINT_SPACE
30433      if (commaNeeded)
30434          _OUT << "}," << std::endl;
30435      else
30436          _OUT << "}" << std::endl;
30437 }
30438
30439 static void print_VkImageViewASTCDecodeModeEXT(VkImageViewASTCDecodeModeEXT obj, const std::string& s, bool commaNeeded=true) {
30440      PRINT_SPACE
30441      _OUT << "{" << std::endl;
30442      INDENT(4);
30443
30444      print_VkStructureType(obj.sType, "sType", 1);
30445
30446       if (obj.pNext) {
30447          dumpPNextChain(obj.pNext);
30448       } else {
30449          PRINT_SPACE
30450          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30451      }
30452
30453      print_VkFormat(obj.decodeMode, "decodeMode", 0);
30454
30455      INDENT(-4);
30456      PRINT_SPACE
30457      if (commaNeeded)
30458          _OUT << "}," << std::endl;
30459      else
30460          _OUT << "}" << std::endl;
30461 }
30462 static void print_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT * obj, const std::string& s, bool commaNeeded=true) {
30463      PRINT_SPACE
30464      _OUT << "{" << std::endl;
30465      INDENT(4);
30466
30467      print_VkStructureType(obj->sType, "sType", 1);
30468
30469       if (obj->pNext) {
30470          dumpPNextChain(obj->pNext);
30471       } else {
30472          PRINT_SPACE
30473          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30474      }
30475
30476      print_VkFormat(obj->decodeMode, "decodeMode", 0);
30477
30478      INDENT(-4);
30479      PRINT_SPACE
30480      if (commaNeeded)
30481          _OUT << "}," << std::endl;
30482      else
30483          _OUT << "}" << std::endl;
30484 }
30485
30486 static void print_VkPhysicalDeviceASTCDecodeFeaturesEXT(VkPhysicalDeviceASTCDecodeFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
30487      PRINT_SPACE
30488      _OUT << "{" << std::endl;
30489      INDENT(4);
30490
30491      print_VkStructureType(obj.sType, "sType", 1);
30492
30493       if (obj.pNext) {
30494          dumpPNextChain(obj.pNext);
30495       } else {
30496          PRINT_SPACE
30497          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30498      }
30499
30500      print_VkBool32(obj.decodeModeSharedExponent, "decodeModeSharedExponent", 0);
30501
30502      INDENT(-4);
30503      PRINT_SPACE
30504      if (commaNeeded)
30505          _OUT << "}," << std::endl;
30506      else
30507          _OUT << "}" << std::endl;
30508 }
30509 static void print_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
30510      PRINT_SPACE
30511      _OUT << "{" << std::endl;
30512      INDENT(4);
30513
30514      print_VkStructureType(obj->sType, "sType", 1);
30515
30516       if (obj->pNext) {
30517          dumpPNextChain(obj->pNext);
30518       } else {
30519          PRINT_SPACE
30520          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30521      }
30522
30523      print_VkBool32(obj->decodeModeSharedExponent, "decodeModeSharedExponent", 0);
30524
30525      INDENT(-4);
30526      PRINT_SPACE
30527      if (commaNeeded)
30528          _OUT << "}," << std::endl;
30529      else
30530          _OUT << "}" << std::endl;
30531 }
30532
30533 static std::map<deUint64, std::string> VkSurfaceCounterFlagBitsEXT_map = {
30534     std::make_pair(1ULL << 0, "VK_SURFACE_COUNTER_VBLANK_BIT_EXT"),
30535 };
30536 static void print_VkSurfaceCounterFlagBitsEXT(VkSurfaceCounterFlagBitsEXT obj, const std::string& str, bool commaNeeded=true) {
30537      PRINT_SPACE
30538      if (str != "") _OUT << "\"" << str << "\"" << " : ";
30539      if (commaNeeded)
30540          _OUT << "\"" <<  VkSurfaceCounterFlagBitsEXT_map[obj] << "\"," << std::endl;
30541      else
30542          _OUT << "\"" << VkSurfaceCounterFlagBitsEXT_map[obj] << "\"" << std::endl;
30543 }
30544 static void print_VkSurfaceCounterFlagBitsEXT(const VkSurfaceCounterFlagBitsEXT * obj, const std::string& str, bool commaNeeded=true) {
30545      PRINT_SPACE
30546      if (str != "") _OUT << "\"" << str << "\"" << " : ";
30547      if (commaNeeded)
30548          _OUT << "\"" <<  VkSurfaceCounterFlagBitsEXT_map[*obj] << "\"," << std::endl;
30549      else
30550          _OUT << "\"" << VkSurfaceCounterFlagBitsEXT_map[*obj] << "\"" << std::endl;
30551 }
30552
30553 static void print_VkSurfaceCounterFlagsEXT(VkSurfaceCounterFlagsEXT obj, const std::string& str, bool commaNeeded=true) {
30554      PRINT_SPACE
30555      if (str != "") _OUT << "\"" << str << "\"" << " : ";
30556      const int max_bits = 64; // We don't expect the number to be larger.
30557      std::bitset<max_bits> b(obj);
30558      _OUT << "\"";
30559      if (obj == 0) _OUT << "0";
30560      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
30561          if (b[i] == 1) {
30562              bitCount++;
30563              if (bitCount < b.count())
30564                  _OUT << VkSurfaceCounterFlagBitsEXT_map[1ULL<<i] << " | ";
30565              else
30566                  _OUT << VkSurfaceCounterFlagBitsEXT_map[1ULL<<i];
30567          }
30568      }
30569      if (commaNeeded)
30570        _OUT << "\"" << ",";
30571      else
30572        _OUT << "\""<< "";
30573      _OUT << std::endl;
30574 }
30575 static void print_VkSurfaceCounterFlagsEXT(const VkSurfaceCounterFlagsEXT * obj, const std::string& str, bool commaNeeded=true) {
30576      PRINT_SPACE
30577      if (str != "") _OUT << "\"" << str << "\"" << " : ";
30578      const int max_bits = 64; // We don't expect the number to be larger.
30579      std::bitset<max_bits> b(obj);
30580      _OUT << "\"";
30581      if (obj == 0) _OUT << "0";
30582      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
30583          if (b[i] == 1) {
30584              bitCount++;
30585              if (bitCount < b.count())
30586                  _OUT << VkSurfaceCounterFlagBitsEXT_map[1ULL<<i] << " | ";
30587              else
30588                  _OUT << VkSurfaceCounterFlagBitsEXT_map[1ULL<<i];
30589          }
30590      }
30591      if (commaNeeded)
30592        _OUT << "\"" << ",";
30593      else
30594        _OUT << "\""<< "";
30595      _OUT << std::endl;
30596 }
30597
30598 static void print_VkSurfaceCapabilities2EXT(VkSurfaceCapabilities2EXT obj, const std::string& s, bool commaNeeded=true) {
30599      PRINT_SPACE
30600      _OUT << "{" << std::endl;
30601      INDENT(4);
30602
30603      print_VkStructureType(obj.sType, "sType", 1);
30604
30605       if (obj.pNext) {
30606          dumpPNextChain(obj.pNext);
30607       } else {
30608          PRINT_SPACE
30609          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30610      }
30611
30612      print_uint32_t(obj.minImageCount, "minImageCount", 1);
30613
30614      print_uint32_t(obj.maxImageCount, "maxImageCount", 1);
30615
30616      PRINT_SPACE
30617      _OUT << "\"currentExtent\": " << std::endl;
30618      {
30619            print_VkExtent2D(obj.currentExtent, "currentExtent", 1);
30620      }
30621
30622      PRINT_SPACE
30623      _OUT << "\"minImageExtent\": " << std::endl;
30624      {
30625            print_VkExtent2D(obj.minImageExtent, "minImageExtent", 1);
30626      }
30627
30628      PRINT_SPACE
30629      _OUT << "\"maxImageExtent\": " << std::endl;
30630      {
30631            print_VkExtent2D(obj.maxImageExtent, "maxImageExtent", 1);
30632      }
30633
30634      print_uint32_t(obj.maxImageArrayLayers, "maxImageArrayLayers", 1);
30635
30636      print_VkSurfaceTransformFlagsKHR(obj.supportedTransforms, "supportedTransforms", 1);
30637
30638      print_VkSurfaceTransformFlagBitsKHR(obj.currentTransform, "currentTransform", 1);
30639
30640      print_VkCompositeAlphaFlagsKHR(obj.supportedCompositeAlpha, "supportedCompositeAlpha", 1);
30641
30642      print_VkImageUsageFlags(obj.supportedUsageFlags, "supportedUsageFlags", 1);
30643
30644      print_VkSurfaceCounterFlagsEXT(obj.supportedSurfaceCounters, "supportedSurfaceCounters", 0);
30645
30646      INDENT(-4);
30647      PRINT_SPACE
30648      if (commaNeeded)
30649          _OUT << "}," << std::endl;
30650      else
30651          _OUT << "}" << std::endl;
30652 }
30653 static void print_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT * obj, const std::string& s, bool commaNeeded=true) {
30654      PRINT_SPACE
30655      _OUT << "{" << std::endl;
30656      INDENT(4);
30657
30658      print_VkStructureType(obj->sType, "sType", 1);
30659
30660       if (obj->pNext) {
30661          dumpPNextChain(obj->pNext);
30662       } else {
30663          PRINT_SPACE
30664          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30665      }
30666
30667      print_uint32_t(obj->minImageCount, "minImageCount", 1);
30668
30669      print_uint32_t(obj->maxImageCount, "maxImageCount", 1);
30670
30671      PRINT_SPACE
30672      _OUT << "\"currentExtent\": " << std::endl;
30673      {
30674            print_VkExtent2D(obj->currentExtent, "currentExtent", 1);
30675      }
30676
30677      PRINT_SPACE
30678      _OUT << "\"minImageExtent\": " << std::endl;
30679      {
30680            print_VkExtent2D(obj->minImageExtent, "minImageExtent", 1);
30681      }
30682
30683      PRINT_SPACE
30684      _OUT << "\"maxImageExtent\": " << std::endl;
30685      {
30686            print_VkExtent2D(obj->maxImageExtent, "maxImageExtent", 1);
30687      }
30688
30689      print_uint32_t(obj->maxImageArrayLayers, "maxImageArrayLayers", 1);
30690
30691      print_VkSurfaceTransformFlagsKHR(obj->supportedTransforms, "supportedTransforms", 1);
30692
30693      print_VkSurfaceTransformFlagBitsKHR(obj->currentTransform, "currentTransform", 1);
30694
30695      print_VkCompositeAlphaFlagsKHR(obj->supportedCompositeAlpha, "supportedCompositeAlpha", 1);
30696
30697      print_VkImageUsageFlags(obj->supportedUsageFlags, "supportedUsageFlags", 1);
30698
30699      print_VkSurfaceCounterFlagsEXT(obj->supportedSurfaceCounters, "supportedSurfaceCounters", 0);
30700
30701      INDENT(-4);
30702      PRINT_SPACE
30703      if (commaNeeded)
30704          _OUT << "}," << std::endl;
30705      else
30706          _OUT << "}" << std::endl;
30707 }
30708
30709 static std::map<deUint64, std::string> VkDisplayPowerStateEXT_map = {
30710     std::make_pair(0, "VK_DISPLAY_POWER_STATE_OFF_EXT"),
30711     std::make_pair(1, "VK_DISPLAY_POWER_STATE_SUSPEND_EXT"),
30712     std::make_pair(2, "VK_DISPLAY_POWER_STATE_ON_EXT"),
30713 };
30714 static void print_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT obj, const std::string& str, bool commaNeeded=true) {
30715      PRINT_SPACE
30716      if (str != "") _OUT << "\"" << str << "\"" << " : ";
30717      if (commaNeeded)
30718          _OUT << "\"" <<  VkDisplayPowerStateEXT_map[obj] << "\"," << std::endl;
30719      else
30720          _OUT << "\"" << VkDisplayPowerStateEXT_map[obj] << "\"" << std::endl;
30721 }
30722 static void print_VkDisplayPowerStateEXT(const VkDisplayPowerStateEXT * obj, const std::string& str, bool commaNeeded=true) {
30723      PRINT_SPACE
30724      if (str != "") _OUT << "\"" << str << "\"" << " : ";
30725      if (commaNeeded)
30726          _OUT << "\"" <<  VkDisplayPowerStateEXT_map[*obj] << "\"," << std::endl;
30727      else
30728          _OUT << "\"" << VkDisplayPowerStateEXT_map[*obj] << "\"" << std::endl;
30729 }
30730
30731 static std::map<deUint64, std::string> VkDeviceEventTypeEXT_map = {
30732     std::make_pair(0, "VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT"),
30733 };
30734 static void print_VkDeviceEventTypeEXT(VkDeviceEventTypeEXT obj, const std::string& str, bool commaNeeded=true) {
30735      PRINT_SPACE
30736      if (str != "") _OUT << "\"" << str << "\"" << " : ";
30737      if (commaNeeded)
30738          _OUT << "\"" <<  VkDeviceEventTypeEXT_map[obj] << "\"," << std::endl;
30739      else
30740          _OUT << "\"" << VkDeviceEventTypeEXT_map[obj] << "\"" << std::endl;
30741 }
30742 static void print_VkDeviceEventTypeEXT(const VkDeviceEventTypeEXT * obj, const std::string& str, bool commaNeeded=true) {
30743      PRINT_SPACE
30744      if (str != "") _OUT << "\"" << str << "\"" << " : ";
30745      if (commaNeeded)
30746          _OUT << "\"" <<  VkDeviceEventTypeEXT_map[*obj] << "\"," << std::endl;
30747      else
30748          _OUT << "\"" << VkDeviceEventTypeEXT_map[*obj] << "\"" << std::endl;
30749 }
30750
30751 static std::map<deUint64, std::string> VkDisplayEventTypeEXT_map = {
30752     std::make_pair(0, "VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT"),
30753 };
30754 static void print_VkDisplayEventTypeEXT(VkDisplayEventTypeEXT obj, const std::string& str, bool commaNeeded=true) {
30755      PRINT_SPACE
30756      if (str != "") _OUT << "\"" << str << "\"" << " : ";
30757      if (commaNeeded)
30758          _OUT << "\"" <<  VkDisplayEventTypeEXT_map[obj] << "\"," << std::endl;
30759      else
30760          _OUT << "\"" << VkDisplayEventTypeEXT_map[obj] << "\"" << std::endl;
30761 }
30762 static void print_VkDisplayEventTypeEXT(const VkDisplayEventTypeEXT * obj, const std::string& str, bool commaNeeded=true) {
30763      PRINT_SPACE
30764      if (str != "") _OUT << "\"" << str << "\"" << " : ";
30765      if (commaNeeded)
30766          _OUT << "\"" <<  VkDisplayEventTypeEXT_map[*obj] << "\"," << std::endl;
30767      else
30768          _OUT << "\"" << VkDisplayEventTypeEXT_map[*obj] << "\"" << std::endl;
30769 }
30770
30771 static void print_VkDisplayPowerInfoEXT(VkDisplayPowerInfoEXT obj, const std::string& s, bool commaNeeded=true) {
30772      PRINT_SPACE
30773      _OUT << "{" << std::endl;
30774      INDENT(4);
30775
30776      print_VkStructureType(obj.sType, "sType", 1);
30777
30778       if (obj.pNext) {
30779          dumpPNextChain(obj.pNext);
30780       } else {
30781          PRINT_SPACE
30782          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30783      }
30784
30785      print_VkDisplayPowerStateEXT(obj.powerState, "powerState", 0);
30786
30787      INDENT(-4);
30788      PRINT_SPACE
30789      if (commaNeeded)
30790          _OUT << "}," << std::endl;
30791      else
30792          _OUT << "}" << std::endl;
30793 }
30794 static void print_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
30795      PRINT_SPACE
30796      _OUT << "{" << std::endl;
30797      INDENT(4);
30798
30799      print_VkStructureType(obj->sType, "sType", 1);
30800
30801       if (obj->pNext) {
30802          dumpPNextChain(obj->pNext);
30803       } else {
30804          PRINT_SPACE
30805          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30806      }
30807
30808      print_VkDisplayPowerStateEXT(obj->powerState, "powerState", 0);
30809
30810      INDENT(-4);
30811      PRINT_SPACE
30812      if (commaNeeded)
30813          _OUT << "}," << std::endl;
30814      else
30815          _OUT << "}" << std::endl;
30816 }
30817
30818 static void print_VkDeviceEventInfoEXT(VkDeviceEventInfoEXT obj, const std::string& s, bool commaNeeded=true) {
30819      PRINT_SPACE
30820      _OUT << "{" << std::endl;
30821      INDENT(4);
30822
30823      print_VkStructureType(obj.sType, "sType", 1);
30824
30825       if (obj.pNext) {
30826          dumpPNextChain(obj.pNext);
30827       } else {
30828          PRINT_SPACE
30829          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30830      }
30831
30832      print_VkDeviceEventTypeEXT(obj.deviceEvent, "deviceEvent", 0);
30833
30834      INDENT(-4);
30835      PRINT_SPACE
30836      if (commaNeeded)
30837          _OUT << "}," << std::endl;
30838      else
30839          _OUT << "}" << std::endl;
30840 }
30841 static void print_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
30842      PRINT_SPACE
30843      _OUT << "{" << std::endl;
30844      INDENT(4);
30845
30846      print_VkStructureType(obj->sType, "sType", 1);
30847
30848       if (obj->pNext) {
30849          dumpPNextChain(obj->pNext);
30850       } else {
30851          PRINT_SPACE
30852          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30853      }
30854
30855      print_VkDeviceEventTypeEXT(obj->deviceEvent, "deviceEvent", 0);
30856
30857      INDENT(-4);
30858      PRINT_SPACE
30859      if (commaNeeded)
30860          _OUT << "}," << std::endl;
30861      else
30862          _OUT << "}" << std::endl;
30863 }
30864
30865 static void print_VkDisplayEventInfoEXT(VkDisplayEventInfoEXT obj, const std::string& s, bool commaNeeded=true) {
30866      PRINT_SPACE
30867      _OUT << "{" << std::endl;
30868      INDENT(4);
30869
30870      print_VkStructureType(obj.sType, "sType", 1);
30871
30872       if (obj.pNext) {
30873          dumpPNextChain(obj.pNext);
30874       } else {
30875          PRINT_SPACE
30876          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30877      }
30878
30879      print_VkDisplayEventTypeEXT(obj.displayEvent, "displayEvent", 0);
30880
30881      INDENT(-4);
30882      PRINT_SPACE
30883      if (commaNeeded)
30884          _OUT << "}," << std::endl;
30885      else
30886          _OUT << "}" << std::endl;
30887 }
30888 static void print_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
30889      PRINT_SPACE
30890      _OUT << "{" << std::endl;
30891      INDENT(4);
30892
30893      print_VkStructureType(obj->sType, "sType", 1);
30894
30895       if (obj->pNext) {
30896          dumpPNextChain(obj->pNext);
30897       } else {
30898          PRINT_SPACE
30899          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30900      }
30901
30902      print_VkDisplayEventTypeEXT(obj->displayEvent, "displayEvent", 0);
30903
30904      INDENT(-4);
30905      PRINT_SPACE
30906      if (commaNeeded)
30907          _OUT << "}," << std::endl;
30908      else
30909          _OUT << "}" << std::endl;
30910 }
30911
30912 static void print_VkSwapchainCounterCreateInfoEXT(VkSwapchainCounterCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
30913      PRINT_SPACE
30914      _OUT << "{" << std::endl;
30915      INDENT(4);
30916
30917      print_VkStructureType(obj.sType, "sType", 1);
30918
30919       if (obj.pNext) {
30920          dumpPNextChain(obj.pNext);
30921       } else {
30922          PRINT_SPACE
30923          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30924      }
30925
30926      print_VkSurfaceCounterFlagsEXT(obj.surfaceCounters, "surfaceCounters", 0);
30927
30928      INDENT(-4);
30929      PRINT_SPACE
30930      if (commaNeeded)
30931          _OUT << "}," << std::endl;
30932      else
30933          _OUT << "}" << std::endl;
30934 }
30935 static void print_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
30936      PRINT_SPACE
30937      _OUT << "{" << std::endl;
30938      INDENT(4);
30939
30940      print_VkStructureType(obj->sType, "sType", 1);
30941
30942       if (obj->pNext) {
30943          dumpPNextChain(obj->pNext);
30944       } else {
30945          PRINT_SPACE
30946          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
30947      }
30948
30949      print_VkSurfaceCounterFlagsEXT(obj->surfaceCounters, "surfaceCounters", 0);
30950
30951      INDENT(-4);
30952      PRINT_SPACE
30953      if (commaNeeded)
30954          _OUT << "}," << std::endl;
30955      else
30956          _OUT << "}" << std::endl;
30957 }
30958
30959 static std::map<deUint64, std::string> VkDiscardRectangleModeEXT_map = {
30960     std::make_pair(0, "VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT"),
30961     std::make_pair(1, "VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT"),
30962 };
30963 static void print_VkDiscardRectangleModeEXT(VkDiscardRectangleModeEXT obj, const std::string& str, bool commaNeeded=true) {
30964      PRINT_SPACE
30965      if (str != "") _OUT << "\"" << str << "\"" << " : ";
30966      if (commaNeeded)
30967          _OUT << "\"" <<  VkDiscardRectangleModeEXT_map[obj] << "\"," << std::endl;
30968      else
30969          _OUT << "\"" << VkDiscardRectangleModeEXT_map[obj] << "\"" << std::endl;
30970 }
30971 static void print_VkDiscardRectangleModeEXT(const VkDiscardRectangleModeEXT * obj, const std::string& str, bool commaNeeded=true) {
30972      PRINT_SPACE
30973      if (str != "") _OUT << "\"" << str << "\"" << " : ";
30974      if (commaNeeded)
30975          _OUT << "\"" <<  VkDiscardRectangleModeEXT_map[*obj] << "\"," << std::endl;
30976      else
30977          _OUT << "\"" << VkDiscardRectangleModeEXT_map[*obj] << "\"" << std::endl;
30978 }
30979
30980 static void print_VkPipelineDiscardRectangleStateCreateFlagsEXT(VkPipelineDiscardRectangleStateCreateFlagsEXT obj, const std::string& str, bool commaNeeded=true) {
30981      PRINT_SPACE
30982      if (commaNeeded)
30983          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
30984      else
30985          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
30986 }
30987 static void print_VkPipelineDiscardRectangleStateCreateFlagsEXT(const VkPipelineDiscardRectangleStateCreateFlagsEXT * obj, const std::string& str, bool commaNeeded=true) {
30988      PRINT_SPACE
30989      if (commaNeeded)
30990          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
30991      else
30992          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
30993 }
30994
30995 static void print_VkPhysicalDeviceDiscardRectanglePropertiesEXT(VkPhysicalDeviceDiscardRectanglePropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
30996      PRINT_SPACE
30997      _OUT << "{" << std::endl;
30998      INDENT(4);
30999
31000      print_VkStructureType(obj.sType, "sType", 1);
31001
31002       if (obj.pNext) {
31003          dumpPNextChain(obj.pNext);
31004       } else {
31005          PRINT_SPACE
31006          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31007      }
31008
31009      print_uint32_t(obj.maxDiscardRectangles, "maxDiscardRectangles", 0);
31010
31011      INDENT(-4);
31012      PRINT_SPACE
31013      if (commaNeeded)
31014          _OUT << "}," << std::endl;
31015      else
31016          _OUT << "}" << std::endl;
31017 }
31018 static void print_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
31019      PRINT_SPACE
31020      _OUT << "{" << std::endl;
31021      INDENT(4);
31022
31023      print_VkStructureType(obj->sType, "sType", 1);
31024
31025       if (obj->pNext) {
31026          dumpPNextChain(obj->pNext);
31027       } else {
31028          PRINT_SPACE
31029          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31030      }
31031
31032      print_uint32_t(obj->maxDiscardRectangles, "maxDiscardRectangles", 0);
31033
31034      INDENT(-4);
31035      PRINT_SPACE
31036      if (commaNeeded)
31037          _OUT << "}," << std::endl;
31038      else
31039          _OUT << "}" << std::endl;
31040 }
31041
31042 static void print_VkPipelineDiscardRectangleStateCreateInfoEXT(VkPipelineDiscardRectangleStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
31043      PRINT_SPACE
31044      _OUT << "{" << std::endl;
31045      INDENT(4);
31046
31047      print_VkStructureType(obj.sType, "sType", 1);
31048
31049       if (obj.pNext) {
31050          dumpPNextChain(obj.pNext);
31051       } else {
31052          PRINT_SPACE
31053          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31054      }
31055
31056      print_VkPipelineDiscardRectangleStateCreateFlagsEXT(obj.flags, "flags", 1);
31057
31058      print_VkDiscardRectangleModeEXT(obj.discardRectangleMode, "discardRectangleMode", 1);
31059
31060      print_uint32_t(obj.discardRectangleCount, "discardRectangleCount", 1);
31061
31062      PRINT_SPACE
31063      _OUT << "\"pDiscardRectangles\": " << std::endl;
31064      if (obj.pDiscardRectangles) {
31065          PRINT_SPACE
31066          _OUT << "[" << std::endl;
31067          for (unsigned int i = 0; i < obj.discardRectangleCount; i++) {
31068            if (i+1 == obj.discardRectangleCount)
31069                print_VkRect2D(obj.pDiscardRectangles[i], "pDiscardRectangles", 0);
31070            else
31071                print_VkRect2D(obj.pDiscardRectangles[i], "pDiscardRectangles", 1);
31072          }
31073          PRINT_SPACE
31074          _OUT << "]" << std::endl;
31075     }
31076      else
31077      {
31078          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
31079      }
31080
31081      INDENT(-4);
31082      PRINT_SPACE
31083      if (commaNeeded)
31084          _OUT << "}," << std::endl;
31085      else
31086          _OUT << "}" << std::endl;
31087 }
31088 static void print_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
31089      PRINT_SPACE
31090      _OUT << "{" << std::endl;
31091      INDENT(4);
31092
31093      print_VkStructureType(obj->sType, "sType", 1);
31094
31095       if (obj->pNext) {
31096          dumpPNextChain(obj->pNext);
31097       } else {
31098          PRINT_SPACE
31099          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31100      }
31101
31102      print_VkPipelineDiscardRectangleStateCreateFlagsEXT(obj->flags, "flags", 1);
31103
31104      print_VkDiscardRectangleModeEXT(obj->discardRectangleMode, "discardRectangleMode", 1);
31105
31106      print_uint32_t(obj->discardRectangleCount, "discardRectangleCount", 1);
31107
31108      PRINT_SPACE
31109      _OUT << "\"pDiscardRectangles\": " << std::endl;
31110      if (obj->pDiscardRectangles) {
31111          PRINT_SPACE
31112          _OUT << "[" << std::endl;
31113          for (unsigned int i = 0; i < obj->discardRectangleCount; i++) {
31114            if (i+1 == obj->discardRectangleCount)
31115                print_VkRect2D(obj->pDiscardRectangles[i], "pDiscardRectangles", 0);
31116            else
31117                print_VkRect2D(obj->pDiscardRectangles[i], "pDiscardRectangles", 1);
31118          }
31119          PRINT_SPACE
31120          _OUT << "]" << std::endl;
31121     }
31122      else
31123      {
31124          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
31125      }
31126
31127      INDENT(-4);
31128      PRINT_SPACE
31129      if (commaNeeded)
31130          _OUT << "}," << std::endl;
31131      else
31132          _OUT << "}" << std::endl;
31133 }
31134
31135 static std::map<deUint64, std::string> VkConservativeRasterizationModeEXT_map = {
31136     std::make_pair(0, "VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT"),
31137     std::make_pair(1, "VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT"),
31138     std::make_pair(2, "VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT"),
31139 };
31140 static void print_VkConservativeRasterizationModeEXT(VkConservativeRasterizationModeEXT obj, const std::string& str, bool commaNeeded=true) {
31141      PRINT_SPACE
31142      if (str != "") _OUT << "\"" << str << "\"" << " : ";
31143      if (commaNeeded)
31144          _OUT << "\"" <<  VkConservativeRasterizationModeEXT_map[obj] << "\"," << std::endl;
31145      else
31146          _OUT << "\"" << VkConservativeRasterizationModeEXT_map[obj] << "\"" << std::endl;
31147 }
31148 static void print_VkConservativeRasterizationModeEXT(const VkConservativeRasterizationModeEXT * obj, const std::string& str, bool commaNeeded=true) {
31149      PRINT_SPACE
31150      if (str != "") _OUT << "\"" << str << "\"" << " : ";
31151      if (commaNeeded)
31152          _OUT << "\"" <<  VkConservativeRasterizationModeEXT_map[*obj] << "\"," << std::endl;
31153      else
31154          _OUT << "\"" << VkConservativeRasterizationModeEXT_map[*obj] << "\"" << std::endl;
31155 }
31156
31157 static void print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(VkPipelineRasterizationConservativeStateCreateFlagsEXT obj, const std::string& str, bool commaNeeded=true) {
31158      PRINT_SPACE
31159      if (commaNeeded)
31160          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
31161      else
31162          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
31163 }
31164 static void print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(const VkPipelineRasterizationConservativeStateCreateFlagsEXT * obj, const std::string& str, bool commaNeeded=true) {
31165      PRINT_SPACE
31166      if (commaNeeded)
31167          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
31168      else
31169          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
31170 }
31171
31172 static void print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(VkPhysicalDeviceConservativeRasterizationPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
31173      PRINT_SPACE
31174      _OUT << "{" << std::endl;
31175      INDENT(4);
31176
31177      print_VkStructureType(obj.sType, "sType", 1);
31178
31179       if (obj.pNext) {
31180          dumpPNextChain(obj.pNext);
31181       } else {
31182          PRINT_SPACE
31183          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31184      }
31185
31186      print_float(obj.primitiveOverestimationSize, "primitiveOverestimationSize", 1);
31187
31188      print_float(obj.maxExtraPrimitiveOverestimationSize, "maxExtraPrimitiveOverestimationSize", 1);
31189
31190      print_float(obj.extraPrimitiveOverestimationSizeGranularity, "extraPrimitiveOverestimationSizeGranularity", 1);
31191
31192      print_VkBool32(obj.primitiveUnderestimation, "primitiveUnderestimation", 1);
31193
31194      print_VkBool32(obj.conservativePointAndLineRasterization, "conservativePointAndLineRasterization", 1);
31195
31196      print_VkBool32(obj.degenerateTrianglesRasterized, "degenerateTrianglesRasterized", 1);
31197
31198      print_VkBool32(obj.degenerateLinesRasterized, "degenerateLinesRasterized", 1);
31199
31200      print_VkBool32(obj.fullyCoveredFragmentShaderInputVariable, "fullyCoveredFragmentShaderInputVariable", 1);
31201
31202      print_VkBool32(obj.conservativeRasterizationPostDepthCoverage, "conservativeRasterizationPostDepthCoverage", 0);
31203
31204      INDENT(-4);
31205      PRINT_SPACE
31206      if (commaNeeded)
31207          _OUT << "}," << std::endl;
31208      else
31209          _OUT << "}" << std::endl;
31210 }
31211 static void print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
31212      PRINT_SPACE
31213      _OUT << "{" << std::endl;
31214      INDENT(4);
31215
31216      print_VkStructureType(obj->sType, "sType", 1);
31217
31218       if (obj->pNext) {
31219          dumpPNextChain(obj->pNext);
31220       } else {
31221          PRINT_SPACE
31222          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31223      }
31224
31225      print_float(obj->primitiveOverestimationSize, "primitiveOverestimationSize", 1);
31226
31227      print_float(obj->maxExtraPrimitiveOverestimationSize, "maxExtraPrimitiveOverestimationSize", 1);
31228
31229      print_float(obj->extraPrimitiveOverestimationSizeGranularity, "extraPrimitiveOverestimationSizeGranularity", 1);
31230
31231      print_VkBool32(obj->primitiveUnderestimation, "primitiveUnderestimation", 1);
31232
31233      print_VkBool32(obj->conservativePointAndLineRasterization, "conservativePointAndLineRasterization", 1);
31234
31235      print_VkBool32(obj->degenerateTrianglesRasterized, "degenerateTrianglesRasterized", 1);
31236
31237      print_VkBool32(obj->degenerateLinesRasterized, "degenerateLinesRasterized", 1);
31238
31239      print_VkBool32(obj->fullyCoveredFragmentShaderInputVariable, "fullyCoveredFragmentShaderInputVariable", 1);
31240
31241      print_VkBool32(obj->conservativeRasterizationPostDepthCoverage, "conservativeRasterizationPostDepthCoverage", 0);
31242
31243      INDENT(-4);
31244      PRINT_SPACE
31245      if (commaNeeded)
31246          _OUT << "}," << std::endl;
31247      else
31248          _OUT << "}" << std::endl;
31249 }
31250
31251 static void print_VkPipelineRasterizationConservativeStateCreateInfoEXT(VkPipelineRasterizationConservativeStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
31252      PRINT_SPACE
31253      _OUT << "{" << std::endl;
31254      INDENT(4);
31255
31256      print_VkStructureType(obj.sType, "sType", 1);
31257
31258       if (obj.pNext) {
31259          dumpPNextChain(obj.pNext);
31260       } else {
31261          PRINT_SPACE
31262          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31263      }
31264
31265      print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(obj.flags, "flags", 1);
31266
31267      print_VkConservativeRasterizationModeEXT(obj.conservativeRasterizationMode, "conservativeRasterizationMode", 1);
31268
31269      print_float(obj.extraPrimitiveOverestimationSize, "extraPrimitiveOverestimationSize", 0);
31270
31271      INDENT(-4);
31272      PRINT_SPACE
31273      if (commaNeeded)
31274          _OUT << "}," << std::endl;
31275      else
31276          _OUT << "}" << std::endl;
31277 }
31278 static void print_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
31279      PRINT_SPACE
31280      _OUT << "{" << std::endl;
31281      INDENT(4);
31282
31283      print_VkStructureType(obj->sType, "sType", 1);
31284
31285       if (obj->pNext) {
31286          dumpPNextChain(obj->pNext);
31287       } else {
31288          PRINT_SPACE
31289          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31290      }
31291
31292      print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(obj->flags, "flags", 1);
31293
31294      print_VkConservativeRasterizationModeEXT(obj->conservativeRasterizationMode, "conservativeRasterizationMode", 1);
31295
31296      print_float(obj->extraPrimitiveOverestimationSize, "extraPrimitiveOverestimationSize", 0);
31297
31298      INDENT(-4);
31299      PRINT_SPACE
31300      if (commaNeeded)
31301          _OUT << "}," << std::endl;
31302      else
31303          _OUT << "}" << std::endl;
31304 }
31305
31306 static void print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(VkPipelineRasterizationDepthClipStateCreateFlagsEXT obj, const std::string& str, bool commaNeeded=true) {
31307      PRINT_SPACE
31308      if (commaNeeded)
31309          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
31310      else
31311          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
31312 }
31313 static void print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(const VkPipelineRasterizationDepthClipStateCreateFlagsEXT * obj, const std::string& str, bool commaNeeded=true) {
31314      PRINT_SPACE
31315      if (commaNeeded)
31316          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
31317      else
31318          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
31319 }
31320
31321 static void print_VkPhysicalDeviceDepthClipEnableFeaturesEXT(VkPhysicalDeviceDepthClipEnableFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
31322      PRINT_SPACE
31323      _OUT << "{" << std::endl;
31324      INDENT(4);
31325
31326      print_VkStructureType(obj.sType, "sType", 1);
31327
31328       if (obj.pNext) {
31329          dumpPNextChain(obj.pNext);
31330       } else {
31331          PRINT_SPACE
31332          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31333      }
31334
31335      print_VkBool32(obj.depthClipEnable, "depthClipEnable", 0);
31336
31337      INDENT(-4);
31338      PRINT_SPACE
31339      if (commaNeeded)
31340          _OUT << "}," << std::endl;
31341      else
31342          _OUT << "}" << std::endl;
31343 }
31344 static void print_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
31345      PRINT_SPACE
31346      _OUT << "{" << std::endl;
31347      INDENT(4);
31348
31349      print_VkStructureType(obj->sType, "sType", 1);
31350
31351       if (obj->pNext) {
31352          dumpPNextChain(obj->pNext);
31353       } else {
31354          PRINT_SPACE
31355          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31356      }
31357
31358      print_VkBool32(obj->depthClipEnable, "depthClipEnable", 0);
31359
31360      INDENT(-4);
31361      PRINT_SPACE
31362      if (commaNeeded)
31363          _OUT << "}," << std::endl;
31364      else
31365          _OUT << "}" << std::endl;
31366 }
31367
31368 static void print_VkPipelineRasterizationDepthClipStateCreateInfoEXT(VkPipelineRasterizationDepthClipStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
31369      PRINT_SPACE
31370      _OUT << "{" << std::endl;
31371      INDENT(4);
31372
31373      print_VkStructureType(obj.sType, "sType", 1);
31374
31375       if (obj.pNext) {
31376          dumpPNextChain(obj.pNext);
31377       } else {
31378          PRINT_SPACE
31379          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31380      }
31381
31382      print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(obj.flags, "flags", 1);
31383
31384      print_VkBool32(obj.depthClipEnable, "depthClipEnable", 0);
31385
31386      INDENT(-4);
31387      PRINT_SPACE
31388      if (commaNeeded)
31389          _OUT << "}," << std::endl;
31390      else
31391          _OUT << "}" << std::endl;
31392 }
31393 static void print_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
31394      PRINT_SPACE
31395      _OUT << "{" << std::endl;
31396      INDENT(4);
31397
31398      print_VkStructureType(obj->sType, "sType", 1);
31399
31400       if (obj->pNext) {
31401          dumpPNextChain(obj->pNext);
31402       } else {
31403          PRINT_SPACE
31404          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31405      }
31406
31407      print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(obj->flags, "flags", 1);
31408
31409      print_VkBool32(obj->depthClipEnable, "depthClipEnable", 0);
31410
31411      INDENT(-4);
31412      PRINT_SPACE
31413      if (commaNeeded)
31414          _OUT << "}," << std::endl;
31415      else
31416          _OUT << "}" << std::endl;
31417 }
31418
31419 static void print_VkXYColorEXT(VkXYColorEXT obj, const std::string& s, bool commaNeeded=true) {
31420      PRINT_SPACE
31421      _OUT << "{" << std::endl;
31422      INDENT(4);
31423
31424      print_float(obj.x, "x", 1);
31425
31426      print_float(obj.y, "y", 0);
31427
31428      INDENT(-4);
31429      PRINT_SPACE
31430      if (commaNeeded)
31431          _OUT << "}," << std::endl;
31432      else
31433          _OUT << "}" << std::endl;
31434 }
31435 static void print_VkXYColorEXT(const VkXYColorEXT * obj, const std::string& s, bool commaNeeded=true) {
31436      PRINT_SPACE
31437      _OUT << "{" << std::endl;
31438      INDENT(4);
31439
31440      print_float(obj->x, "x", 1);
31441
31442      print_float(obj->y, "y", 0);
31443
31444      INDENT(-4);
31445      PRINT_SPACE
31446      if (commaNeeded)
31447          _OUT << "}," << std::endl;
31448      else
31449          _OUT << "}" << std::endl;
31450 }
31451
31452 static void print_VkHdrMetadataEXT(VkHdrMetadataEXT obj, const std::string& s, bool commaNeeded=true) {
31453      PRINT_SPACE
31454      _OUT << "{" << std::endl;
31455      INDENT(4);
31456
31457      print_VkStructureType(obj.sType, "sType", 1);
31458
31459       if (obj.pNext) {
31460          dumpPNextChain(obj.pNext);
31461       } else {
31462          PRINT_SPACE
31463          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31464      }
31465
31466      PRINT_SPACE
31467      _OUT << "\"displayPrimaryRed\": " << std::endl;
31468      {
31469            print_VkXYColorEXT(obj.displayPrimaryRed, "displayPrimaryRed", 1);
31470      }
31471
31472      PRINT_SPACE
31473      _OUT << "\"displayPrimaryGreen\": " << std::endl;
31474      {
31475            print_VkXYColorEXT(obj.displayPrimaryGreen, "displayPrimaryGreen", 1);
31476      }
31477
31478      PRINT_SPACE
31479      _OUT << "\"displayPrimaryBlue\": " << std::endl;
31480      {
31481            print_VkXYColorEXT(obj.displayPrimaryBlue, "displayPrimaryBlue", 1);
31482      }
31483
31484      PRINT_SPACE
31485      _OUT << "\"whitePoint\": " << std::endl;
31486      {
31487            print_VkXYColorEXT(obj.whitePoint, "whitePoint", 1);
31488      }
31489
31490      print_float(obj.maxLuminance, "maxLuminance", 1);
31491
31492      print_float(obj.minLuminance, "minLuminance", 1);
31493
31494      print_float(obj.maxContentLightLevel, "maxContentLightLevel", 1);
31495
31496      print_float(obj.maxFrameAverageLightLevel, "maxFrameAverageLightLevel", 0);
31497
31498      INDENT(-4);
31499      PRINT_SPACE
31500      if (commaNeeded)
31501          _OUT << "}," << std::endl;
31502      else
31503          _OUT << "}" << std::endl;
31504 }
31505 static void print_VkHdrMetadataEXT(const VkHdrMetadataEXT * obj, const std::string& s, bool commaNeeded=true) {
31506      PRINT_SPACE
31507      _OUT << "{" << std::endl;
31508      INDENT(4);
31509
31510      print_VkStructureType(obj->sType, "sType", 1);
31511
31512       if (obj->pNext) {
31513          dumpPNextChain(obj->pNext);
31514       } else {
31515          PRINT_SPACE
31516          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31517      }
31518
31519      PRINT_SPACE
31520      _OUT << "\"displayPrimaryRed\": " << std::endl;
31521      {
31522            print_VkXYColorEXT(obj->displayPrimaryRed, "displayPrimaryRed", 1);
31523      }
31524
31525      PRINT_SPACE
31526      _OUT << "\"displayPrimaryGreen\": " << std::endl;
31527      {
31528            print_VkXYColorEXT(obj->displayPrimaryGreen, "displayPrimaryGreen", 1);
31529      }
31530
31531      PRINT_SPACE
31532      _OUT << "\"displayPrimaryBlue\": " << std::endl;
31533      {
31534            print_VkXYColorEXT(obj->displayPrimaryBlue, "displayPrimaryBlue", 1);
31535      }
31536
31537      PRINT_SPACE
31538      _OUT << "\"whitePoint\": " << std::endl;
31539      {
31540            print_VkXYColorEXT(obj->whitePoint, "whitePoint", 1);
31541      }
31542
31543      print_float(obj->maxLuminance, "maxLuminance", 1);
31544
31545      print_float(obj->minLuminance, "minLuminance", 1);
31546
31547      print_float(obj->maxContentLightLevel, "maxContentLightLevel", 1);
31548
31549      print_float(obj->maxFrameAverageLightLevel, "maxFrameAverageLightLevel", 0);
31550
31551      INDENT(-4);
31552      PRINT_SPACE
31553      if (commaNeeded)
31554          _OUT << "}," << std::endl;
31555      else
31556          _OUT << "}" << std::endl;
31557 }
31558
31559 static void print_VkDebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT obj, const std::string& str, bool commaNeeded=true) {
31560      PRINT_SPACE
31561      if (commaNeeded)
31562          _OUT << "\"" << str << "\"" << "," << std::endl;
31563      else
31564          _OUT << "\"" << str << "\"" << std::endl;
31565 }
31566 static void print_VkDebugUtilsMessengerEXT(const VkDebugUtilsMessengerEXT * obj, const std::string& str, bool commaNeeded=true) {
31567      PRINT_SPACE
31568      if (commaNeeded)
31569          _OUT << "\"" << str << "\"" << "," << std::endl;
31570      else
31571          _OUT << "\"" << str << "\"" << std::endl;
31572 }
31573
31574 static std::map<deUint64, std::string> VkDebugUtilsMessageSeverityFlagBitsEXT_map = {
31575     std::make_pair(1ULL << 0, "VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT"),
31576     std::make_pair(1ULL << 4, "VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT"),
31577     std::make_pair(1ULL << 8, "VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT"),
31578     std::make_pair(1ULL << 12, "VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT"),
31579 };
31580 static void print_VkDebugUtilsMessageSeverityFlagBitsEXT(VkDebugUtilsMessageSeverityFlagBitsEXT obj, const std::string& str, bool commaNeeded=true) {
31581      PRINT_SPACE
31582      if (str != "") _OUT << "\"" << str << "\"" << " : ";
31583      if (commaNeeded)
31584          _OUT << "\"" <<  VkDebugUtilsMessageSeverityFlagBitsEXT_map[obj] << "\"," << std::endl;
31585      else
31586          _OUT << "\"" << VkDebugUtilsMessageSeverityFlagBitsEXT_map[obj] << "\"" << std::endl;
31587 }
31588 static void print_VkDebugUtilsMessageSeverityFlagBitsEXT(const VkDebugUtilsMessageSeverityFlagBitsEXT * obj, const std::string& str, bool commaNeeded=true) {
31589      PRINT_SPACE
31590      if (str != "") _OUT << "\"" << str << "\"" << " : ";
31591      if (commaNeeded)
31592          _OUT << "\"" <<  VkDebugUtilsMessageSeverityFlagBitsEXT_map[*obj] << "\"," << std::endl;
31593      else
31594          _OUT << "\"" << VkDebugUtilsMessageSeverityFlagBitsEXT_map[*obj] << "\"" << std::endl;
31595 }
31596
31597 static std::map<deUint64, std::string> VkDebugUtilsMessageTypeFlagBitsEXT_map = {
31598     std::make_pair(1ULL << 0, "VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT"),
31599     std::make_pair(1ULL << 1, "VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT"),
31600     std::make_pair(1ULL << 2, "VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT"),
31601 };
31602 static void print_VkDebugUtilsMessageTypeFlagBitsEXT(VkDebugUtilsMessageTypeFlagBitsEXT obj, const std::string& str, bool commaNeeded=true) {
31603      PRINT_SPACE
31604      if (str != "") _OUT << "\"" << str << "\"" << " : ";
31605      if (commaNeeded)
31606          _OUT << "\"" <<  VkDebugUtilsMessageTypeFlagBitsEXT_map[obj] << "\"," << std::endl;
31607      else
31608          _OUT << "\"" << VkDebugUtilsMessageTypeFlagBitsEXT_map[obj] << "\"" << std::endl;
31609 }
31610 static void print_VkDebugUtilsMessageTypeFlagBitsEXT(const VkDebugUtilsMessageTypeFlagBitsEXT * obj, const std::string& str, bool commaNeeded=true) {
31611      PRINT_SPACE
31612      if (str != "") _OUT << "\"" << str << "\"" << " : ";
31613      if (commaNeeded)
31614          _OUT << "\"" <<  VkDebugUtilsMessageTypeFlagBitsEXT_map[*obj] << "\"," << std::endl;
31615      else
31616          _OUT << "\"" << VkDebugUtilsMessageTypeFlagBitsEXT_map[*obj] << "\"" << std::endl;
31617 }
31618
31619 static void print_VkDebugUtilsMessengerCallbackDataFlagsEXT(VkDebugUtilsMessengerCallbackDataFlagsEXT obj, const std::string& str, bool commaNeeded=true) {
31620      PRINT_SPACE
31621      if (commaNeeded)
31622          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
31623      else
31624          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
31625 }
31626 static void print_VkDebugUtilsMessengerCallbackDataFlagsEXT(const VkDebugUtilsMessengerCallbackDataFlagsEXT * obj, const std::string& str, bool commaNeeded=true) {
31627      PRINT_SPACE
31628      if (commaNeeded)
31629          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
31630      else
31631          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
31632 }
31633
31634 static void print_VkDebugUtilsMessageTypeFlagsEXT(VkDebugUtilsMessageTypeFlagsEXT obj, const std::string& str, bool commaNeeded=true) {
31635      PRINT_SPACE
31636      if (str != "") _OUT << "\"" << str << "\"" << " : ";
31637      const int max_bits = 64; // We don't expect the number to be larger.
31638      std::bitset<max_bits> b(obj);
31639      _OUT << "\"";
31640      if (obj == 0) _OUT << "0";
31641      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
31642          if (b[i] == 1) {
31643              bitCount++;
31644              if (bitCount < b.count())
31645                  _OUT << VkDebugUtilsMessageTypeFlagBitsEXT_map[1ULL<<i] << " | ";
31646              else
31647                  _OUT << VkDebugUtilsMessageTypeFlagBitsEXT_map[1ULL<<i];
31648          }
31649      }
31650      if (commaNeeded)
31651        _OUT << "\"" << ",";
31652      else
31653        _OUT << "\""<< "";
31654      _OUT << std::endl;
31655 }
31656 static void print_VkDebugUtilsMessageTypeFlagsEXT(const VkDebugUtilsMessageTypeFlagsEXT * obj, const std::string& str, bool commaNeeded=true) {
31657      PRINT_SPACE
31658      if (str != "") _OUT << "\"" << str << "\"" << " : ";
31659      const int max_bits = 64; // We don't expect the number to be larger.
31660      std::bitset<max_bits> b(obj);
31661      _OUT << "\"";
31662      if (obj == 0) _OUT << "0";
31663      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
31664          if (b[i] == 1) {
31665              bitCount++;
31666              if (bitCount < b.count())
31667                  _OUT << VkDebugUtilsMessageTypeFlagBitsEXT_map[1ULL<<i] << " | ";
31668              else
31669                  _OUT << VkDebugUtilsMessageTypeFlagBitsEXT_map[1ULL<<i];
31670          }
31671      }
31672      if (commaNeeded)
31673        _OUT << "\"" << ",";
31674      else
31675        _OUT << "\""<< "";
31676      _OUT << std::endl;
31677 }
31678
31679 static void print_VkDebugUtilsMessageSeverityFlagsEXT(VkDebugUtilsMessageSeverityFlagsEXT obj, const std::string& str, bool commaNeeded=true) {
31680      PRINT_SPACE
31681      if (str != "") _OUT << "\"" << str << "\"" << " : ";
31682      const int max_bits = 64; // We don't expect the number to be larger.
31683      std::bitset<max_bits> b(obj);
31684      _OUT << "\"";
31685      if (obj == 0) _OUT << "0";
31686      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
31687          if (b[i] == 1) {
31688              bitCount++;
31689              if (bitCount < b.count())
31690                  _OUT << VkDebugUtilsMessageSeverityFlagBitsEXT_map[1ULL<<i] << " | ";
31691              else
31692                  _OUT << VkDebugUtilsMessageSeverityFlagBitsEXT_map[1ULL<<i];
31693          }
31694      }
31695      if (commaNeeded)
31696        _OUT << "\"" << ",";
31697      else
31698        _OUT << "\""<< "";
31699      _OUT << std::endl;
31700 }
31701 static void print_VkDebugUtilsMessageSeverityFlagsEXT(const VkDebugUtilsMessageSeverityFlagsEXT * obj, const std::string& str, bool commaNeeded=true) {
31702      PRINT_SPACE
31703      if (str != "") _OUT << "\"" << str << "\"" << " : ";
31704      const int max_bits = 64; // We don't expect the number to be larger.
31705      std::bitset<max_bits> b(obj);
31706      _OUT << "\"";
31707      if (obj == 0) _OUT << "0";
31708      for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) {
31709          if (b[i] == 1) {
31710              bitCount++;
31711              if (bitCount < b.count())
31712                  _OUT << VkDebugUtilsMessageSeverityFlagBitsEXT_map[1ULL<<i] << " | ";
31713              else
31714                  _OUT << VkDebugUtilsMessageSeverityFlagBitsEXT_map[1ULL<<i];
31715          }
31716      }
31717      if (commaNeeded)
31718        _OUT << "\"" << ",";
31719      else
31720        _OUT << "\""<< "";
31721      _OUT << std::endl;
31722 }
31723
31724 static void print_VkDebugUtilsMessengerCreateFlagsEXT(VkDebugUtilsMessengerCreateFlagsEXT obj, const std::string& str, bool commaNeeded=true) {
31725      PRINT_SPACE
31726      if (commaNeeded)
31727          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
31728      else
31729          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
31730 }
31731 static void print_VkDebugUtilsMessengerCreateFlagsEXT(const VkDebugUtilsMessengerCreateFlagsEXT * obj, const std::string& str, bool commaNeeded=true) {
31732      PRINT_SPACE
31733      if (commaNeeded)
31734          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
31735      else
31736          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
31737 }
31738
31739 static void print_VkDebugUtilsLabelEXT(VkDebugUtilsLabelEXT obj, const std::string& s, bool commaNeeded=true) {
31740      PRINT_SPACE
31741      _OUT << "{" << std::endl;
31742      INDENT(4);
31743
31744      print_VkStructureType(obj.sType, "sType", 1);
31745
31746       if (obj.pNext) {
31747          dumpPNextChain(obj.pNext);
31748       } else {
31749          PRINT_SPACE
31750          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31751      }
31752
31753      print_char(obj.pLabelName, "pLabelName", 1);
31754
31755      PRINT_SPACE
31756      _OUT << "\"color\":" << std::endl;
31757      PRINT_SPACE
31758      if (obj.color) {
31759        _OUT << "[" << std::endl;
31760        for (unsigned int i = 0; i < 4; i++) {
31761            bool isCommaNeeded = (i+1) != 4;
31762            print_float(obj.color[i], "", isCommaNeeded);
31763        }
31764        PRINT_SPACE
31765        _OUT << "]" << "" << std::endl;
31766      } else {
31767        _OUT << "\"NULL\"" << "" << std::endl;
31768      }
31769
31770      INDENT(-4);
31771      PRINT_SPACE
31772      if (commaNeeded)
31773          _OUT << "}," << std::endl;
31774      else
31775          _OUT << "}" << std::endl;
31776 }
31777 static void print_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT * obj, const std::string& s, bool commaNeeded=true) {
31778      PRINT_SPACE
31779      _OUT << "{" << std::endl;
31780      INDENT(4);
31781
31782      print_VkStructureType(obj->sType, "sType", 1);
31783
31784       if (obj->pNext) {
31785          dumpPNextChain(obj->pNext);
31786       } else {
31787          PRINT_SPACE
31788          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31789      }
31790
31791      print_char(obj->pLabelName, "pLabelName", 1);
31792
31793      PRINT_SPACE
31794      _OUT << "\"color\":" << std::endl;
31795      PRINT_SPACE
31796      if (obj->color) {
31797        _OUT << "[" << std::endl;
31798        for (unsigned int i = 0; i < 4; i++) {
31799            bool isCommaNeeded = (i+1) != 4;
31800            print_float(obj->color[i], "", isCommaNeeded);
31801        }
31802        PRINT_SPACE
31803        _OUT << "]" << "" << std::endl;
31804      } else {
31805        _OUT << "\"NULL\"" << "" << std::endl;
31806      }
31807
31808      INDENT(-4);
31809      PRINT_SPACE
31810      if (commaNeeded)
31811          _OUT << "}," << std::endl;
31812      else
31813          _OUT << "}" << std::endl;
31814 }
31815
31816 static void print_VkDebugUtilsObjectNameInfoEXT(VkDebugUtilsObjectNameInfoEXT obj, const std::string& s, bool commaNeeded=true) {
31817      PRINT_SPACE
31818      _OUT << "{" << std::endl;
31819      INDENT(4);
31820
31821      print_VkStructureType(obj.sType, "sType", 1);
31822
31823       if (obj.pNext) {
31824          dumpPNextChain(obj.pNext);
31825       } else {
31826          PRINT_SPACE
31827          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31828      }
31829
31830      print_VkObjectType(obj.objectType, "objectType", 1);
31831
31832      print_uint64_t(obj.objectHandle, "objectHandle", 1);
31833
31834      print_char(obj.pObjectName, "pObjectName", 0);
31835
31836      INDENT(-4);
31837      PRINT_SPACE
31838      if (commaNeeded)
31839          _OUT << "}," << std::endl;
31840      else
31841          _OUT << "}" << std::endl;
31842 }
31843 static void print_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
31844      PRINT_SPACE
31845      _OUT << "{" << std::endl;
31846      INDENT(4);
31847
31848      print_VkStructureType(obj->sType, "sType", 1);
31849
31850       if (obj->pNext) {
31851          dumpPNextChain(obj->pNext);
31852       } else {
31853          PRINT_SPACE
31854          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31855      }
31856
31857      print_VkObjectType(obj->objectType, "objectType", 1);
31858
31859      print_uint64_t(obj->objectHandle, "objectHandle", 1);
31860
31861      print_char(obj->pObjectName, "pObjectName", 0);
31862
31863      INDENT(-4);
31864      PRINT_SPACE
31865      if (commaNeeded)
31866          _OUT << "}," << std::endl;
31867      else
31868          _OUT << "}" << std::endl;
31869 }
31870
31871 static void print_VkDebugUtilsMessengerCallbackDataEXT(VkDebugUtilsMessengerCallbackDataEXT obj, const std::string& s, bool commaNeeded=true) {
31872      PRINT_SPACE
31873      _OUT << "{" << std::endl;
31874      INDENT(4);
31875
31876      print_VkStructureType(obj.sType, "sType", 1);
31877
31878       if (obj.pNext) {
31879          dumpPNextChain(obj.pNext);
31880       } else {
31881          PRINT_SPACE
31882          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31883      }
31884
31885      print_VkDebugUtilsMessengerCallbackDataFlagsEXT(obj.flags, "flags", 1);
31886
31887      print_char(obj.pMessageIdName, "pMessageIdName", 1);
31888
31889      print_int32_t(obj.messageIdNumber, "messageIdNumber", 1);
31890
31891      print_char(obj.pMessage, "pMessage", 1);
31892
31893      print_uint32_t(obj.queueLabelCount, "queueLabelCount", 1);
31894
31895      PRINT_SPACE
31896      _OUT << "\"pQueueLabels\": " << std::endl;
31897      if (obj.pQueueLabels) {
31898          PRINT_SPACE
31899          _OUT << "[" << std::endl;
31900          for (unsigned int i = 0; i < obj.queueLabelCount; i++) {
31901            if (i+1 == obj.queueLabelCount)
31902                print_VkDebugUtilsLabelEXT(obj.pQueueLabels[i], "pQueueLabels", 0);
31903            else
31904                print_VkDebugUtilsLabelEXT(obj.pQueueLabels[i], "pQueueLabels", 1);
31905          }
31906          PRINT_SPACE
31907          _OUT << "]," << std::endl;
31908     }
31909      else
31910      {
31911          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
31912      }
31913
31914      print_uint32_t(obj.cmdBufLabelCount, "cmdBufLabelCount", 1);
31915
31916      PRINT_SPACE
31917      _OUT << "\"pCmdBufLabels\": " << std::endl;
31918      if (obj.pCmdBufLabels) {
31919          PRINT_SPACE
31920          _OUT << "[" << std::endl;
31921          for (unsigned int i = 0; i < obj.cmdBufLabelCount; i++) {
31922            if (i+1 == obj.cmdBufLabelCount)
31923                print_VkDebugUtilsLabelEXT(obj.pCmdBufLabels[i], "pCmdBufLabels", 0);
31924            else
31925                print_VkDebugUtilsLabelEXT(obj.pCmdBufLabels[i], "pCmdBufLabels", 1);
31926          }
31927          PRINT_SPACE
31928          _OUT << "]," << std::endl;
31929     }
31930      else
31931      {
31932          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
31933      }
31934
31935      print_uint32_t(obj.objectCount, "objectCount", 1);
31936
31937      PRINT_SPACE
31938      _OUT << "\"pObjects\": " << std::endl;
31939      if (obj.pObjects) {
31940          PRINT_SPACE
31941          _OUT << "[" << std::endl;
31942          for (unsigned int i = 0; i < obj.objectCount; i++) {
31943            if (i+1 == obj.objectCount)
31944                print_VkDebugUtilsObjectNameInfoEXT(obj.pObjects[i], "pObjects", 0);
31945            else
31946                print_VkDebugUtilsObjectNameInfoEXT(obj.pObjects[i], "pObjects", 1);
31947          }
31948          PRINT_SPACE
31949          _OUT << "]" << std::endl;
31950     }
31951      else
31952      {
31953          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
31954      }
31955
31956      INDENT(-4);
31957      PRINT_SPACE
31958      if (commaNeeded)
31959          _OUT << "}," << std::endl;
31960      else
31961          _OUT << "}" << std::endl;
31962 }
31963 static void print_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT * obj, const std::string& s, bool commaNeeded=true) {
31964      PRINT_SPACE
31965      _OUT << "{" << std::endl;
31966      INDENT(4);
31967
31968      print_VkStructureType(obj->sType, "sType", 1);
31969
31970       if (obj->pNext) {
31971          dumpPNextChain(obj->pNext);
31972       } else {
31973          PRINT_SPACE
31974          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
31975      }
31976
31977      print_VkDebugUtilsMessengerCallbackDataFlagsEXT(obj->flags, "flags", 1);
31978
31979      print_char(obj->pMessageIdName, "pMessageIdName", 1);
31980
31981      print_int32_t(obj->messageIdNumber, "messageIdNumber", 1);
31982
31983      print_char(obj->pMessage, "pMessage", 1);
31984
31985      print_uint32_t(obj->queueLabelCount, "queueLabelCount", 1);
31986
31987      PRINT_SPACE
31988      _OUT << "\"pQueueLabels\": " << std::endl;
31989      if (obj->pQueueLabels) {
31990          PRINT_SPACE
31991          _OUT << "[" << std::endl;
31992          for (unsigned int i = 0; i < obj->queueLabelCount; i++) {
31993            if (i+1 == obj->queueLabelCount)
31994                print_VkDebugUtilsLabelEXT(obj->pQueueLabels[i], "pQueueLabels", 0);
31995            else
31996                print_VkDebugUtilsLabelEXT(obj->pQueueLabels[i], "pQueueLabels", 1);
31997          }
31998          PRINT_SPACE
31999          _OUT << "]," << std::endl;
32000     }
32001      else
32002      {
32003          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
32004      }
32005
32006      print_uint32_t(obj->cmdBufLabelCount, "cmdBufLabelCount", 1);
32007
32008      PRINT_SPACE
32009      _OUT << "\"pCmdBufLabels\": " << std::endl;
32010      if (obj->pCmdBufLabels) {
32011          PRINT_SPACE
32012          _OUT << "[" << std::endl;
32013          for (unsigned int i = 0; i < obj->cmdBufLabelCount; i++) {
32014            if (i+1 == obj->cmdBufLabelCount)
32015                print_VkDebugUtilsLabelEXT(obj->pCmdBufLabels[i], "pCmdBufLabels", 0);
32016            else
32017                print_VkDebugUtilsLabelEXT(obj->pCmdBufLabels[i], "pCmdBufLabels", 1);
32018          }
32019          PRINT_SPACE
32020          _OUT << "]," << std::endl;
32021     }
32022      else
32023      {
32024          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
32025      }
32026
32027      print_uint32_t(obj->objectCount, "objectCount", 1);
32028
32029      PRINT_SPACE
32030      _OUT << "\"pObjects\": " << std::endl;
32031      if (obj->pObjects) {
32032          PRINT_SPACE
32033          _OUT << "[" << std::endl;
32034          for (unsigned int i = 0; i < obj->objectCount; i++) {
32035            if (i+1 == obj->objectCount)
32036                print_VkDebugUtilsObjectNameInfoEXT(obj->pObjects[i], "pObjects", 0);
32037            else
32038                print_VkDebugUtilsObjectNameInfoEXT(obj->pObjects[i], "pObjects", 1);
32039          }
32040          PRINT_SPACE
32041          _OUT << "]" << std::endl;
32042     }
32043      else
32044      {
32045          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
32046      }
32047
32048      INDENT(-4);
32049      PRINT_SPACE
32050      if (commaNeeded)
32051          _OUT << "}," << std::endl;
32052      else
32053          _OUT << "}" << std::endl;
32054 }
32055
32056 static void print_VkDebugUtilsMessengerCreateInfoEXT(VkDebugUtilsMessengerCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
32057      PRINT_SPACE
32058      _OUT << "{" << std::endl;
32059      INDENT(4);
32060
32061      print_VkStructureType(obj.sType, "sType", 1);
32062
32063       if (obj.pNext) {
32064          dumpPNextChain(obj.pNext);
32065       } else {
32066          PRINT_SPACE
32067          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32068      }
32069
32070      print_VkDebugUtilsMessengerCreateFlagsEXT(obj.flags, "flags", 1);
32071
32072      print_VkDebugUtilsMessageSeverityFlagsEXT(obj.messageSeverity, "messageSeverity", 1);
32073
32074      print_VkDebugUtilsMessageTypeFlagsEXT(obj.messageType, "messageType", 1);
32075
32076      /** Note: Ignoring function pointer (PFN_vkDebugUtilsMessengerCallbackEXT). **/
32077
32078      /** Note: Ignoring void* data. **/
32079
32080      INDENT(-4);
32081      PRINT_SPACE
32082      if (commaNeeded)
32083          _OUT << "}," << std::endl;
32084      else
32085          _OUT << "}" << std::endl;
32086 }
32087 static void print_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
32088      PRINT_SPACE
32089      _OUT << "{" << std::endl;
32090      INDENT(4);
32091
32092      print_VkStructureType(obj->sType, "sType", 1);
32093
32094       if (obj->pNext) {
32095          dumpPNextChain(obj->pNext);
32096       } else {
32097          PRINT_SPACE
32098          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32099      }
32100
32101      print_VkDebugUtilsMessengerCreateFlagsEXT(obj->flags, "flags", 1);
32102
32103      print_VkDebugUtilsMessageSeverityFlagsEXT(obj->messageSeverity, "messageSeverity", 1);
32104
32105      print_VkDebugUtilsMessageTypeFlagsEXT(obj->messageType, "messageType", 1);
32106
32107      /** Note: Ignoring function pointer (PFN_vkDebugUtilsMessengerCallbackEXT). **/
32108
32109      /** Note: Ignoring void* data. **/
32110
32111      INDENT(-4);
32112      PRINT_SPACE
32113      if (commaNeeded)
32114          _OUT << "}," << std::endl;
32115      else
32116          _OUT << "}" << std::endl;
32117 }
32118
32119 static void print_VkDebugUtilsObjectTagInfoEXT(VkDebugUtilsObjectTagInfoEXT obj, const std::string& s, bool commaNeeded=true) {
32120      PRINT_SPACE
32121      _OUT << "{" << std::endl;
32122      INDENT(4);
32123
32124      print_VkStructureType(obj.sType, "sType", 1);
32125
32126       if (obj.pNext) {
32127          dumpPNextChain(obj.pNext);
32128       } else {
32129          PRINT_SPACE
32130          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32131      }
32132
32133      print_VkObjectType(obj.objectType, "objectType", 1);
32134
32135      print_uint64_t(obj.objectHandle, "objectHandle", 1);
32136
32137      print_uint64_t(obj.tagName, "tagName", 1);
32138
32139      print_size_t(obj.tagSize, "tagSize", 1);
32140
32141      /** Note: Ignoring void* data. **/
32142
32143      INDENT(-4);
32144      PRINT_SPACE
32145      if (commaNeeded)
32146          _OUT << "}," << std::endl;
32147      else
32148          _OUT << "}" << std::endl;
32149 }
32150 static void print_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
32151      PRINT_SPACE
32152      _OUT << "{" << std::endl;
32153      INDENT(4);
32154
32155      print_VkStructureType(obj->sType, "sType", 1);
32156
32157       if (obj->pNext) {
32158          dumpPNextChain(obj->pNext);
32159       } else {
32160          PRINT_SPACE
32161          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32162      }
32163
32164      print_VkObjectType(obj->objectType, "objectType", 1);
32165
32166      print_uint64_t(obj->objectHandle, "objectHandle", 1);
32167
32168      print_uint64_t(obj->tagName, "tagName", 1);
32169
32170      print_size_t(obj->tagSize, "tagSize", 1);
32171
32172      /** Note: Ignoring void* data. **/
32173
32174      INDENT(-4);
32175      PRINT_SPACE
32176      if (commaNeeded)
32177          _OUT << "}," << std::endl;
32178      else
32179          _OUT << "}" << std::endl;
32180 }
32181
32182 static void print_VkSampleLocationEXT(VkSampleLocationEXT obj, const std::string& s, bool commaNeeded=true) {
32183      PRINT_SPACE
32184      _OUT << "{" << std::endl;
32185      INDENT(4);
32186
32187      print_float(obj.x, "x", 1);
32188
32189      print_float(obj.y, "y", 0);
32190
32191      INDENT(-4);
32192      PRINT_SPACE
32193      if (commaNeeded)
32194          _OUT << "}," << std::endl;
32195      else
32196          _OUT << "}" << std::endl;
32197 }
32198 static void print_VkSampleLocationEXT(const VkSampleLocationEXT * obj, const std::string& s, bool commaNeeded=true) {
32199      PRINT_SPACE
32200      _OUT << "{" << std::endl;
32201      INDENT(4);
32202
32203      print_float(obj->x, "x", 1);
32204
32205      print_float(obj->y, "y", 0);
32206
32207      INDENT(-4);
32208      PRINT_SPACE
32209      if (commaNeeded)
32210          _OUT << "}," << std::endl;
32211      else
32212          _OUT << "}" << std::endl;
32213 }
32214
32215 static void print_VkSampleLocationsInfoEXT(VkSampleLocationsInfoEXT obj, const std::string& s, bool commaNeeded=true) {
32216      PRINT_SPACE
32217      _OUT << "{" << std::endl;
32218      INDENT(4);
32219
32220      print_VkStructureType(obj.sType, "sType", 1);
32221
32222       if (obj.pNext) {
32223          dumpPNextChain(obj.pNext);
32224       } else {
32225          PRINT_SPACE
32226          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32227      }
32228
32229      print_VkSampleCountFlagBits(obj.sampleLocationsPerPixel, "sampleLocationsPerPixel", 1);
32230
32231      PRINT_SPACE
32232      _OUT << "\"sampleLocationGridSize\": " << std::endl;
32233      {
32234            print_VkExtent2D(obj.sampleLocationGridSize, "sampleLocationGridSize", 1);
32235      }
32236
32237      print_uint32_t(obj.sampleLocationsCount, "sampleLocationsCount", 1);
32238
32239      PRINT_SPACE
32240      _OUT << "\"pSampleLocations\": " << std::endl;
32241      if (obj.pSampleLocations) {
32242          PRINT_SPACE
32243          _OUT << "[" << std::endl;
32244          for (unsigned int i = 0; i < obj.sampleLocationsCount; i++) {
32245            if (i+1 == obj.sampleLocationsCount)
32246                print_VkSampleLocationEXT(obj.pSampleLocations[i], "pSampleLocations", 0);
32247            else
32248                print_VkSampleLocationEXT(obj.pSampleLocations[i], "pSampleLocations", 1);
32249          }
32250          PRINT_SPACE
32251          _OUT << "]" << std::endl;
32252     }
32253      else
32254      {
32255          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
32256      }
32257
32258      INDENT(-4);
32259      PRINT_SPACE
32260      if (commaNeeded)
32261          _OUT << "}," << std::endl;
32262      else
32263          _OUT << "}" << std::endl;
32264 }
32265 static void print_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
32266      PRINT_SPACE
32267      _OUT << "{" << std::endl;
32268      INDENT(4);
32269
32270      print_VkStructureType(obj->sType, "sType", 1);
32271
32272       if (obj->pNext) {
32273          dumpPNextChain(obj->pNext);
32274       } else {
32275          PRINT_SPACE
32276          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32277      }
32278
32279      print_VkSampleCountFlagBits(obj->sampleLocationsPerPixel, "sampleLocationsPerPixel", 1);
32280
32281      PRINT_SPACE
32282      _OUT << "\"sampleLocationGridSize\": " << std::endl;
32283      {
32284            print_VkExtent2D(obj->sampleLocationGridSize, "sampleLocationGridSize", 1);
32285      }
32286
32287      print_uint32_t(obj->sampleLocationsCount, "sampleLocationsCount", 1);
32288
32289      PRINT_SPACE
32290      _OUT << "\"pSampleLocations\": " << std::endl;
32291      if (obj->pSampleLocations) {
32292          PRINT_SPACE
32293          _OUT << "[" << std::endl;
32294          for (unsigned int i = 0; i < obj->sampleLocationsCount; i++) {
32295            if (i+1 == obj->sampleLocationsCount)
32296                print_VkSampleLocationEXT(obj->pSampleLocations[i], "pSampleLocations", 0);
32297            else
32298                print_VkSampleLocationEXT(obj->pSampleLocations[i], "pSampleLocations", 1);
32299          }
32300          PRINT_SPACE
32301          _OUT << "]" << std::endl;
32302     }
32303      else
32304      {
32305          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
32306      }
32307
32308      INDENT(-4);
32309      PRINT_SPACE
32310      if (commaNeeded)
32311          _OUT << "}," << std::endl;
32312      else
32313          _OUT << "}" << std::endl;
32314 }
32315
32316 static void print_VkAttachmentSampleLocationsEXT(VkAttachmentSampleLocationsEXT obj, const std::string& s, bool commaNeeded=true) {
32317      PRINT_SPACE
32318      _OUT << "{" << std::endl;
32319      INDENT(4);
32320
32321      print_uint32_t(obj.attachmentIndex, "attachmentIndex", 1);
32322
32323      PRINT_SPACE
32324      _OUT << "\"sampleLocationsInfo\": " << std::endl;
32325      {
32326            print_VkSampleLocationsInfoEXT(obj.sampleLocationsInfo, "sampleLocationsInfo", 0);
32327      }
32328
32329      INDENT(-4);
32330      PRINT_SPACE
32331      if (commaNeeded)
32332          _OUT << "}," << std::endl;
32333      else
32334          _OUT << "}" << std::endl;
32335 }
32336 static void print_VkAttachmentSampleLocationsEXT(const VkAttachmentSampleLocationsEXT * obj, const std::string& s, bool commaNeeded=true) {
32337      PRINT_SPACE
32338      _OUT << "{" << std::endl;
32339      INDENT(4);
32340
32341      print_uint32_t(obj->attachmentIndex, "attachmentIndex", 1);
32342
32343      PRINT_SPACE
32344      _OUT << "\"sampleLocationsInfo\": " << std::endl;
32345      {
32346            print_VkSampleLocationsInfoEXT(obj->sampleLocationsInfo, "sampleLocationsInfo", 0);
32347      }
32348
32349      INDENT(-4);
32350      PRINT_SPACE
32351      if (commaNeeded)
32352          _OUT << "}," << std::endl;
32353      else
32354          _OUT << "}" << std::endl;
32355 }
32356
32357 static void print_VkSubpassSampleLocationsEXT(VkSubpassSampleLocationsEXT obj, const std::string& s, bool commaNeeded=true) {
32358      PRINT_SPACE
32359      _OUT << "{" << std::endl;
32360      INDENT(4);
32361
32362      print_uint32_t(obj.subpassIndex, "subpassIndex", 1);
32363
32364      PRINT_SPACE
32365      _OUT << "\"sampleLocationsInfo\": " << std::endl;
32366      {
32367            print_VkSampleLocationsInfoEXT(obj.sampleLocationsInfo, "sampleLocationsInfo", 0);
32368      }
32369
32370      INDENT(-4);
32371      PRINT_SPACE
32372      if (commaNeeded)
32373          _OUT << "}," << std::endl;
32374      else
32375          _OUT << "}" << std::endl;
32376 }
32377 static void print_VkSubpassSampleLocationsEXT(const VkSubpassSampleLocationsEXT * obj, const std::string& s, bool commaNeeded=true) {
32378      PRINT_SPACE
32379      _OUT << "{" << std::endl;
32380      INDENT(4);
32381
32382      print_uint32_t(obj->subpassIndex, "subpassIndex", 1);
32383
32384      PRINT_SPACE
32385      _OUT << "\"sampleLocationsInfo\": " << std::endl;
32386      {
32387            print_VkSampleLocationsInfoEXT(obj->sampleLocationsInfo, "sampleLocationsInfo", 0);
32388      }
32389
32390      INDENT(-4);
32391      PRINT_SPACE
32392      if (commaNeeded)
32393          _OUT << "}," << std::endl;
32394      else
32395          _OUT << "}" << std::endl;
32396 }
32397
32398 static void print_VkRenderPassSampleLocationsBeginInfoEXT(VkRenderPassSampleLocationsBeginInfoEXT obj, const std::string& s, bool commaNeeded=true) {
32399      PRINT_SPACE
32400      _OUT << "{" << std::endl;
32401      INDENT(4);
32402
32403      print_VkStructureType(obj.sType, "sType", 1);
32404
32405       if (obj.pNext) {
32406          dumpPNextChain(obj.pNext);
32407       } else {
32408          PRINT_SPACE
32409          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32410      }
32411
32412      print_uint32_t(obj.attachmentInitialSampleLocationsCount, "attachmentInitialSampleLocationsCount", 1);
32413
32414      PRINT_SPACE
32415      _OUT << "\"pAttachmentInitialSampleLocations\": " << std::endl;
32416      if (obj.pAttachmentInitialSampleLocations) {
32417          PRINT_SPACE
32418          _OUT << "[" << std::endl;
32419          for (unsigned int i = 0; i < obj.attachmentInitialSampleLocationsCount; i++) {
32420            if (i+1 == obj.attachmentInitialSampleLocationsCount)
32421                print_VkAttachmentSampleLocationsEXT(obj.pAttachmentInitialSampleLocations[i], "pAttachmentInitialSampleLocations", 0);
32422            else
32423                print_VkAttachmentSampleLocationsEXT(obj.pAttachmentInitialSampleLocations[i], "pAttachmentInitialSampleLocations", 1);
32424          }
32425          PRINT_SPACE
32426          _OUT << "]," << std::endl;
32427     }
32428      else
32429      {
32430          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
32431      }
32432
32433      print_uint32_t(obj.postSubpassSampleLocationsCount, "postSubpassSampleLocationsCount", 1);
32434
32435      PRINT_SPACE
32436      _OUT << "\"pPostSubpassSampleLocations\": " << std::endl;
32437      if (obj.pPostSubpassSampleLocations) {
32438          PRINT_SPACE
32439          _OUT << "[" << std::endl;
32440          for (unsigned int i = 0; i < obj.postSubpassSampleLocationsCount; i++) {
32441            if (i+1 == obj.postSubpassSampleLocationsCount)
32442                print_VkSubpassSampleLocationsEXT(obj.pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations", 0);
32443            else
32444                print_VkSubpassSampleLocationsEXT(obj.pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations", 1);
32445          }
32446          PRINT_SPACE
32447          _OUT << "]" << std::endl;
32448     }
32449      else
32450      {
32451          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
32452      }
32453
32454      INDENT(-4);
32455      PRINT_SPACE
32456      if (commaNeeded)
32457          _OUT << "}," << std::endl;
32458      else
32459          _OUT << "}" << std::endl;
32460 }
32461 static void print_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
32462      PRINT_SPACE
32463      _OUT << "{" << std::endl;
32464      INDENT(4);
32465
32466      print_VkStructureType(obj->sType, "sType", 1);
32467
32468       if (obj->pNext) {
32469          dumpPNextChain(obj->pNext);
32470       } else {
32471          PRINT_SPACE
32472          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32473      }
32474
32475      print_uint32_t(obj->attachmentInitialSampleLocationsCount, "attachmentInitialSampleLocationsCount", 1);
32476
32477      PRINT_SPACE
32478      _OUT << "\"pAttachmentInitialSampleLocations\": " << std::endl;
32479      if (obj->pAttachmentInitialSampleLocations) {
32480          PRINT_SPACE
32481          _OUT << "[" << std::endl;
32482          for (unsigned int i = 0; i < obj->attachmentInitialSampleLocationsCount; i++) {
32483            if (i+1 == obj->attachmentInitialSampleLocationsCount)
32484                print_VkAttachmentSampleLocationsEXT(obj->pAttachmentInitialSampleLocations[i], "pAttachmentInitialSampleLocations", 0);
32485            else
32486                print_VkAttachmentSampleLocationsEXT(obj->pAttachmentInitialSampleLocations[i], "pAttachmentInitialSampleLocations", 1);
32487          }
32488          PRINT_SPACE
32489          _OUT << "]," << std::endl;
32490     }
32491      else
32492      {
32493          PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl;
32494      }
32495
32496      print_uint32_t(obj->postSubpassSampleLocationsCount, "postSubpassSampleLocationsCount", 1);
32497
32498      PRINT_SPACE
32499      _OUT << "\"pPostSubpassSampleLocations\": " << std::endl;
32500      if (obj->pPostSubpassSampleLocations) {
32501          PRINT_SPACE
32502          _OUT << "[" << std::endl;
32503          for (unsigned int i = 0; i < obj->postSubpassSampleLocationsCount; i++) {
32504            if (i+1 == obj->postSubpassSampleLocationsCount)
32505                print_VkSubpassSampleLocationsEXT(obj->pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations", 0);
32506            else
32507                print_VkSubpassSampleLocationsEXT(obj->pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations", 1);
32508          }
32509          PRINT_SPACE
32510          _OUT << "]" << std::endl;
32511     }
32512      else
32513      {
32514          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
32515      }
32516
32517      INDENT(-4);
32518      PRINT_SPACE
32519      if (commaNeeded)
32520          _OUT << "}," << std::endl;
32521      else
32522          _OUT << "}" << std::endl;
32523 }
32524
32525 static void print_VkPipelineSampleLocationsStateCreateInfoEXT(VkPipelineSampleLocationsStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
32526      PRINT_SPACE
32527      _OUT << "{" << std::endl;
32528      INDENT(4);
32529
32530      print_VkStructureType(obj.sType, "sType", 1);
32531
32532       if (obj.pNext) {
32533          dumpPNextChain(obj.pNext);
32534       } else {
32535          PRINT_SPACE
32536          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32537      }
32538
32539      print_VkBool32(obj.sampleLocationsEnable, "sampleLocationsEnable", 1);
32540
32541      PRINT_SPACE
32542      _OUT << "\"sampleLocationsInfo\": " << std::endl;
32543      {
32544            print_VkSampleLocationsInfoEXT(obj.sampleLocationsInfo, "sampleLocationsInfo", 0);
32545      }
32546
32547      INDENT(-4);
32548      PRINT_SPACE
32549      if (commaNeeded)
32550          _OUT << "}," << std::endl;
32551      else
32552          _OUT << "}" << std::endl;
32553 }
32554 static void print_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
32555      PRINT_SPACE
32556      _OUT << "{" << std::endl;
32557      INDENT(4);
32558
32559      print_VkStructureType(obj->sType, "sType", 1);
32560
32561       if (obj->pNext) {
32562          dumpPNextChain(obj->pNext);
32563       } else {
32564          PRINT_SPACE
32565          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32566      }
32567
32568      print_VkBool32(obj->sampleLocationsEnable, "sampleLocationsEnable", 1);
32569
32570      PRINT_SPACE
32571      _OUT << "\"sampleLocationsInfo\": " << std::endl;
32572      {
32573            print_VkSampleLocationsInfoEXT(obj->sampleLocationsInfo, "sampleLocationsInfo", 0);
32574      }
32575
32576      INDENT(-4);
32577      PRINT_SPACE
32578      if (commaNeeded)
32579          _OUT << "}," << std::endl;
32580      else
32581          _OUT << "}" << std::endl;
32582 }
32583
32584 static void print_VkPhysicalDeviceSampleLocationsPropertiesEXT(VkPhysicalDeviceSampleLocationsPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
32585      PRINT_SPACE
32586      _OUT << "{" << std::endl;
32587      INDENT(4);
32588
32589      print_VkStructureType(obj.sType, "sType", 1);
32590
32591       if (obj.pNext) {
32592          dumpPNextChain(obj.pNext);
32593       } else {
32594          PRINT_SPACE
32595          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32596      }
32597
32598      print_VkSampleCountFlags(obj.sampleLocationSampleCounts, "sampleLocationSampleCounts", 1);
32599
32600      PRINT_SPACE
32601      _OUT << "\"maxSampleLocationGridSize\": " << std::endl;
32602      {
32603            print_VkExtent2D(obj.maxSampleLocationGridSize, "maxSampleLocationGridSize", 1);
32604      }
32605
32606      PRINT_SPACE
32607      _OUT << "\"sampleLocationCoordinateRange\":" << std::endl;
32608      PRINT_SPACE
32609      if (obj.sampleLocationCoordinateRange) {
32610        _OUT << "[" << std::endl;
32611        for (unsigned int i = 0; i < 2; i++) {
32612            bool isCommaNeeded = (i+1) != 2;
32613            print_float(obj.sampleLocationCoordinateRange[i], "", isCommaNeeded);
32614        }
32615        PRINT_SPACE
32616        _OUT << "]" << "," << std::endl;
32617      } else {
32618        _OUT << "\"NULL\"" << "," << std::endl;
32619      }
32620
32621      print_uint32_t(obj.sampleLocationSubPixelBits, "sampleLocationSubPixelBits", 1);
32622
32623      print_VkBool32(obj.variableSampleLocations, "variableSampleLocations", 0);
32624
32625      INDENT(-4);
32626      PRINT_SPACE
32627      if (commaNeeded)
32628          _OUT << "}," << std::endl;
32629      else
32630          _OUT << "}" << std::endl;
32631 }
32632 static void print_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
32633      PRINT_SPACE
32634      _OUT << "{" << std::endl;
32635      INDENT(4);
32636
32637      print_VkStructureType(obj->sType, "sType", 1);
32638
32639       if (obj->pNext) {
32640          dumpPNextChain(obj->pNext);
32641       } else {
32642          PRINT_SPACE
32643          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32644      }
32645
32646      print_VkSampleCountFlags(obj->sampleLocationSampleCounts, "sampleLocationSampleCounts", 1);
32647
32648      PRINT_SPACE
32649      _OUT << "\"maxSampleLocationGridSize\": " << std::endl;
32650      {
32651            print_VkExtent2D(obj->maxSampleLocationGridSize, "maxSampleLocationGridSize", 1);
32652      }
32653
32654      PRINT_SPACE
32655      _OUT << "\"sampleLocationCoordinateRange\":" << std::endl;
32656      PRINT_SPACE
32657      if (obj->sampleLocationCoordinateRange) {
32658        _OUT << "[" << std::endl;
32659        for (unsigned int i = 0; i < 2; i++) {
32660            bool isCommaNeeded = (i+1) != 2;
32661            print_float(obj->sampleLocationCoordinateRange[i], "", isCommaNeeded);
32662        }
32663        PRINT_SPACE
32664        _OUT << "]" << "," << std::endl;
32665      } else {
32666        _OUT << "\"NULL\"" << "," << std::endl;
32667      }
32668
32669      print_uint32_t(obj->sampleLocationSubPixelBits, "sampleLocationSubPixelBits", 1);
32670
32671      print_VkBool32(obj->variableSampleLocations, "variableSampleLocations", 0);
32672
32673      INDENT(-4);
32674      PRINT_SPACE
32675      if (commaNeeded)
32676          _OUT << "}," << std::endl;
32677      else
32678          _OUT << "}" << std::endl;
32679 }
32680
32681 static void print_VkMultisamplePropertiesEXT(VkMultisamplePropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
32682      PRINT_SPACE
32683      _OUT << "{" << std::endl;
32684      INDENT(4);
32685
32686      print_VkStructureType(obj.sType, "sType", 1);
32687
32688       if (obj.pNext) {
32689          dumpPNextChain(obj.pNext);
32690       } else {
32691          PRINT_SPACE
32692          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32693      }
32694
32695      PRINT_SPACE
32696      _OUT << "\"maxSampleLocationGridSize\": " << std::endl;
32697      {
32698            print_VkExtent2D(obj.maxSampleLocationGridSize, "maxSampleLocationGridSize", 0);
32699      }
32700
32701      INDENT(-4);
32702      PRINT_SPACE
32703      if (commaNeeded)
32704          _OUT << "}," << std::endl;
32705      else
32706          _OUT << "}" << std::endl;
32707 }
32708 static void print_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
32709      PRINT_SPACE
32710      _OUT << "{" << std::endl;
32711      INDENT(4);
32712
32713      print_VkStructureType(obj->sType, "sType", 1);
32714
32715       if (obj->pNext) {
32716          dumpPNextChain(obj->pNext);
32717       } else {
32718          PRINT_SPACE
32719          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32720      }
32721
32722      PRINT_SPACE
32723      _OUT << "\"maxSampleLocationGridSize\": " << std::endl;
32724      {
32725            print_VkExtent2D(obj->maxSampleLocationGridSize, "maxSampleLocationGridSize", 0);
32726      }
32727
32728      INDENT(-4);
32729      PRINT_SPACE
32730      if (commaNeeded)
32731          _OUT << "}," << std::endl;
32732      else
32733          _OUT << "}" << std::endl;
32734 }
32735
32736 static std::map<deUint64, std::string> VkBlendOverlapEXT_map = {
32737     std::make_pair(0, "VK_BLEND_OVERLAP_UNCORRELATED_EXT"),
32738     std::make_pair(1, "VK_BLEND_OVERLAP_DISJOINT_EXT"),
32739     std::make_pair(2, "VK_BLEND_OVERLAP_CONJOINT_EXT"),
32740 };
32741 static void print_VkBlendOverlapEXT(VkBlendOverlapEXT obj, const std::string& str, bool commaNeeded=true) {
32742      PRINT_SPACE
32743      if (str != "") _OUT << "\"" << str << "\"" << " : ";
32744      if (commaNeeded)
32745          _OUT << "\"" <<  VkBlendOverlapEXT_map[obj] << "\"," << std::endl;
32746      else
32747          _OUT << "\"" << VkBlendOverlapEXT_map[obj] << "\"" << std::endl;
32748 }
32749 static void print_VkBlendOverlapEXT(const VkBlendOverlapEXT * obj, const std::string& str, bool commaNeeded=true) {
32750      PRINT_SPACE
32751      if (str != "") _OUT << "\"" << str << "\"" << " : ";
32752      if (commaNeeded)
32753          _OUT << "\"" <<  VkBlendOverlapEXT_map[*obj] << "\"," << std::endl;
32754      else
32755          _OUT << "\"" << VkBlendOverlapEXT_map[*obj] << "\"" << std::endl;
32756 }
32757
32758 static void print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
32759      PRINT_SPACE
32760      _OUT << "{" << std::endl;
32761      INDENT(4);
32762
32763      print_VkStructureType(obj.sType, "sType", 1);
32764
32765       if (obj.pNext) {
32766          dumpPNextChain(obj.pNext);
32767       } else {
32768          PRINT_SPACE
32769          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32770      }
32771
32772      print_VkBool32(obj.advancedBlendCoherentOperations, "advancedBlendCoherentOperations", 0);
32773
32774      INDENT(-4);
32775      PRINT_SPACE
32776      if (commaNeeded)
32777          _OUT << "}," << std::endl;
32778      else
32779          _OUT << "}" << std::endl;
32780 }
32781 static void print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
32782      PRINT_SPACE
32783      _OUT << "{" << std::endl;
32784      INDENT(4);
32785
32786      print_VkStructureType(obj->sType, "sType", 1);
32787
32788       if (obj->pNext) {
32789          dumpPNextChain(obj->pNext);
32790       } else {
32791          PRINT_SPACE
32792          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32793      }
32794
32795      print_VkBool32(obj->advancedBlendCoherentOperations, "advancedBlendCoherentOperations", 0);
32796
32797      INDENT(-4);
32798      PRINT_SPACE
32799      if (commaNeeded)
32800          _OUT << "}," << std::endl;
32801      else
32802          _OUT << "}" << std::endl;
32803 }
32804
32805 static void print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
32806      PRINT_SPACE
32807      _OUT << "{" << std::endl;
32808      INDENT(4);
32809
32810      print_VkStructureType(obj.sType, "sType", 1);
32811
32812       if (obj.pNext) {
32813          dumpPNextChain(obj.pNext);
32814       } else {
32815          PRINT_SPACE
32816          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32817      }
32818
32819      print_uint32_t(obj.advancedBlendMaxColorAttachments, "advancedBlendMaxColorAttachments", 1);
32820
32821      print_VkBool32(obj.advancedBlendIndependentBlend, "advancedBlendIndependentBlend", 1);
32822
32823      print_VkBool32(obj.advancedBlendNonPremultipliedSrcColor, "advancedBlendNonPremultipliedSrcColor", 1);
32824
32825      print_VkBool32(obj.advancedBlendNonPremultipliedDstColor, "advancedBlendNonPremultipliedDstColor", 1);
32826
32827      print_VkBool32(obj.advancedBlendCorrelatedOverlap, "advancedBlendCorrelatedOverlap", 1);
32828
32829      print_VkBool32(obj.advancedBlendAllOperations, "advancedBlendAllOperations", 0);
32830
32831      INDENT(-4);
32832      PRINT_SPACE
32833      if (commaNeeded)
32834          _OUT << "}," << std::endl;
32835      else
32836          _OUT << "}" << std::endl;
32837 }
32838 static void print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
32839      PRINT_SPACE
32840      _OUT << "{" << std::endl;
32841      INDENT(4);
32842
32843      print_VkStructureType(obj->sType, "sType", 1);
32844
32845       if (obj->pNext) {
32846          dumpPNextChain(obj->pNext);
32847       } else {
32848          PRINT_SPACE
32849          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32850      }
32851
32852      print_uint32_t(obj->advancedBlendMaxColorAttachments, "advancedBlendMaxColorAttachments", 1);
32853
32854      print_VkBool32(obj->advancedBlendIndependentBlend, "advancedBlendIndependentBlend", 1);
32855
32856      print_VkBool32(obj->advancedBlendNonPremultipliedSrcColor, "advancedBlendNonPremultipliedSrcColor", 1);
32857
32858      print_VkBool32(obj->advancedBlendNonPremultipliedDstColor, "advancedBlendNonPremultipliedDstColor", 1);
32859
32860      print_VkBool32(obj->advancedBlendCorrelatedOverlap, "advancedBlendCorrelatedOverlap", 1);
32861
32862      print_VkBool32(obj->advancedBlendAllOperations, "advancedBlendAllOperations", 0);
32863
32864      INDENT(-4);
32865      PRINT_SPACE
32866      if (commaNeeded)
32867          _OUT << "}," << std::endl;
32868      else
32869          _OUT << "}" << std::endl;
32870 }
32871
32872 static void print_VkPipelineColorBlendAdvancedStateCreateInfoEXT(VkPipelineColorBlendAdvancedStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
32873      PRINT_SPACE
32874      _OUT << "{" << std::endl;
32875      INDENT(4);
32876
32877      print_VkStructureType(obj.sType, "sType", 1);
32878
32879       if (obj.pNext) {
32880          dumpPNextChain(obj.pNext);
32881       } else {
32882          PRINT_SPACE
32883          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32884      }
32885
32886      print_VkBool32(obj.srcPremultiplied, "srcPremultiplied", 1);
32887
32888      print_VkBool32(obj.dstPremultiplied, "dstPremultiplied", 1);
32889
32890      print_VkBlendOverlapEXT(obj.blendOverlap, "blendOverlap", 0);
32891
32892      INDENT(-4);
32893      PRINT_SPACE
32894      if (commaNeeded)
32895          _OUT << "}," << std::endl;
32896      else
32897          _OUT << "}" << std::endl;
32898 }
32899 static void print_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
32900      PRINT_SPACE
32901      _OUT << "{" << std::endl;
32902      INDENT(4);
32903
32904      print_VkStructureType(obj->sType, "sType", 1);
32905
32906       if (obj->pNext) {
32907          dumpPNextChain(obj->pNext);
32908       } else {
32909          PRINT_SPACE
32910          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
32911      }
32912
32913      print_VkBool32(obj->srcPremultiplied, "srcPremultiplied", 1);
32914
32915      print_VkBool32(obj->dstPremultiplied, "dstPremultiplied", 1);
32916
32917      print_VkBlendOverlapEXT(obj->blendOverlap, "blendOverlap", 0);
32918
32919      INDENT(-4);
32920      PRINT_SPACE
32921      if (commaNeeded)
32922          _OUT << "}," << std::endl;
32923      else
32924          _OUT << "}" << std::endl;
32925 }
32926
32927 static std::map<deUint64, std::string> VkFormatFeatureFlagBits2KHR_map = {
32928     std::make_pair(1ULL << 0, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR"),
32929     std::make_pair(1ULL << 1, "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR"),
32930     std::make_pair(1ULL << 2, "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR"),
32931     std::make_pair(1ULL << 3, "VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR"),
32932     std::make_pair(1ULL << 4, "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR"),
32933     std::make_pair(1ULL << 5, "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR"),
32934     std::make_pair(1ULL << 6, "VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR"),
32935     std::make_pair(1ULL << 7, "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR"),
32936     std::make_pair(1ULL << 8, "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR"),
32937     std::make_pair(1ULL << 9, "VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR"),
32938     std::make_pair(1ULL << 10, "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR"),
32939     std::make_pair(1ULL << 11, "VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR"),
32940     std::make_pair(1ULL << 12, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR"),
32941     std::make_pair(1ULL << 13, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT"),
32942     std::make_pair(1ULL << 14, "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR"),
32943     std::make_pair(1ULL << 15, "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR"),
32944     std::make_pair(1ULL << 16, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR"),
32945     std::make_pair(1ULL << 17, "VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR"),
32946     std::make_pair(1ULL << 18, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR"),
32947     std::make_pair(1ULL << 19, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR"),
32948     std::make_pair(1ULL << 20, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR"),
32949     std::make_pair(1ULL << 21, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR"),
32950     std::make_pair(1ULL << 22, "VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR"),
32951     std::make_pair(1ULL << 23, "VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR"),
32952     std::make_pair(1ULL << 31, "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR"),
32953     std::make_pair(1ULL << 32, "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR"),
32954     std::make_pair(1ULL << 33, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR"),
32955     std::make_pair(1ULL << 25, "VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR"),
32956     std::make_pair(1ULL << 26, "VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR"),
32957     std::make_pair(1ULL << 29, "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"),
32958     std::make_pair(1ULL << 24, "VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT"),
32959     std::make_pair(1ULL << 30, "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"),
32960     std::make_pair(1ULL << 27, "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR"),
32961     std::make_pair(1ULL << 28, "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR"),
32962 };
32963 static void print_VkFormatFeatureFlagBits2KHR(VkFormatFeatureFlagBits2KHR obj, const std::string& str, bool commaNeeded=true) {
32964      PRINT_SPACE
32965      if (str != "") _OUT << "\"" << str << "\"" << " : ";
32966      if (commaNeeded)
32967          _OUT << "\"" <<  VkFormatFeatureFlagBits2KHR_map[obj] << "\"," << std::endl;
32968      else
32969          _OUT << "\"" << VkFormatFeatureFlagBits2KHR_map[obj] << "\"" << std::endl;
32970 }
32971 static void print_VkFormatFeatureFlagBits2KHR(const VkFormatFeatureFlagBits2KHR * obj, const std::string& str, bool commaNeeded=true) {
32972      PRINT_SPACE
32973      if (str != "") _OUT << "\"" << str << "\"" << " : ";
32974      if (commaNeeded)
32975          _OUT << "\"" <<  VkFormatFeatureFlagBits2KHR_map[*obj] << "\"," << std::endl;
32976      else
32977          _OUT << "\"" << VkFormatFeatureFlagBits2KHR_map[*obj] << "\"" << std::endl;
32978 }
32979
32980 static void print_VkFormatFeatureFlags2KHR(VkFormatFeatureFlags2KHR obj, const std::string& str, bool commaNeeded=true) {
32981      PRINT_SPACE
32982      if (commaNeeded)
32983          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
32984      else
32985          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
32986 }
32987 static void print_VkFormatFeatureFlags2KHR(const VkFormatFeatureFlags2KHR * obj, const std::string& str, bool commaNeeded=true) {
32988      PRINT_SPACE
32989      if (commaNeeded)
32990          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
32991      else
32992          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
32993 }
32994
32995 static void print_VkDrmFormatModifierPropertiesEXT(VkDrmFormatModifierPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
32996      PRINT_SPACE
32997      _OUT << "{" << std::endl;
32998      INDENT(4);
32999
33000      print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 1);
33001
33002      print_uint32_t(obj.drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1);
33003
33004      print_VkFormatFeatureFlags(obj.drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0);
33005
33006      INDENT(-4);
33007      PRINT_SPACE
33008      if (commaNeeded)
33009          _OUT << "}," << std::endl;
33010      else
33011          _OUT << "}" << std::endl;
33012 }
33013 static void print_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
33014      PRINT_SPACE
33015      _OUT << "{" << std::endl;
33016      INDENT(4);
33017
33018      print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 1);
33019
33020      print_uint32_t(obj->drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1);
33021
33022      print_VkFormatFeatureFlags(obj->drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0);
33023
33024      INDENT(-4);
33025      PRINT_SPACE
33026      if (commaNeeded)
33027          _OUT << "}," << std::endl;
33028      else
33029          _OUT << "}" << std::endl;
33030 }
33031
33032 static void print_VkDrmFormatModifierPropertiesListEXT(VkDrmFormatModifierPropertiesListEXT obj, const std::string& s, bool commaNeeded=true) {
33033      PRINT_SPACE
33034      _OUT << "{" << std::endl;
33035      INDENT(4);
33036
33037      print_VkStructureType(obj.sType, "sType", 1);
33038
33039       if (obj.pNext) {
33040          dumpPNextChain(obj.pNext);
33041       } else {
33042          PRINT_SPACE
33043          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33044      }
33045
33046      print_uint32_t(obj.drmFormatModifierCount, "drmFormatModifierCount", 1);
33047
33048      PRINT_SPACE
33049      _OUT << "\"pDrmFormatModifierProperties\": " << std::endl;
33050      if (obj.pDrmFormatModifierProperties) {
33051          PRINT_SPACE
33052          _OUT << "[" << std::endl;
33053          for (unsigned int i = 0; i < obj.drmFormatModifierCount; i++) {
33054            if (i+1 == obj.drmFormatModifierCount)
33055                print_VkDrmFormatModifierPropertiesEXT(obj.pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 0);
33056            else
33057                print_VkDrmFormatModifierPropertiesEXT(obj.pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 1);
33058          }
33059          PRINT_SPACE
33060          _OUT << "]" << std::endl;
33061     }
33062      else
33063      {
33064          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
33065      }
33066
33067      INDENT(-4);
33068      PRINT_SPACE
33069      if (commaNeeded)
33070          _OUT << "}," << std::endl;
33071      else
33072          _OUT << "}" << std::endl;
33073 }
33074 static void print_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT * obj, const std::string& s, bool commaNeeded=true) {
33075      PRINT_SPACE
33076      _OUT << "{" << std::endl;
33077      INDENT(4);
33078
33079      print_VkStructureType(obj->sType, "sType", 1);
33080
33081       if (obj->pNext) {
33082          dumpPNextChain(obj->pNext);
33083       } else {
33084          PRINT_SPACE
33085          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33086      }
33087
33088      print_uint32_t(obj->drmFormatModifierCount, "drmFormatModifierCount", 1);
33089
33090      PRINT_SPACE
33091      _OUT << "\"pDrmFormatModifierProperties\": " << std::endl;
33092      if (obj->pDrmFormatModifierProperties) {
33093          PRINT_SPACE
33094          _OUT << "[" << std::endl;
33095          for (unsigned int i = 0; i < obj->drmFormatModifierCount; i++) {
33096            if (i+1 == obj->drmFormatModifierCount)
33097                print_VkDrmFormatModifierPropertiesEXT(obj->pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 0);
33098            else
33099                print_VkDrmFormatModifierPropertiesEXT(obj->pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 1);
33100          }
33101          PRINT_SPACE
33102          _OUT << "]" << std::endl;
33103     }
33104      else
33105      {
33106          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
33107      }
33108
33109      INDENT(-4);
33110      PRINT_SPACE
33111      if (commaNeeded)
33112          _OUT << "}," << std::endl;
33113      else
33114          _OUT << "}" << std::endl;
33115 }
33116
33117 static void print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(VkPhysicalDeviceImageDrmFormatModifierInfoEXT obj, const std::string& s, bool commaNeeded=true) {
33118      PRINT_SPACE
33119      _OUT << "{" << std::endl;
33120      INDENT(4);
33121
33122      print_VkStructureType(obj.sType, "sType", 1);
33123
33124       if (obj.pNext) {
33125          dumpPNextChain(obj.pNext);
33126       } else {
33127          PRINT_SPACE
33128          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33129      }
33130
33131      print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 1);
33132
33133      print_VkSharingMode(obj.sharingMode, "sharingMode", 1);
33134
33135      print_uint32_t(obj.queueFamilyIndexCount, "queueFamilyIndexCount", 1);
33136
33137      PRINT_SPACE
33138      _OUT << "\"pQueueFamilyIndices\":" << std::endl;
33139      PRINT_SPACE
33140      if (obj.pQueueFamilyIndices) {
33141        _OUT << "[" << std::endl;
33142        for (unsigned int i = 0; i < obj.queueFamilyIndexCount; i++) {
33143            bool isCommaNeeded = (i+1) != obj.queueFamilyIndexCount;
33144            print_uint32_t(obj.pQueueFamilyIndices[i], "", isCommaNeeded);
33145        }
33146        PRINT_SPACE
33147        _OUT << "]" << "" << std::endl;
33148      } else {
33149        _OUT << "\"NULL\"" << "" << std::endl;
33150      }
33151
33152      INDENT(-4);
33153      PRINT_SPACE
33154      if (commaNeeded)
33155          _OUT << "}," << std::endl;
33156      else
33157          _OUT << "}" << std::endl;
33158 }
33159 static void print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
33160      PRINT_SPACE
33161      _OUT << "{" << std::endl;
33162      INDENT(4);
33163
33164      print_VkStructureType(obj->sType, "sType", 1);
33165
33166       if (obj->pNext) {
33167          dumpPNextChain(obj->pNext);
33168       } else {
33169          PRINT_SPACE
33170          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33171      }
33172
33173      print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 1);
33174
33175      print_VkSharingMode(obj->sharingMode, "sharingMode", 1);
33176
33177      print_uint32_t(obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1);
33178
33179      PRINT_SPACE
33180      _OUT << "\"pQueueFamilyIndices\":" << std::endl;
33181      PRINT_SPACE
33182      if (obj->pQueueFamilyIndices) {
33183        _OUT << "[" << std::endl;
33184        for (unsigned int i = 0; i < obj->queueFamilyIndexCount; i++) {
33185            bool isCommaNeeded = (i+1) != obj->queueFamilyIndexCount;
33186            print_uint32_t(obj->pQueueFamilyIndices[i], "", isCommaNeeded);
33187        }
33188        PRINT_SPACE
33189        _OUT << "]" << "" << std::endl;
33190      } else {
33191        _OUT << "\"NULL\"" << "" << std::endl;
33192      }
33193
33194      INDENT(-4);
33195      PRINT_SPACE
33196      if (commaNeeded)
33197          _OUT << "}," << std::endl;
33198      else
33199          _OUT << "}" << std::endl;
33200 }
33201
33202 static void print_VkImageDrmFormatModifierListCreateInfoEXT(VkImageDrmFormatModifierListCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
33203      PRINT_SPACE
33204      _OUT << "{" << std::endl;
33205      INDENT(4);
33206
33207      print_VkStructureType(obj.sType, "sType", 1);
33208
33209       if (obj.pNext) {
33210          dumpPNextChain(obj.pNext);
33211       } else {
33212          PRINT_SPACE
33213          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33214      }
33215
33216      print_uint32_t(obj.drmFormatModifierCount, "drmFormatModifierCount", 1);
33217
33218      PRINT_SPACE
33219      _OUT << "\"pDrmFormatModifiers\":" << std::endl;
33220      PRINT_SPACE
33221      if (obj.pDrmFormatModifiers) {
33222        _OUT << "[" << std::endl;
33223        for (unsigned int i = 0; i < obj.drmFormatModifierCount; i++) {
33224            bool isCommaNeeded = (i+1) != obj.drmFormatModifierCount;
33225            print_uint64_t(obj.pDrmFormatModifiers[i], "", isCommaNeeded);
33226        }
33227        PRINT_SPACE
33228        _OUT << "]" << "" << std::endl;
33229      } else {
33230        _OUT << "\"NULL\"" << "" << std::endl;
33231      }
33232
33233      INDENT(-4);
33234      PRINT_SPACE
33235      if (commaNeeded)
33236          _OUT << "}," << std::endl;
33237      else
33238          _OUT << "}" << std::endl;
33239 }
33240 static void print_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
33241      PRINT_SPACE
33242      _OUT << "{" << std::endl;
33243      INDENT(4);
33244
33245      print_VkStructureType(obj->sType, "sType", 1);
33246
33247       if (obj->pNext) {
33248          dumpPNextChain(obj->pNext);
33249       } else {
33250          PRINT_SPACE
33251          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33252      }
33253
33254      print_uint32_t(obj->drmFormatModifierCount, "drmFormatModifierCount", 1);
33255
33256      PRINT_SPACE
33257      _OUT << "\"pDrmFormatModifiers\":" << std::endl;
33258      PRINT_SPACE
33259      if (obj->pDrmFormatModifiers) {
33260        _OUT << "[" << std::endl;
33261        for (unsigned int i = 0; i < obj->drmFormatModifierCount; i++) {
33262            bool isCommaNeeded = (i+1) != obj->drmFormatModifierCount;
33263            print_uint64_t(obj->pDrmFormatModifiers[i], "", isCommaNeeded);
33264        }
33265        PRINT_SPACE
33266        _OUT << "]" << "" << std::endl;
33267      } else {
33268        _OUT << "\"NULL\"" << "" << std::endl;
33269      }
33270
33271      INDENT(-4);
33272      PRINT_SPACE
33273      if (commaNeeded)
33274          _OUT << "}," << std::endl;
33275      else
33276          _OUT << "}" << std::endl;
33277 }
33278
33279 static void print_VkImageDrmFormatModifierExplicitCreateInfoEXT(VkImageDrmFormatModifierExplicitCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
33280      PRINT_SPACE
33281      _OUT << "{" << std::endl;
33282      INDENT(4);
33283
33284      print_VkStructureType(obj.sType, "sType", 1);
33285
33286       if (obj.pNext) {
33287          dumpPNextChain(obj.pNext);
33288       } else {
33289          PRINT_SPACE
33290          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33291      }
33292
33293      print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 1);
33294
33295      print_uint32_t(obj.drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1);
33296
33297      PRINT_SPACE
33298      _OUT << "\"pPlaneLayouts\": " << std::endl;
33299      if (obj.pPlaneLayouts) {
33300          PRINT_SPACE
33301          _OUT << "[" << std::endl;
33302          for (unsigned int i = 0; i < obj.drmFormatModifierPlaneCount; i++) {
33303            if (i+1 == obj.drmFormatModifierPlaneCount)
33304                print_VkSubresourceLayout(obj.pPlaneLayouts[i], "pPlaneLayouts", 0);
33305            else
33306                print_VkSubresourceLayout(obj.pPlaneLayouts[i], "pPlaneLayouts", 1);
33307          }
33308          PRINT_SPACE
33309          _OUT << "]" << std::endl;
33310     }
33311      else
33312      {
33313          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
33314      }
33315
33316      INDENT(-4);
33317      PRINT_SPACE
33318      if (commaNeeded)
33319          _OUT << "}," << std::endl;
33320      else
33321          _OUT << "}" << std::endl;
33322 }
33323 static void print_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
33324      PRINT_SPACE
33325      _OUT << "{" << std::endl;
33326      INDENT(4);
33327
33328      print_VkStructureType(obj->sType, "sType", 1);
33329
33330       if (obj->pNext) {
33331          dumpPNextChain(obj->pNext);
33332       } else {
33333          PRINT_SPACE
33334          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33335      }
33336
33337      print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 1);
33338
33339      print_uint32_t(obj->drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1);
33340
33341      PRINT_SPACE
33342      _OUT << "\"pPlaneLayouts\": " << std::endl;
33343      if (obj->pPlaneLayouts) {
33344          PRINT_SPACE
33345          _OUT << "[" << std::endl;
33346          for (unsigned int i = 0; i < obj->drmFormatModifierPlaneCount; i++) {
33347            if (i+1 == obj->drmFormatModifierPlaneCount)
33348                print_VkSubresourceLayout(obj->pPlaneLayouts[i], "pPlaneLayouts", 0);
33349            else
33350                print_VkSubresourceLayout(obj->pPlaneLayouts[i], "pPlaneLayouts", 1);
33351          }
33352          PRINT_SPACE
33353          _OUT << "]" << std::endl;
33354     }
33355      else
33356      {
33357          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
33358      }
33359
33360      INDENT(-4);
33361      PRINT_SPACE
33362      if (commaNeeded)
33363          _OUT << "}," << std::endl;
33364      else
33365          _OUT << "}" << std::endl;
33366 }
33367
33368 static void print_VkImageDrmFormatModifierPropertiesEXT(VkImageDrmFormatModifierPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
33369      PRINT_SPACE
33370      _OUT << "{" << std::endl;
33371      INDENT(4);
33372
33373      print_VkStructureType(obj.sType, "sType", 1);
33374
33375       if (obj.pNext) {
33376          dumpPNextChain(obj.pNext);
33377       } else {
33378          PRINT_SPACE
33379          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33380      }
33381
33382      print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 0);
33383
33384      INDENT(-4);
33385      PRINT_SPACE
33386      if (commaNeeded)
33387          _OUT << "}," << std::endl;
33388      else
33389          _OUT << "}" << std::endl;
33390 }
33391 static void print_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
33392      PRINT_SPACE
33393      _OUT << "{" << std::endl;
33394      INDENT(4);
33395
33396      print_VkStructureType(obj->sType, "sType", 1);
33397
33398       if (obj->pNext) {
33399          dumpPNextChain(obj->pNext);
33400       } else {
33401          PRINT_SPACE
33402          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33403      }
33404
33405      print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 0);
33406
33407      INDENT(-4);
33408      PRINT_SPACE
33409      if (commaNeeded)
33410          _OUT << "}," << std::endl;
33411      else
33412          _OUT << "}" << std::endl;
33413 }
33414
33415 static void print_VkDrmFormatModifierProperties2EXT(VkDrmFormatModifierProperties2EXT obj, const std::string& s, bool commaNeeded=true) {
33416      PRINT_SPACE
33417      _OUT << "{" << std::endl;
33418      INDENT(4);
33419
33420      print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 1);
33421
33422      print_uint32_t(obj.drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1);
33423
33424      print_VkFormatFeatureFlags2KHR(obj.drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0);
33425
33426      INDENT(-4);
33427      PRINT_SPACE
33428      if (commaNeeded)
33429          _OUT << "}," << std::endl;
33430      else
33431          _OUT << "}" << std::endl;
33432 }
33433 static void print_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT * obj, const std::string& s, bool commaNeeded=true) {
33434      PRINT_SPACE
33435      _OUT << "{" << std::endl;
33436      INDENT(4);
33437
33438      print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 1);
33439
33440      print_uint32_t(obj->drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1);
33441
33442      print_VkFormatFeatureFlags2KHR(obj->drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0);
33443
33444      INDENT(-4);
33445      PRINT_SPACE
33446      if (commaNeeded)
33447          _OUT << "}," << std::endl;
33448      else
33449          _OUT << "}" << std::endl;
33450 }
33451
33452 static void print_VkDrmFormatModifierPropertiesList2EXT(VkDrmFormatModifierPropertiesList2EXT obj, const std::string& s, bool commaNeeded=true) {
33453      PRINT_SPACE
33454      _OUT << "{" << std::endl;
33455      INDENT(4);
33456
33457      print_VkStructureType(obj.sType, "sType", 1);
33458
33459       if (obj.pNext) {
33460          dumpPNextChain(obj.pNext);
33461       } else {
33462          PRINT_SPACE
33463          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33464      }
33465
33466      print_uint32_t(obj.drmFormatModifierCount, "drmFormatModifierCount", 1);
33467
33468      PRINT_SPACE
33469      _OUT << "\"pDrmFormatModifierProperties\": " << std::endl;
33470      if (obj.pDrmFormatModifierProperties) {
33471          PRINT_SPACE
33472          _OUT << "[" << std::endl;
33473          for (unsigned int i = 0; i < obj.drmFormatModifierCount; i++) {
33474            if (i+1 == obj.drmFormatModifierCount)
33475                print_VkDrmFormatModifierProperties2EXT(obj.pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 0);
33476            else
33477                print_VkDrmFormatModifierProperties2EXT(obj.pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 1);
33478          }
33479          PRINT_SPACE
33480          _OUT << "]" << std::endl;
33481     }
33482      else
33483      {
33484          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
33485      }
33486
33487      INDENT(-4);
33488      PRINT_SPACE
33489      if (commaNeeded)
33490          _OUT << "}," << std::endl;
33491      else
33492          _OUT << "}" << std::endl;
33493 }
33494 static void print_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT * obj, const std::string& s, bool commaNeeded=true) {
33495      PRINT_SPACE
33496      _OUT << "{" << std::endl;
33497      INDENT(4);
33498
33499      print_VkStructureType(obj->sType, "sType", 1);
33500
33501       if (obj->pNext) {
33502          dumpPNextChain(obj->pNext);
33503       } else {
33504          PRINT_SPACE
33505          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33506      }
33507
33508      print_uint32_t(obj->drmFormatModifierCount, "drmFormatModifierCount", 1);
33509
33510      PRINT_SPACE
33511      _OUT << "\"pDrmFormatModifierProperties\": " << std::endl;
33512      if (obj->pDrmFormatModifierProperties) {
33513          PRINT_SPACE
33514          _OUT << "[" << std::endl;
33515          for (unsigned int i = 0; i < obj->drmFormatModifierCount; i++) {
33516            if (i+1 == obj->drmFormatModifierCount)
33517                print_VkDrmFormatModifierProperties2EXT(obj->pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 0);
33518            else
33519                print_VkDrmFormatModifierProperties2EXT(obj->pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 1);
33520          }
33521          PRINT_SPACE
33522          _OUT << "]" << std::endl;
33523     }
33524      else
33525      {
33526          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
33527      }
33528
33529      INDENT(-4);
33530      PRINT_SPACE
33531      if (commaNeeded)
33532          _OUT << "}," << std::endl;
33533      else
33534          _OUT << "}" << std::endl;
33535 }
33536
33537 static void print_VkPhysicalDeviceImageViewImageFormatInfoEXT(VkPhysicalDeviceImageViewImageFormatInfoEXT obj, const std::string& s, bool commaNeeded=true) {
33538      PRINT_SPACE
33539      _OUT << "{" << std::endl;
33540      INDENT(4);
33541
33542      print_VkStructureType(obj.sType, "sType", 1);
33543
33544       if (obj.pNext) {
33545          dumpPNextChain(obj.pNext);
33546       } else {
33547          PRINT_SPACE
33548          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33549      }
33550
33551      print_VkImageViewType(obj.imageViewType, "imageViewType", 0);
33552
33553      INDENT(-4);
33554      PRINT_SPACE
33555      if (commaNeeded)
33556          _OUT << "}," << std::endl;
33557      else
33558          _OUT << "}" << std::endl;
33559 }
33560 static void print_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
33561      PRINT_SPACE
33562      _OUT << "{" << std::endl;
33563      INDENT(4);
33564
33565      print_VkStructureType(obj->sType, "sType", 1);
33566
33567       if (obj->pNext) {
33568          dumpPNextChain(obj->pNext);
33569       } else {
33570          PRINT_SPACE
33571          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33572      }
33573
33574      print_VkImageViewType(obj->imageViewType, "imageViewType", 0);
33575
33576      INDENT(-4);
33577      PRINT_SPACE
33578      if (commaNeeded)
33579          _OUT << "}," << std::endl;
33580      else
33581          _OUT << "}" << std::endl;
33582 }
33583
33584 static void print_VkFilterCubicImageViewImageFormatPropertiesEXT(VkFilterCubicImageViewImageFormatPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
33585      PRINT_SPACE
33586      _OUT << "{" << std::endl;
33587      INDENT(4);
33588
33589      print_VkStructureType(obj.sType, "sType", 1);
33590
33591       if (obj.pNext) {
33592          dumpPNextChain(obj.pNext);
33593       } else {
33594          PRINT_SPACE
33595          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33596      }
33597
33598      print_VkBool32(obj.filterCubic, "filterCubic", 1);
33599
33600      print_VkBool32(obj.filterCubicMinmax, "filterCubicMinmax", 0);
33601
33602      INDENT(-4);
33603      PRINT_SPACE
33604      if (commaNeeded)
33605          _OUT << "}," << std::endl;
33606      else
33607          _OUT << "}" << std::endl;
33608 }
33609 static void print_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
33610      PRINT_SPACE
33611      _OUT << "{" << std::endl;
33612      INDENT(4);
33613
33614      print_VkStructureType(obj->sType, "sType", 1);
33615
33616       if (obj->pNext) {
33617          dumpPNextChain(obj->pNext);
33618       } else {
33619          PRINT_SPACE
33620          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33621      }
33622
33623      print_VkBool32(obj->filterCubic, "filterCubic", 1);
33624
33625      print_VkBool32(obj->filterCubicMinmax, "filterCubicMinmax", 0);
33626
33627      INDENT(-4);
33628      PRINT_SPACE
33629      if (commaNeeded)
33630          _OUT << "}," << std::endl;
33631      else
33632          _OUT << "}" << std::endl;
33633 }
33634
33635 static std::map<deUint64, std::string> VkQueueGlobalPriorityEXT_map = {
33636     std::make_pair(128, "VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT"),
33637     std::make_pair(256, "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT"),
33638     std::make_pair(512, "VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT"),
33639     std::make_pair(1024, "VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT"),
33640 };
33641 static void print_VkQueueGlobalPriorityEXT(VkQueueGlobalPriorityEXT obj, const std::string& str, bool commaNeeded=true) {
33642      PRINT_SPACE
33643      if (str != "") _OUT << "\"" << str << "\"" << " : ";
33644      if (commaNeeded)
33645          _OUT << "\"" <<  VkQueueGlobalPriorityEXT_map[obj] << "\"," << std::endl;
33646      else
33647          _OUT << "\"" << VkQueueGlobalPriorityEXT_map[obj] << "\"" << std::endl;
33648 }
33649 static void print_VkQueueGlobalPriorityEXT(const VkQueueGlobalPriorityEXT * obj, const std::string& str, bool commaNeeded=true) {
33650      PRINT_SPACE
33651      if (str != "") _OUT << "\"" << str << "\"" << " : ";
33652      if (commaNeeded)
33653          _OUT << "\"" <<  VkQueueGlobalPriorityEXT_map[*obj] << "\"," << std::endl;
33654      else
33655          _OUT << "\"" << VkQueueGlobalPriorityEXT_map[*obj] << "\"" << std::endl;
33656 }
33657
33658 static void print_VkDeviceQueueGlobalPriorityCreateInfoEXT(VkDeviceQueueGlobalPriorityCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
33659      PRINT_SPACE
33660      _OUT << "{" << std::endl;
33661      INDENT(4);
33662
33663      print_VkStructureType(obj.sType, "sType", 1);
33664
33665       if (obj.pNext) {
33666          dumpPNextChain(obj.pNext);
33667       } else {
33668          PRINT_SPACE
33669          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33670      }
33671
33672      print_VkQueueGlobalPriorityEXT(obj.globalPriority, "globalPriority", 0);
33673
33674      INDENT(-4);
33675      PRINT_SPACE
33676      if (commaNeeded)
33677          _OUT << "}," << std::endl;
33678      else
33679          _OUT << "}" << std::endl;
33680 }
33681 static void print_VkDeviceQueueGlobalPriorityCreateInfoEXT(const VkDeviceQueueGlobalPriorityCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
33682      PRINT_SPACE
33683      _OUT << "{" << std::endl;
33684      INDENT(4);
33685
33686      print_VkStructureType(obj->sType, "sType", 1);
33687
33688       if (obj->pNext) {
33689          dumpPNextChain(obj->pNext);
33690       } else {
33691          PRINT_SPACE
33692          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33693      }
33694
33695      print_VkQueueGlobalPriorityEXT(obj->globalPriority, "globalPriority", 0);
33696
33697      INDENT(-4);
33698      PRINT_SPACE
33699      if (commaNeeded)
33700          _OUT << "}," << std::endl;
33701      else
33702          _OUT << "}" << std::endl;
33703 }
33704
33705 static void print_VkImportMemoryHostPointerInfoEXT(VkImportMemoryHostPointerInfoEXT obj, const std::string& s, bool commaNeeded=true) {
33706      PRINT_SPACE
33707      _OUT << "{" << std::endl;
33708      INDENT(4);
33709
33710      print_VkStructureType(obj.sType, "sType", 1);
33711
33712       if (obj.pNext) {
33713          dumpPNextChain(obj.pNext);
33714       } else {
33715          PRINT_SPACE
33716          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33717      }
33718
33719      print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 1);
33720
33721      /** Note: Ignoring void* data. **/
33722
33723      INDENT(-4);
33724      PRINT_SPACE
33725      if (commaNeeded)
33726          _OUT << "}," << std::endl;
33727      else
33728          _OUT << "}" << std::endl;
33729 }
33730 static void print_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
33731      PRINT_SPACE
33732      _OUT << "{" << std::endl;
33733      INDENT(4);
33734
33735      print_VkStructureType(obj->sType, "sType", 1);
33736
33737       if (obj->pNext) {
33738          dumpPNextChain(obj->pNext);
33739       } else {
33740          PRINT_SPACE
33741          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33742      }
33743
33744      print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 1);
33745
33746      /** Note: Ignoring void* data. **/
33747
33748      INDENT(-4);
33749      PRINT_SPACE
33750      if (commaNeeded)
33751          _OUT << "}," << std::endl;
33752      else
33753          _OUT << "}" << std::endl;
33754 }
33755
33756 static void print_VkMemoryHostPointerPropertiesEXT(VkMemoryHostPointerPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
33757      PRINT_SPACE
33758      _OUT << "{" << std::endl;
33759      INDENT(4);
33760
33761      print_VkStructureType(obj.sType, "sType", 1);
33762
33763       if (obj.pNext) {
33764          dumpPNextChain(obj.pNext);
33765       } else {
33766          PRINT_SPACE
33767          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33768      }
33769
33770      print_uint32_t(obj.memoryTypeBits, "memoryTypeBits", 0);
33771
33772      INDENT(-4);
33773      PRINT_SPACE
33774      if (commaNeeded)
33775          _OUT << "}," << std::endl;
33776      else
33777          _OUT << "}" << std::endl;
33778 }
33779 static void print_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
33780      PRINT_SPACE
33781      _OUT << "{" << std::endl;
33782      INDENT(4);
33783
33784      print_VkStructureType(obj->sType, "sType", 1);
33785
33786       if (obj->pNext) {
33787          dumpPNextChain(obj->pNext);
33788       } else {
33789          PRINT_SPACE
33790          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33791      }
33792
33793      print_uint32_t(obj->memoryTypeBits, "memoryTypeBits", 0);
33794
33795      INDENT(-4);
33796      PRINT_SPACE
33797      if (commaNeeded)
33798          _OUT << "}," << std::endl;
33799      else
33800          _OUT << "}" << std::endl;
33801 }
33802
33803 static void print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(VkPhysicalDeviceExternalMemoryHostPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
33804      PRINT_SPACE
33805      _OUT << "{" << std::endl;
33806      INDENT(4);
33807
33808      print_VkStructureType(obj.sType, "sType", 1);
33809
33810       if (obj.pNext) {
33811          dumpPNextChain(obj.pNext);
33812       } else {
33813          PRINT_SPACE
33814          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33815      }
33816
33817      print_VkDeviceSize(obj.minImportedHostPointerAlignment, "minImportedHostPointerAlignment", 0);
33818
33819      INDENT(-4);
33820      PRINT_SPACE
33821      if (commaNeeded)
33822          _OUT << "}," << std::endl;
33823      else
33824          _OUT << "}" << std::endl;
33825 }
33826 static void print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
33827      PRINT_SPACE
33828      _OUT << "{" << std::endl;
33829      INDENT(4);
33830
33831      print_VkStructureType(obj->sType, "sType", 1);
33832
33833       if (obj->pNext) {
33834          dumpPNextChain(obj->pNext);
33835       } else {
33836          PRINT_SPACE
33837          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33838      }
33839
33840      print_VkDeviceSize(obj->minImportedHostPointerAlignment, "minImportedHostPointerAlignment", 0);
33841
33842      INDENT(-4);
33843      PRINT_SPACE
33844      if (commaNeeded)
33845          _OUT << "}," << std::endl;
33846      else
33847          _OUT << "}" << std::endl;
33848 }
33849
33850 static std::map<deUint64, std::string> VkTimeDomainEXT_map = {
33851     std::make_pair(0, "VK_TIME_DOMAIN_DEVICE_EXT"),
33852     std::make_pair(1, "VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT"),
33853     std::make_pair(2, "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT"),
33854     std::make_pair(3, "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT"),
33855 };
33856 static void print_VkTimeDomainEXT(VkTimeDomainEXT obj, const std::string& str, bool commaNeeded=true) {
33857      PRINT_SPACE
33858      if (str != "") _OUT << "\"" << str << "\"" << " : ";
33859      if (commaNeeded)
33860          _OUT << "\"" <<  VkTimeDomainEXT_map[obj] << "\"," << std::endl;
33861      else
33862          _OUT << "\"" << VkTimeDomainEXT_map[obj] << "\"" << std::endl;
33863 }
33864 static void print_VkTimeDomainEXT(const VkTimeDomainEXT * obj, const std::string& str, bool commaNeeded=true) {
33865      PRINT_SPACE
33866      if (str != "") _OUT << "\"" << str << "\"" << " : ";
33867      if (commaNeeded)
33868          _OUT << "\"" <<  VkTimeDomainEXT_map[*obj] << "\"," << std::endl;
33869      else
33870          _OUT << "\"" << VkTimeDomainEXT_map[*obj] << "\"" << std::endl;
33871 }
33872
33873 static void print_VkCalibratedTimestampInfoEXT(VkCalibratedTimestampInfoEXT obj, const std::string& s, bool commaNeeded=true) {
33874      PRINT_SPACE
33875      _OUT << "{" << std::endl;
33876      INDENT(4);
33877
33878      print_VkStructureType(obj.sType, "sType", 1);
33879
33880       if (obj.pNext) {
33881          dumpPNextChain(obj.pNext);
33882       } else {
33883          PRINT_SPACE
33884          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33885      }
33886
33887      print_VkTimeDomainEXT(obj.timeDomain, "timeDomain", 0);
33888
33889      INDENT(-4);
33890      PRINT_SPACE
33891      if (commaNeeded)
33892          _OUT << "}," << std::endl;
33893      else
33894          _OUT << "}" << std::endl;
33895 }
33896 static void print_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
33897      PRINT_SPACE
33898      _OUT << "{" << std::endl;
33899      INDENT(4);
33900
33901      print_VkStructureType(obj->sType, "sType", 1);
33902
33903       if (obj->pNext) {
33904          dumpPNextChain(obj->pNext);
33905       } else {
33906          PRINT_SPACE
33907          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33908      }
33909
33910      print_VkTimeDomainEXT(obj->timeDomain, "timeDomain", 0);
33911
33912      INDENT(-4);
33913      PRINT_SPACE
33914      if (commaNeeded)
33915          _OUT << "}," << std::endl;
33916      else
33917          _OUT << "}" << std::endl;
33918 }
33919
33920 static void print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
33921      PRINT_SPACE
33922      _OUT << "{" << std::endl;
33923      INDENT(4);
33924
33925      print_VkStructureType(obj.sType, "sType", 1);
33926
33927       if (obj.pNext) {
33928          dumpPNextChain(obj.pNext);
33929       } else {
33930          PRINT_SPACE
33931          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33932      }
33933
33934      print_uint32_t(obj.maxVertexAttribDivisor, "maxVertexAttribDivisor", 0);
33935
33936      INDENT(-4);
33937      PRINT_SPACE
33938      if (commaNeeded)
33939          _OUT << "}," << std::endl;
33940      else
33941          _OUT << "}" << std::endl;
33942 }
33943 static void print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
33944      PRINT_SPACE
33945      _OUT << "{" << std::endl;
33946      INDENT(4);
33947
33948      print_VkStructureType(obj->sType, "sType", 1);
33949
33950       if (obj->pNext) {
33951          dumpPNextChain(obj->pNext);
33952       } else {
33953          PRINT_SPACE
33954          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
33955      }
33956
33957      print_uint32_t(obj->maxVertexAttribDivisor, "maxVertexAttribDivisor", 0);
33958
33959      INDENT(-4);
33960      PRINT_SPACE
33961      if (commaNeeded)
33962          _OUT << "}," << std::endl;
33963      else
33964          _OUT << "}" << std::endl;
33965 }
33966
33967 static void print_VkVertexInputBindingDivisorDescriptionEXT(VkVertexInputBindingDivisorDescriptionEXT obj, const std::string& s, bool commaNeeded=true) {
33968      PRINT_SPACE
33969      _OUT << "{" << std::endl;
33970      INDENT(4);
33971
33972      print_uint32_t(obj.binding, "binding", 1);
33973
33974      print_uint32_t(obj.divisor, "divisor", 0);
33975
33976      INDENT(-4);
33977      PRINT_SPACE
33978      if (commaNeeded)
33979          _OUT << "}," << std::endl;
33980      else
33981          _OUT << "}" << std::endl;
33982 }
33983 static void print_VkVertexInputBindingDivisorDescriptionEXT(const VkVertexInputBindingDivisorDescriptionEXT * obj, const std::string& s, bool commaNeeded=true) {
33984      PRINT_SPACE
33985      _OUT << "{" << std::endl;
33986      INDENT(4);
33987
33988      print_uint32_t(obj->binding, "binding", 1);
33989
33990      print_uint32_t(obj->divisor, "divisor", 0);
33991
33992      INDENT(-4);
33993      PRINT_SPACE
33994      if (commaNeeded)
33995          _OUT << "}," << std::endl;
33996      else
33997          _OUT << "}" << std::endl;
33998 }
33999
34000 static void print_VkPipelineVertexInputDivisorStateCreateInfoEXT(VkPipelineVertexInputDivisorStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
34001      PRINT_SPACE
34002      _OUT << "{" << std::endl;
34003      INDENT(4);
34004
34005      print_VkStructureType(obj.sType, "sType", 1);
34006
34007       if (obj.pNext) {
34008          dumpPNextChain(obj.pNext);
34009       } else {
34010          PRINT_SPACE
34011          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34012      }
34013
34014      print_uint32_t(obj.vertexBindingDivisorCount, "vertexBindingDivisorCount", 1);
34015
34016      PRINT_SPACE
34017      _OUT << "\"pVertexBindingDivisors\": " << std::endl;
34018      if (obj.pVertexBindingDivisors) {
34019          PRINT_SPACE
34020          _OUT << "[" << std::endl;
34021          for (unsigned int i = 0; i < obj.vertexBindingDivisorCount; i++) {
34022            if (i+1 == obj.vertexBindingDivisorCount)
34023                print_VkVertexInputBindingDivisorDescriptionEXT(obj.pVertexBindingDivisors[i], "pVertexBindingDivisors", 0);
34024            else
34025                print_VkVertexInputBindingDivisorDescriptionEXT(obj.pVertexBindingDivisors[i], "pVertexBindingDivisors", 1);
34026          }
34027          PRINT_SPACE
34028          _OUT << "]" << std::endl;
34029     }
34030      else
34031      {
34032          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
34033      }
34034
34035      INDENT(-4);
34036      PRINT_SPACE
34037      if (commaNeeded)
34038          _OUT << "}," << std::endl;
34039      else
34040          _OUT << "}" << std::endl;
34041 }
34042 static void print_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
34043      PRINT_SPACE
34044      _OUT << "{" << std::endl;
34045      INDENT(4);
34046
34047      print_VkStructureType(obj->sType, "sType", 1);
34048
34049       if (obj->pNext) {
34050          dumpPNextChain(obj->pNext);
34051       } else {
34052          PRINT_SPACE
34053          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34054      }
34055
34056      print_uint32_t(obj->vertexBindingDivisorCount, "vertexBindingDivisorCount", 1);
34057
34058      PRINT_SPACE
34059      _OUT << "\"pVertexBindingDivisors\": " << std::endl;
34060      if (obj->pVertexBindingDivisors) {
34061          PRINT_SPACE
34062          _OUT << "[" << std::endl;
34063          for (unsigned int i = 0; i < obj->vertexBindingDivisorCount; i++) {
34064            if (i+1 == obj->vertexBindingDivisorCount)
34065                print_VkVertexInputBindingDivisorDescriptionEXT(obj->pVertexBindingDivisors[i], "pVertexBindingDivisors", 0);
34066            else
34067                print_VkVertexInputBindingDivisorDescriptionEXT(obj->pVertexBindingDivisors[i], "pVertexBindingDivisors", 1);
34068          }
34069          PRINT_SPACE
34070          _OUT << "]" << std::endl;
34071     }
34072      else
34073      {
34074          PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl;
34075      }
34076
34077      INDENT(-4);
34078      PRINT_SPACE
34079      if (commaNeeded)
34080          _OUT << "}," << std::endl;
34081      else
34082          _OUT << "}" << std::endl;
34083 }
34084
34085 static void print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
34086      PRINT_SPACE
34087      _OUT << "{" << std::endl;
34088      INDENT(4);
34089
34090      print_VkStructureType(obj.sType, "sType", 1);
34091
34092       if (obj.pNext) {
34093          dumpPNextChain(obj.pNext);
34094       } else {
34095          PRINT_SPACE
34096          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34097      }
34098
34099      print_VkBool32(obj.vertexAttributeInstanceRateDivisor, "vertexAttributeInstanceRateDivisor", 1);
34100
34101      print_VkBool32(obj.vertexAttributeInstanceRateZeroDivisor, "vertexAttributeInstanceRateZeroDivisor", 0);
34102
34103      INDENT(-4);
34104      PRINT_SPACE
34105      if (commaNeeded)
34106          _OUT << "}," << std::endl;
34107      else
34108          _OUT << "}" << std::endl;
34109 }
34110 static void print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
34111      PRINT_SPACE
34112      _OUT << "{" << std::endl;
34113      INDENT(4);
34114
34115      print_VkStructureType(obj->sType, "sType", 1);
34116
34117       if (obj->pNext) {
34118          dumpPNextChain(obj->pNext);
34119       } else {
34120          PRINT_SPACE
34121          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34122      }
34123
34124      print_VkBool32(obj->vertexAttributeInstanceRateDivisor, "vertexAttributeInstanceRateDivisor", 1);
34125
34126      print_VkBool32(obj->vertexAttributeInstanceRateZeroDivisor, "vertexAttributeInstanceRateZeroDivisor", 0);
34127
34128      INDENT(-4);
34129      PRINT_SPACE
34130      if (commaNeeded)
34131          _OUT << "}," << std::endl;
34132      else
34133          _OUT << "}" << std::endl;
34134 }
34135
34136 static void print_VkPhysicalDevicePCIBusInfoPropertiesEXT(VkPhysicalDevicePCIBusInfoPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
34137      PRINT_SPACE
34138      _OUT << "{" << std::endl;
34139      INDENT(4);
34140
34141      print_VkStructureType(obj.sType, "sType", 1);
34142
34143       if (obj.pNext) {
34144          dumpPNextChain(obj.pNext);
34145       } else {
34146          PRINT_SPACE
34147          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34148      }
34149
34150      print_uint32_t(obj.pciDomain, "pciDomain", 1);
34151
34152      print_uint32_t(obj.pciBus, "pciBus", 1);
34153
34154      print_uint32_t(obj.pciDevice, "pciDevice", 1);
34155
34156      print_uint32_t(obj.pciFunction, "pciFunction", 0);
34157
34158      INDENT(-4);
34159      PRINT_SPACE
34160      if (commaNeeded)
34161          _OUT << "}," << std::endl;
34162      else
34163          _OUT << "}" << std::endl;
34164 }
34165 static void print_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
34166      PRINT_SPACE
34167      _OUT << "{" << std::endl;
34168      INDENT(4);
34169
34170      print_VkStructureType(obj->sType, "sType", 1);
34171
34172       if (obj->pNext) {
34173          dumpPNextChain(obj->pNext);
34174       } else {
34175          PRINT_SPACE
34176          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34177      }
34178
34179      print_uint32_t(obj->pciDomain, "pciDomain", 1);
34180
34181      print_uint32_t(obj->pciBus, "pciBus", 1);
34182
34183      print_uint32_t(obj->pciDevice, "pciDevice", 1);
34184
34185      print_uint32_t(obj->pciFunction, "pciFunction", 0);
34186
34187      INDENT(-4);
34188      PRINT_SPACE
34189      if (commaNeeded)
34190          _OUT << "}," << std::endl;
34191      else
34192          _OUT << "}" << std::endl;
34193 }
34194
34195 static void print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(VkPhysicalDeviceSubgroupSizeControlFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
34196      PRINT_SPACE
34197      _OUT << "{" << std::endl;
34198      INDENT(4);
34199
34200      print_VkStructureType(obj.sType, "sType", 1);
34201
34202       if (obj.pNext) {
34203          dumpPNextChain(obj.pNext);
34204       } else {
34205          PRINT_SPACE
34206          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34207      }
34208
34209      print_VkBool32(obj.subgroupSizeControl, "subgroupSizeControl", 1);
34210
34211      print_VkBool32(obj.computeFullSubgroups, "computeFullSubgroups", 0);
34212
34213      INDENT(-4);
34214      PRINT_SPACE
34215      if (commaNeeded)
34216          _OUT << "}," << std::endl;
34217      else
34218          _OUT << "}" << std::endl;
34219 }
34220 static void print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
34221      PRINT_SPACE
34222      _OUT << "{" << std::endl;
34223      INDENT(4);
34224
34225      print_VkStructureType(obj->sType, "sType", 1);
34226
34227       if (obj->pNext) {
34228          dumpPNextChain(obj->pNext);
34229       } else {
34230          PRINT_SPACE
34231          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34232      }
34233
34234      print_VkBool32(obj->subgroupSizeControl, "subgroupSizeControl", 1);
34235
34236      print_VkBool32(obj->computeFullSubgroups, "computeFullSubgroups", 0);
34237
34238      INDENT(-4);
34239      PRINT_SPACE
34240      if (commaNeeded)
34241          _OUT << "}," << std::endl;
34242      else
34243          _OUT << "}" << std::endl;
34244 }
34245
34246 static void print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
34247      PRINT_SPACE
34248      _OUT << "{" << std::endl;
34249      INDENT(4);
34250
34251      print_VkStructureType(obj.sType, "sType", 1);
34252
34253       if (obj.pNext) {
34254          dumpPNextChain(obj.pNext);
34255       } else {
34256          PRINT_SPACE
34257          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34258      }
34259
34260      print_uint32_t(obj.minSubgroupSize, "minSubgroupSize", 1);
34261
34262      print_uint32_t(obj.maxSubgroupSize, "maxSubgroupSize", 1);
34263
34264      print_uint32_t(obj.maxComputeWorkgroupSubgroups, "maxComputeWorkgroupSubgroups", 1);
34265
34266      print_VkShaderStageFlags(obj.requiredSubgroupSizeStages, "requiredSubgroupSizeStages", 0);
34267
34268      INDENT(-4);
34269      PRINT_SPACE
34270      if (commaNeeded)
34271          _OUT << "}," << std::endl;
34272      else
34273          _OUT << "}" << std::endl;
34274 }
34275 static void print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
34276      PRINT_SPACE
34277      _OUT << "{" << std::endl;
34278      INDENT(4);
34279
34280      print_VkStructureType(obj->sType, "sType", 1);
34281
34282       if (obj->pNext) {
34283          dumpPNextChain(obj->pNext);
34284       } else {
34285          PRINT_SPACE
34286          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34287      }
34288
34289      print_uint32_t(obj->minSubgroupSize, "minSubgroupSize", 1);
34290
34291      print_uint32_t(obj->maxSubgroupSize, "maxSubgroupSize", 1);
34292
34293      print_uint32_t(obj->maxComputeWorkgroupSubgroups, "maxComputeWorkgroupSubgroups", 1);
34294
34295      print_VkShaderStageFlags(obj->requiredSubgroupSizeStages, "requiredSubgroupSizeStages", 0);
34296
34297      INDENT(-4);
34298      PRINT_SPACE
34299      if (commaNeeded)
34300          _OUT << "}," << std::endl;
34301      else
34302          _OUT << "}" << std::endl;
34303 }
34304
34305 static void print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
34306      PRINT_SPACE
34307      _OUT << "{" << std::endl;
34308      INDENT(4);
34309
34310      print_VkStructureType(obj.sType, "sType", 1);
34311
34312       if (obj.pNext) {
34313          dumpPNextChain(obj.pNext);
34314       } else {
34315          PRINT_SPACE
34316          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34317      }
34318
34319      print_uint32_t(obj.requiredSubgroupSize, "requiredSubgroupSize", 0);
34320
34321      INDENT(-4);
34322      PRINT_SPACE
34323      if (commaNeeded)
34324          _OUT << "}," << std::endl;
34325      else
34326          _OUT << "}" << std::endl;
34327 }
34328 static void print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
34329      PRINT_SPACE
34330      _OUT << "{" << std::endl;
34331      INDENT(4);
34332
34333      print_VkStructureType(obj->sType, "sType", 1);
34334
34335       if (obj->pNext) {
34336          dumpPNextChain(obj->pNext);
34337       } else {
34338          PRINT_SPACE
34339          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34340      }
34341
34342      print_uint32_t(obj->requiredSubgroupSize, "requiredSubgroupSize", 0);
34343
34344      INDENT(-4);
34345      PRINT_SPACE
34346      if (commaNeeded)
34347          _OUT << "}," << std::endl;
34348      else
34349          _OUT << "}" << std::endl;
34350 }
34351
34352 static void print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
34353      PRINT_SPACE
34354      _OUT << "{" << std::endl;
34355      INDENT(4);
34356
34357      print_VkStructureType(obj.sType, "sType", 1);
34358
34359       if (obj.pNext) {
34360          dumpPNextChain(obj.pNext);
34361       } else {
34362          PRINT_SPACE
34363          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34364      }
34365
34366      print_VkBool32(obj.shaderImageInt64Atomics, "shaderImageInt64Atomics", 1);
34367
34368      print_VkBool32(obj.sparseImageInt64Atomics, "sparseImageInt64Atomics", 0);
34369
34370      INDENT(-4);
34371      PRINT_SPACE
34372      if (commaNeeded)
34373          _OUT << "}," << std::endl;
34374      else
34375          _OUT << "}" << std::endl;
34376 }
34377 static void print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
34378      PRINT_SPACE
34379      _OUT << "{" << std::endl;
34380      INDENT(4);
34381
34382      print_VkStructureType(obj->sType, "sType", 1);
34383
34384       if (obj->pNext) {
34385          dumpPNextChain(obj->pNext);
34386       } else {
34387          PRINT_SPACE
34388          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34389      }
34390
34391      print_VkBool32(obj->shaderImageInt64Atomics, "shaderImageInt64Atomics", 1);
34392
34393      print_VkBool32(obj->sparseImageInt64Atomics, "sparseImageInt64Atomics", 0);
34394
34395      INDENT(-4);
34396      PRINT_SPACE
34397      if (commaNeeded)
34398          _OUT << "}," << std::endl;
34399      else
34400          _OUT << "}" << std::endl;
34401 }
34402
34403 static void print_VkPhysicalDeviceMemoryBudgetPropertiesEXT(VkPhysicalDeviceMemoryBudgetPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
34404      PRINT_SPACE
34405      _OUT << "{" << std::endl;
34406      INDENT(4);
34407
34408      print_VkStructureType(obj.sType, "sType", 1);
34409
34410       if (obj.pNext) {
34411          dumpPNextChain(obj.pNext);
34412       } else {
34413          PRINT_SPACE
34414          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34415      }
34416
34417      PRINT_SPACE
34418      _OUT << "\"heapBudget\":" << std::endl;
34419      PRINT_SPACE
34420      if (obj.heapBudget) {
34421        _OUT << "[" << std::endl;
34422        for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++) {
34423            bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_HEAPS;
34424            print_VkDeviceSize(obj.heapBudget[i], "", isCommaNeeded);
34425        }
34426        PRINT_SPACE
34427        _OUT << "]" << "," << std::endl;
34428      } else {
34429        _OUT << "\"NULL\"" << "," << std::endl;
34430      }
34431
34432      PRINT_SPACE
34433      _OUT << "\"heapUsage\":" << std::endl;
34434      PRINT_SPACE
34435      if (obj.heapUsage) {
34436        _OUT << "[" << std::endl;
34437        for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++) {
34438            bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_HEAPS;
34439            print_VkDeviceSize(obj.heapUsage[i], "", isCommaNeeded);
34440        }
34441        PRINT_SPACE
34442        _OUT << "]" << "" << std::endl;
34443      } else {
34444        _OUT << "\"NULL\"" << "" << std::endl;
34445      }
34446
34447      INDENT(-4);
34448      PRINT_SPACE
34449      if (commaNeeded)
34450          _OUT << "}," << std::endl;
34451      else
34452          _OUT << "}" << std::endl;
34453 }
34454 static void print_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
34455      PRINT_SPACE
34456      _OUT << "{" << std::endl;
34457      INDENT(4);
34458
34459      print_VkStructureType(obj->sType, "sType", 1);
34460
34461       if (obj->pNext) {
34462          dumpPNextChain(obj->pNext);
34463       } else {
34464          PRINT_SPACE
34465          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34466      }
34467
34468      PRINT_SPACE
34469      _OUT << "\"heapBudget\":" << std::endl;
34470      PRINT_SPACE
34471      if (obj->heapBudget) {
34472        _OUT << "[" << std::endl;
34473        for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++) {
34474            bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_HEAPS;
34475            print_VkDeviceSize(obj->heapBudget[i], "", isCommaNeeded);
34476        }
34477        PRINT_SPACE
34478        _OUT << "]" << "," << std::endl;
34479      } else {
34480        _OUT << "\"NULL\"" << "," << std::endl;
34481      }
34482
34483      PRINT_SPACE
34484      _OUT << "\"heapUsage\":" << std::endl;
34485      PRINT_SPACE
34486      if (obj->heapUsage) {
34487        _OUT << "[" << std::endl;
34488        for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++) {
34489            bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_HEAPS;
34490            print_VkDeviceSize(obj->heapUsage[i], "", isCommaNeeded);
34491        }
34492        PRINT_SPACE
34493        _OUT << "]" << "" << std::endl;
34494      } else {
34495        _OUT << "\"NULL\"" << "" << std::endl;
34496      }
34497
34498      INDENT(-4);
34499      PRINT_SPACE
34500      if (commaNeeded)
34501          _OUT << "}," << std::endl;
34502      else
34503          _OUT << "}" << std::endl;
34504 }
34505
34506 static std::map<deUint64, std::string> VkValidationFeatureEnableEXT_map = {
34507     std::make_pair(0, "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT"),
34508     std::make_pair(1, "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT"),
34509     std::make_pair(2, "VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT"),
34510     std::make_pair(3, "VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT"),
34511     std::make_pair(4, "VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT"),
34512 };
34513 static void print_VkValidationFeatureEnableEXT(VkValidationFeatureEnableEXT obj, const std::string& str, bool commaNeeded=true) {
34514      PRINT_SPACE
34515      if (str != "") _OUT << "\"" << str << "\"" << " : ";
34516      if (commaNeeded)
34517          _OUT << "\"" <<  VkValidationFeatureEnableEXT_map[obj] << "\"," << std::endl;
34518      else
34519          _OUT << "\"" << VkValidationFeatureEnableEXT_map[obj] << "\"" << std::endl;
34520 }
34521 static void print_VkValidationFeatureEnableEXT(const VkValidationFeatureEnableEXT * obj, const std::string& str, bool commaNeeded=true) {
34522      PRINT_SPACE
34523      if (str != "") _OUT << "\"" << str << "\"" << " : ";
34524      if (commaNeeded)
34525          _OUT << "\"" <<  VkValidationFeatureEnableEXT_map[*obj] << "\"," << std::endl;
34526      else
34527          _OUT << "\"" << VkValidationFeatureEnableEXT_map[*obj] << "\"" << std::endl;
34528 }
34529
34530 static std::map<deUint64, std::string> VkValidationFeatureDisableEXT_map = {
34531     std::make_pair(0, "VK_VALIDATION_FEATURE_DISABLE_ALL_EXT"),
34532     std::make_pair(1, "VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT"),
34533     std::make_pair(2, "VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT"),
34534     std::make_pair(3, "VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT"),
34535     std::make_pair(4, "VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT"),
34536     std::make_pair(5, "VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT"),
34537     std::make_pair(6, "VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT"),
34538     std::make_pair(7, "VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT"),
34539 };
34540 static void print_VkValidationFeatureDisableEXT(VkValidationFeatureDisableEXT obj, const std::string& str, bool commaNeeded=true) {
34541      PRINT_SPACE
34542      if (str != "") _OUT << "\"" << str << "\"" << " : ";
34543      if (commaNeeded)
34544          _OUT << "\"" <<  VkValidationFeatureDisableEXT_map[obj] << "\"," << std::endl;
34545      else
34546          _OUT << "\"" << VkValidationFeatureDisableEXT_map[obj] << "\"" << std::endl;
34547 }
34548 static void print_VkValidationFeatureDisableEXT(const VkValidationFeatureDisableEXT * obj, const std::string& str, bool commaNeeded=true) {
34549      PRINT_SPACE
34550      if (str != "") _OUT << "\"" << str << "\"" << " : ";
34551      if (commaNeeded)
34552          _OUT << "\"" <<  VkValidationFeatureDisableEXT_map[*obj] << "\"," << std::endl;
34553      else
34554          _OUT << "\"" << VkValidationFeatureDisableEXT_map[*obj] << "\"" << std::endl;
34555 }
34556
34557 static void print_VkValidationFeaturesEXT(VkValidationFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
34558      PRINT_SPACE
34559      _OUT << "{" << std::endl;
34560      INDENT(4);
34561
34562      print_VkStructureType(obj.sType, "sType", 1);
34563
34564       if (obj.pNext) {
34565          dumpPNextChain(obj.pNext);
34566       } else {
34567          PRINT_SPACE
34568          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34569      }
34570
34571      print_uint32_t(obj.enabledValidationFeatureCount, "enabledValidationFeatureCount", 1);
34572
34573      PRINT_SPACE
34574      _OUT << "\"pEnabledValidationFeatures\":" << std::endl;
34575      PRINT_SPACE
34576      if (obj.pEnabledValidationFeatures) {
34577        _OUT << "[" << std::endl;
34578        for (unsigned int i = 0; i < obj.enabledValidationFeatureCount; i++) {
34579            bool isCommaNeeded = (i+1) != obj.enabledValidationFeatureCount;
34580            print_VkValidationFeatureEnableEXT(obj.pEnabledValidationFeatures[i], "", isCommaNeeded);
34581        }
34582        PRINT_SPACE
34583        _OUT << "]" << "," << std::endl;
34584      } else {
34585        _OUT << "\"NULL\"" << "," << std::endl;
34586      }
34587
34588      print_uint32_t(obj.disabledValidationFeatureCount, "disabledValidationFeatureCount", 1);
34589
34590      PRINT_SPACE
34591      _OUT << "\"pDisabledValidationFeatures\":" << std::endl;
34592      PRINT_SPACE
34593      if (obj.pDisabledValidationFeatures) {
34594        _OUT << "[" << std::endl;
34595        for (unsigned int i = 0; i < obj.disabledValidationFeatureCount; i++) {
34596            bool isCommaNeeded = (i+1) != obj.disabledValidationFeatureCount;
34597            print_VkValidationFeatureDisableEXT(obj.pDisabledValidationFeatures[i], "", isCommaNeeded);
34598        }
34599        PRINT_SPACE
34600        _OUT << "]" << "" << std::endl;
34601      } else {
34602        _OUT << "\"NULL\"" << "" << std::endl;
34603      }
34604
34605      INDENT(-4);
34606      PRINT_SPACE
34607      if (commaNeeded)
34608          _OUT << "}," << std::endl;
34609      else
34610          _OUT << "}" << std::endl;
34611 }
34612 static void print_VkValidationFeaturesEXT(const VkValidationFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
34613      PRINT_SPACE
34614      _OUT << "{" << std::endl;
34615      INDENT(4);
34616
34617      print_VkStructureType(obj->sType, "sType", 1);
34618
34619       if (obj->pNext) {
34620          dumpPNextChain(obj->pNext);
34621       } else {
34622          PRINT_SPACE
34623          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34624      }
34625
34626      print_uint32_t(obj->enabledValidationFeatureCount, "enabledValidationFeatureCount", 1);
34627
34628      PRINT_SPACE
34629      _OUT << "\"pEnabledValidationFeatures\":" << std::endl;
34630      PRINT_SPACE
34631      if (obj->pEnabledValidationFeatures) {
34632        _OUT << "[" << std::endl;
34633        for (unsigned int i = 0; i < obj->enabledValidationFeatureCount; i++) {
34634            bool isCommaNeeded = (i+1) != obj->enabledValidationFeatureCount;
34635            print_VkValidationFeatureEnableEXT(obj->pEnabledValidationFeatures[i], "", isCommaNeeded);
34636        }
34637        PRINT_SPACE
34638        _OUT << "]" << "," << std::endl;
34639      } else {
34640        _OUT << "\"NULL\"" << "," << std::endl;
34641      }
34642
34643      print_uint32_t(obj->disabledValidationFeatureCount, "disabledValidationFeatureCount", 1);
34644
34645      PRINT_SPACE
34646      _OUT << "\"pDisabledValidationFeatures\":" << std::endl;
34647      PRINT_SPACE
34648      if (obj->pDisabledValidationFeatures) {
34649        _OUT << "[" << std::endl;
34650        for (unsigned int i = 0; i < obj->disabledValidationFeatureCount; i++) {
34651            bool isCommaNeeded = (i+1) != obj->disabledValidationFeatureCount;
34652            print_VkValidationFeatureDisableEXT(obj->pDisabledValidationFeatures[i], "", isCommaNeeded);
34653        }
34654        PRINT_SPACE
34655        _OUT << "]" << "" << std::endl;
34656      } else {
34657        _OUT << "\"NULL\"" << "" << std::endl;
34658      }
34659
34660      INDENT(-4);
34661      PRINT_SPACE
34662      if (commaNeeded)
34663          _OUT << "}," << std::endl;
34664      else
34665          _OUT << "}" << std::endl;
34666 }
34667
34668 static void print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
34669      PRINT_SPACE
34670      _OUT << "{" << std::endl;
34671      INDENT(4);
34672
34673      print_VkStructureType(obj.sType, "sType", 1);
34674
34675       if (obj.pNext) {
34676          dumpPNextChain(obj.pNext);
34677       } else {
34678          PRINT_SPACE
34679          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34680      }
34681
34682      print_VkBool32(obj.fragmentShaderSampleInterlock, "fragmentShaderSampleInterlock", 1);
34683
34684      print_VkBool32(obj.fragmentShaderPixelInterlock, "fragmentShaderPixelInterlock", 1);
34685
34686      print_VkBool32(obj.fragmentShaderShadingRateInterlock, "fragmentShaderShadingRateInterlock", 0);
34687
34688      INDENT(-4);
34689      PRINT_SPACE
34690      if (commaNeeded)
34691          _OUT << "}," << std::endl;
34692      else
34693          _OUT << "}" << std::endl;
34694 }
34695 static void print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
34696      PRINT_SPACE
34697      _OUT << "{" << std::endl;
34698      INDENT(4);
34699
34700      print_VkStructureType(obj->sType, "sType", 1);
34701
34702       if (obj->pNext) {
34703          dumpPNextChain(obj->pNext);
34704       } else {
34705          PRINT_SPACE
34706          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34707      }
34708
34709      print_VkBool32(obj->fragmentShaderSampleInterlock, "fragmentShaderSampleInterlock", 1);
34710
34711      print_VkBool32(obj->fragmentShaderPixelInterlock, "fragmentShaderPixelInterlock", 1);
34712
34713      print_VkBool32(obj->fragmentShaderShadingRateInterlock, "fragmentShaderShadingRateInterlock", 0);
34714
34715      INDENT(-4);
34716      PRINT_SPACE
34717      if (commaNeeded)
34718          _OUT << "}," << std::endl;
34719      else
34720          _OUT << "}" << std::endl;
34721 }
34722
34723 static void print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
34724      PRINT_SPACE
34725      _OUT << "{" << std::endl;
34726      INDENT(4);
34727
34728      print_VkStructureType(obj.sType, "sType", 1);
34729
34730       if (obj.pNext) {
34731          dumpPNextChain(obj.pNext);
34732       } else {
34733          PRINT_SPACE
34734          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34735      }
34736
34737      print_VkBool32(obj.ycbcrImageArrays, "ycbcrImageArrays", 0);
34738
34739      INDENT(-4);
34740      PRINT_SPACE
34741      if (commaNeeded)
34742          _OUT << "}," << std::endl;
34743      else
34744          _OUT << "}" << std::endl;
34745 }
34746 static void print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
34747      PRINT_SPACE
34748      _OUT << "{" << std::endl;
34749      INDENT(4);
34750
34751      print_VkStructureType(obj->sType, "sType", 1);
34752
34753       if (obj->pNext) {
34754          dumpPNextChain(obj->pNext);
34755       } else {
34756          PRINT_SPACE
34757          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34758      }
34759
34760      print_VkBool32(obj->ycbcrImageArrays, "ycbcrImageArrays", 0);
34761
34762      INDENT(-4);
34763      PRINT_SPACE
34764      if (commaNeeded)
34765          _OUT << "}," << std::endl;
34766      else
34767          _OUT << "}" << std::endl;
34768 }
34769
34770 static void print_VkHeadlessSurfaceCreateFlagsEXT(VkHeadlessSurfaceCreateFlagsEXT obj, const std::string& str, bool commaNeeded=true) {
34771      PRINT_SPACE
34772      if (commaNeeded)
34773          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
34774      else
34775          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
34776 }
34777 static void print_VkHeadlessSurfaceCreateFlagsEXT(const VkHeadlessSurfaceCreateFlagsEXT * obj, const std::string& str, bool commaNeeded=true) {
34778      PRINT_SPACE
34779      if (commaNeeded)
34780          _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl;
34781      else
34782          _OUT << "\"" << str << "\"" << " : " << obj << std::endl;
34783 }
34784
34785 static void print_VkHeadlessSurfaceCreateInfoEXT(VkHeadlessSurfaceCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
34786      PRINT_SPACE
34787      _OUT << "{" << std::endl;
34788      INDENT(4);
34789
34790      print_VkStructureType(obj.sType, "sType", 1);
34791
34792       if (obj.pNext) {
34793          dumpPNextChain(obj.pNext);
34794       } else {
34795          PRINT_SPACE
34796          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34797      }
34798
34799      print_VkHeadlessSurfaceCreateFlagsEXT(obj.flags, "flags", 0);
34800
34801      INDENT(-4);
34802      PRINT_SPACE
34803      if (commaNeeded)
34804          _OUT << "}," << std::endl;
34805      else
34806          _OUT << "}" << std::endl;
34807 }
34808 static void print_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
34809      PRINT_SPACE
34810      _OUT << "{" << std::endl;
34811      INDENT(4);
34812
34813      print_VkStructureType(obj->sType, "sType", 1);
34814
34815       if (obj->pNext) {
34816          dumpPNextChain(obj->pNext);
34817       } else {
34818          PRINT_SPACE
34819          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34820      }
34821
34822      print_VkHeadlessSurfaceCreateFlagsEXT(obj->flags, "flags", 0);
34823
34824      INDENT(-4);
34825      PRINT_SPACE
34826      if (commaNeeded)
34827          _OUT << "}," << std::endl;
34828      else
34829          _OUT << "}" << std::endl;
34830 }
34831
34832 static std::map<deUint64, std::string> VkLineRasterizationModeEXT_map = {
34833     std::make_pair(0, "VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT"),
34834     std::make_pair(1, "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT"),
34835     std::make_pair(2, "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT"),
34836     std::make_pair(3, "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT"),
34837 };
34838 static void print_VkLineRasterizationModeEXT(VkLineRasterizationModeEXT obj, const std::string& str, bool commaNeeded=true) {
34839      PRINT_SPACE
34840      if (str != "") _OUT << "\"" << str << "\"" << " : ";
34841      if (commaNeeded)
34842          _OUT << "\"" <<  VkLineRasterizationModeEXT_map[obj] << "\"," << std::endl;
34843      else
34844          _OUT << "\"" << VkLineRasterizationModeEXT_map[obj] << "\"" << std::endl;
34845 }
34846 static void print_VkLineRasterizationModeEXT(const VkLineRasterizationModeEXT * obj, const std::string& str, bool commaNeeded=true) {
34847      PRINT_SPACE
34848      if (str != "") _OUT << "\"" << str << "\"" << " : ";
34849      if (commaNeeded)
34850          _OUT << "\"" <<  VkLineRasterizationModeEXT_map[*obj] << "\"," << std::endl;
34851      else
34852          _OUT << "\"" << VkLineRasterizationModeEXT_map[*obj] << "\"" << std::endl;
34853 }
34854
34855 static void print_VkPhysicalDeviceLineRasterizationFeaturesEXT(VkPhysicalDeviceLineRasterizationFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
34856      PRINT_SPACE
34857      _OUT << "{" << std::endl;
34858      INDENT(4);
34859
34860      print_VkStructureType(obj.sType, "sType", 1);
34861
34862       if (obj.pNext) {
34863          dumpPNextChain(obj.pNext);
34864       } else {
34865          PRINT_SPACE
34866          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34867      }
34868
34869      print_VkBool32(obj.rectangularLines, "rectangularLines", 1);
34870
34871      print_VkBool32(obj.bresenhamLines, "bresenhamLines", 1);
34872
34873      print_VkBool32(obj.smoothLines, "smoothLines", 1);
34874
34875      print_VkBool32(obj.stippledRectangularLines, "stippledRectangularLines", 1);
34876
34877      print_VkBool32(obj.stippledBresenhamLines, "stippledBresenhamLines", 1);
34878
34879      print_VkBool32(obj.stippledSmoothLines, "stippledSmoothLines", 0);
34880
34881      INDENT(-4);
34882      PRINT_SPACE
34883      if (commaNeeded)
34884          _OUT << "}," << std::endl;
34885      else
34886          _OUT << "}" << std::endl;
34887 }
34888 static void print_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
34889      PRINT_SPACE
34890      _OUT << "{" << std::endl;
34891      INDENT(4);
34892
34893      print_VkStructureType(obj->sType, "sType", 1);
34894
34895       if (obj->pNext) {
34896          dumpPNextChain(obj->pNext);
34897       } else {
34898          PRINT_SPACE
34899          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34900      }
34901
34902      print_VkBool32(obj->rectangularLines, "rectangularLines", 1);
34903
34904      print_VkBool32(obj->bresenhamLines, "bresenhamLines", 1);
34905
34906      print_VkBool32(obj->smoothLines, "smoothLines", 1);
34907
34908      print_VkBool32(obj->stippledRectangularLines, "stippledRectangularLines", 1);
34909
34910      print_VkBool32(obj->stippledBresenhamLines, "stippledBresenhamLines", 1);
34911
34912      print_VkBool32(obj->stippledSmoothLines, "stippledSmoothLines", 0);
34913
34914      INDENT(-4);
34915      PRINT_SPACE
34916      if (commaNeeded)
34917          _OUT << "}," << std::endl;
34918      else
34919          _OUT << "}" << std::endl;
34920 }
34921
34922 static void print_VkPhysicalDeviceLineRasterizationPropertiesEXT(VkPhysicalDeviceLineRasterizationPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
34923      PRINT_SPACE
34924      _OUT << "{" << std::endl;
34925      INDENT(4);
34926
34927      print_VkStructureType(obj.sType, "sType", 1);
34928
34929       if (obj.pNext) {
34930          dumpPNextChain(obj.pNext);
34931       } else {
34932          PRINT_SPACE
34933          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34934      }
34935
34936      print_uint32_t(obj.lineSubPixelPrecisionBits, "lineSubPixelPrecisionBits", 0);
34937
34938      INDENT(-4);
34939      PRINT_SPACE
34940      if (commaNeeded)
34941          _OUT << "}," << std::endl;
34942      else
34943          _OUT << "}" << std::endl;
34944 }
34945 static void print_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
34946      PRINT_SPACE
34947      _OUT << "{" << std::endl;
34948      INDENT(4);
34949
34950      print_VkStructureType(obj->sType, "sType", 1);
34951
34952       if (obj->pNext) {
34953          dumpPNextChain(obj->pNext);
34954       } else {
34955          PRINT_SPACE
34956          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34957      }
34958
34959      print_uint32_t(obj->lineSubPixelPrecisionBits, "lineSubPixelPrecisionBits", 0);
34960
34961      INDENT(-4);
34962      PRINT_SPACE
34963      if (commaNeeded)
34964          _OUT << "}," << std::endl;
34965      else
34966          _OUT << "}" << std::endl;
34967 }
34968
34969 static void print_VkPipelineRasterizationLineStateCreateInfoEXT(VkPipelineRasterizationLineStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
34970      PRINT_SPACE
34971      _OUT << "{" << std::endl;
34972      INDENT(4);
34973
34974      print_VkStructureType(obj.sType, "sType", 1);
34975
34976       if (obj.pNext) {
34977          dumpPNextChain(obj.pNext);
34978       } else {
34979          PRINT_SPACE
34980          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
34981      }
34982
34983      print_VkLineRasterizationModeEXT(obj.lineRasterizationMode, "lineRasterizationMode", 1);
34984
34985      print_VkBool32(obj.stippledLineEnable, "stippledLineEnable", 1);
34986
34987      print_uint32_t(obj.lineStippleFactor, "lineStippleFactor", 1);
34988
34989      print_uint16_t(obj.lineStipplePattern, "lineStipplePattern", 0);
34990
34991      INDENT(-4);
34992      PRINT_SPACE
34993      if (commaNeeded)
34994          _OUT << "}," << std::endl;
34995      else
34996          _OUT << "}" << std::endl;
34997 }
34998 static void print_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
34999      PRINT_SPACE
35000      _OUT << "{" << std::endl;
35001      INDENT(4);
35002
35003      print_VkStructureType(obj->sType, "sType", 1);
35004
35005       if (obj->pNext) {
35006          dumpPNextChain(obj->pNext);
35007       } else {
35008          PRINT_SPACE
35009          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35010      }
35011
35012      print_VkLineRasterizationModeEXT(obj->lineRasterizationMode, "lineRasterizationMode", 1);
35013
35014      print_VkBool32(obj->stippledLineEnable, "stippledLineEnable", 1);
35015
35016      print_uint32_t(obj->lineStippleFactor, "lineStippleFactor", 1);
35017
35018      print_uint16_t(obj->lineStipplePattern, "lineStipplePattern", 0);
35019
35020      INDENT(-4);
35021      PRINT_SPACE
35022      if (commaNeeded)
35023          _OUT << "}," << std::endl;
35024      else
35025          _OUT << "}" << std::endl;
35026 }
35027
35028 static void print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35029      PRINT_SPACE
35030      _OUT << "{" << std::endl;
35031      INDENT(4);
35032
35033      print_VkStructureType(obj.sType, "sType", 1);
35034
35035       if (obj.pNext) {
35036          dumpPNextChain(obj.pNext);
35037       } else {
35038          PRINT_SPACE
35039          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35040      }
35041
35042      print_VkBool32(obj.shaderBufferFloat32Atomics, "shaderBufferFloat32Atomics", 1);
35043
35044      print_VkBool32(obj.shaderBufferFloat32AtomicAdd, "shaderBufferFloat32AtomicAdd", 1);
35045
35046      print_VkBool32(obj.shaderBufferFloat64Atomics, "shaderBufferFloat64Atomics", 1);
35047
35048      print_VkBool32(obj.shaderBufferFloat64AtomicAdd, "shaderBufferFloat64AtomicAdd", 1);
35049
35050      print_VkBool32(obj.shaderSharedFloat32Atomics, "shaderSharedFloat32Atomics", 1);
35051
35052      print_VkBool32(obj.shaderSharedFloat32AtomicAdd, "shaderSharedFloat32AtomicAdd", 1);
35053
35054      print_VkBool32(obj.shaderSharedFloat64Atomics, "shaderSharedFloat64Atomics", 1);
35055
35056      print_VkBool32(obj.shaderSharedFloat64AtomicAdd, "shaderSharedFloat64AtomicAdd", 1);
35057
35058      print_VkBool32(obj.shaderImageFloat32Atomics, "shaderImageFloat32Atomics", 1);
35059
35060      print_VkBool32(obj.shaderImageFloat32AtomicAdd, "shaderImageFloat32AtomicAdd", 1);
35061
35062      print_VkBool32(obj.sparseImageFloat32Atomics, "sparseImageFloat32Atomics", 1);
35063
35064      print_VkBool32(obj.sparseImageFloat32AtomicAdd, "sparseImageFloat32AtomicAdd", 0);
35065
35066      INDENT(-4);
35067      PRINT_SPACE
35068      if (commaNeeded)
35069          _OUT << "}," << std::endl;
35070      else
35071          _OUT << "}" << std::endl;
35072 }
35073 static void print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
35074      PRINT_SPACE
35075      _OUT << "{" << std::endl;
35076      INDENT(4);
35077
35078      print_VkStructureType(obj->sType, "sType", 1);
35079
35080       if (obj->pNext) {
35081          dumpPNextChain(obj->pNext);
35082       } else {
35083          PRINT_SPACE
35084          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35085      }
35086
35087      print_VkBool32(obj->shaderBufferFloat32Atomics, "shaderBufferFloat32Atomics", 1);
35088
35089      print_VkBool32(obj->shaderBufferFloat32AtomicAdd, "shaderBufferFloat32AtomicAdd", 1);
35090
35091      print_VkBool32(obj->shaderBufferFloat64Atomics, "shaderBufferFloat64Atomics", 1);
35092
35093      print_VkBool32(obj->shaderBufferFloat64AtomicAdd, "shaderBufferFloat64AtomicAdd", 1);
35094
35095      print_VkBool32(obj->shaderSharedFloat32Atomics, "shaderSharedFloat32Atomics", 1);
35096
35097      print_VkBool32(obj->shaderSharedFloat32AtomicAdd, "shaderSharedFloat32AtomicAdd", 1);
35098
35099      print_VkBool32(obj->shaderSharedFloat64Atomics, "shaderSharedFloat64Atomics", 1);
35100
35101      print_VkBool32(obj->shaderSharedFloat64AtomicAdd, "shaderSharedFloat64AtomicAdd", 1);
35102
35103      print_VkBool32(obj->shaderImageFloat32Atomics, "shaderImageFloat32Atomics", 1);
35104
35105      print_VkBool32(obj->shaderImageFloat32AtomicAdd, "shaderImageFloat32AtomicAdd", 1);
35106
35107      print_VkBool32(obj->sparseImageFloat32Atomics, "sparseImageFloat32Atomics", 1);
35108
35109      print_VkBool32(obj->sparseImageFloat32AtomicAdd, "sparseImageFloat32AtomicAdd", 0);
35110
35111      INDENT(-4);
35112      PRINT_SPACE
35113      if (commaNeeded)
35114          _OUT << "}," << std::endl;
35115      else
35116          _OUT << "}" << std::endl;
35117 }
35118
35119 static void print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(VkPhysicalDeviceIndexTypeUint8FeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35120      PRINT_SPACE
35121      _OUT << "{" << std::endl;
35122      INDENT(4);
35123
35124      print_VkStructureType(obj.sType, "sType", 1);
35125
35126       if (obj.pNext) {
35127          dumpPNextChain(obj.pNext);
35128       } else {
35129          PRINT_SPACE
35130          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35131      }
35132
35133      print_VkBool32(obj.indexTypeUint8, "indexTypeUint8", 0);
35134
35135      INDENT(-4);
35136      PRINT_SPACE
35137      if (commaNeeded)
35138          _OUT << "}," << std::endl;
35139      else
35140          _OUT << "}" << std::endl;
35141 }
35142 static void print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
35143      PRINT_SPACE
35144      _OUT << "{" << std::endl;
35145      INDENT(4);
35146
35147      print_VkStructureType(obj->sType, "sType", 1);
35148
35149       if (obj->pNext) {
35150          dumpPNextChain(obj->pNext);
35151       } else {
35152          PRINT_SPACE
35153          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35154      }
35155
35156      print_VkBool32(obj->indexTypeUint8, "indexTypeUint8", 0);
35157
35158      INDENT(-4);
35159      PRINT_SPACE
35160      if (commaNeeded)
35161          _OUT << "}," << std::endl;
35162      else
35163          _OUT << "}" << std::endl;
35164 }
35165
35166 static void print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35167      PRINT_SPACE
35168      _OUT << "{" << std::endl;
35169      INDENT(4);
35170
35171      print_VkStructureType(obj.sType, "sType", 1);
35172
35173       if (obj.pNext) {
35174          dumpPNextChain(obj.pNext);
35175       } else {
35176          PRINT_SPACE
35177          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35178      }
35179
35180      print_VkBool32(obj.extendedDynamicState, "extendedDynamicState", 0);
35181
35182      INDENT(-4);
35183      PRINT_SPACE
35184      if (commaNeeded)
35185          _OUT << "}," << std::endl;
35186      else
35187          _OUT << "}" << std::endl;
35188 }
35189 static void print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
35190      PRINT_SPACE
35191      _OUT << "{" << std::endl;
35192      INDENT(4);
35193
35194      print_VkStructureType(obj->sType, "sType", 1);
35195
35196       if (obj->pNext) {
35197          dumpPNextChain(obj->pNext);
35198       } else {
35199          PRINT_SPACE
35200          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35201      }
35202
35203      print_VkBool32(obj->extendedDynamicState, "extendedDynamicState", 0);
35204
35205      INDENT(-4);
35206      PRINT_SPACE
35207      if (commaNeeded)
35208          _OUT << "}," << std::endl;
35209      else
35210          _OUT << "}" << std::endl;
35211 }
35212
35213 static void print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35214      PRINT_SPACE
35215      _OUT << "{" << std::endl;
35216      INDENT(4);
35217
35218      print_VkStructureType(obj.sType, "sType", 1);
35219
35220       if (obj.pNext) {
35221          dumpPNextChain(obj.pNext);
35222       } else {
35223          PRINT_SPACE
35224          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35225      }
35226
35227      print_VkBool32(obj.shaderDemoteToHelperInvocation, "shaderDemoteToHelperInvocation", 0);
35228
35229      INDENT(-4);
35230      PRINT_SPACE
35231      if (commaNeeded)
35232          _OUT << "}," << std::endl;
35233      else
35234          _OUT << "}" << std::endl;
35235 }
35236 static void print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
35237      PRINT_SPACE
35238      _OUT << "{" << std::endl;
35239      INDENT(4);
35240
35241      print_VkStructureType(obj->sType, "sType", 1);
35242
35243       if (obj->pNext) {
35244          dumpPNextChain(obj->pNext);
35245       } else {
35246          PRINT_SPACE
35247          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35248      }
35249
35250      print_VkBool32(obj->shaderDemoteToHelperInvocation, "shaderDemoteToHelperInvocation", 0);
35251
35252      INDENT(-4);
35253      PRINT_SPACE
35254      if (commaNeeded)
35255          _OUT << "}," << std::endl;
35256      else
35257          _OUT << "}" << std::endl;
35258 }
35259
35260 static void print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35261      PRINT_SPACE
35262      _OUT << "{" << std::endl;
35263      INDENT(4);
35264
35265      print_VkStructureType(obj.sType, "sType", 1);
35266
35267       if (obj.pNext) {
35268          dumpPNextChain(obj.pNext);
35269       } else {
35270          PRINT_SPACE
35271          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35272      }
35273
35274      print_VkBool32(obj.texelBufferAlignment, "texelBufferAlignment", 0);
35275
35276      INDENT(-4);
35277      PRINT_SPACE
35278      if (commaNeeded)
35279          _OUT << "}," << std::endl;
35280      else
35281          _OUT << "}" << std::endl;
35282 }
35283 static void print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
35284      PRINT_SPACE
35285      _OUT << "{" << std::endl;
35286      INDENT(4);
35287
35288      print_VkStructureType(obj->sType, "sType", 1);
35289
35290       if (obj->pNext) {
35291          dumpPNextChain(obj->pNext);
35292       } else {
35293          PRINT_SPACE
35294          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35295      }
35296
35297      print_VkBool32(obj->texelBufferAlignment, "texelBufferAlignment", 0);
35298
35299      INDENT(-4);
35300      PRINT_SPACE
35301      if (commaNeeded)
35302          _OUT << "}," << std::endl;
35303      else
35304          _OUT << "}" << std::endl;
35305 }
35306
35307 static void print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
35308      PRINT_SPACE
35309      _OUT << "{" << std::endl;
35310      INDENT(4);
35311
35312      print_VkStructureType(obj.sType, "sType", 1);
35313
35314       if (obj.pNext) {
35315          dumpPNextChain(obj.pNext);
35316       } else {
35317          PRINT_SPACE
35318          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35319      }
35320
35321      print_VkDeviceSize(obj.storageTexelBufferOffsetAlignmentBytes, "storageTexelBufferOffsetAlignmentBytes", 1);
35322
35323      print_VkBool32(obj.storageTexelBufferOffsetSingleTexelAlignment, "storageTexelBufferOffsetSingleTexelAlignment", 1);
35324
35325      print_VkDeviceSize(obj.uniformTexelBufferOffsetAlignmentBytes, "uniformTexelBufferOffsetAlignmentBytes", 1);
35326
35327      print_VkBool32(obj.uniformTexelBufferOffsetSingleTexelAlignment, "uniformTexelBufferOffsetSingleTexelAlignment", 0);
35328
35329      INDENT(-4);
35330      PRINT_SPACE
35331      if (commaNeeded)
35332          _OUT << "}," << std::endl;
35333      else
35334          _OUT << "}" << std::endl;
35335 }
35336 static void print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
35337      PRINT_SPACE
35338      _OUT << "{" << std::endl;
35339      INDENT(4);
35340
35341      print_VkStructureType(obj->sType, "sType", 1);
35342
35343       if (obj->pNext) {
35344          dumpPNextChain(obj->pNext);
35345       } else {
35346          PRINT_SPACE
35347          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35348      }
35349
35350      print_VkDeviceSize(obj->storageTexelBufferOffsetAlignmentBytes, "storageTexelBufferOffsetAlignmentBytes", 1);
35351
35352      print_VkBool32(obj->storageTexelBufferOffsetSingleTexelAlignment, "storageTexelBufferOffsetSingleTexelAlignment", 1);
35353
35354      print_VkDeviceSize(obj->uniformTexelBufferOffsetAlignmentBytes, "uniformTexelBufferOffsetAlignmentBytes", 1);
35355
35356      print_VkBool32(obj->uniformTexelBufferOffsetSingleTexelAlignment, "uniformTexelBufferOffsetSingleTexelAlignment", 0);
35357
35358      INDENT(-4);
35359      PRINT_SPACE
35360      if (commaNeeded)
35361          _OUT << "}," << std::endl;
35362      else
35363          _OUT << "}" << std::endl;
35364 }
35365
35366 static void print_VkPhysicalDeviceRobustness2FeaturesEXT(VkPhysicalDeviceRobustness2FeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35367      PRINT_SPACE
35368      _OUT << "{" << std::endl;
35369      INDENT(4);
35370
35371      print_VkStructureType(obj.sType, "sType", 1);
35372
35373       if (obj.pNext) {
35374          dumpPNextChain(obj.pNext);
35375       } else {
35376          PRINT_SPACE
35377          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35378      }
35379
35380      print_VkBool32(obj.robustBufferAccess2, "robustBufferAccess2", 1);
35381
35382      print_VkBool32(obj.robustImageAccess2, "robustImageAccess2", 1);
35383
35384      print_VkBool32(obj.nullDescriptor, "nullDescriptor", 0);
35385
35386      INDENT(-4);
35387      PRINT_SPACE
35388      if (commaNeeded)
35389          _OUT << "}," << std::endl;
35390      else
35391          _OUT << "}" << std::endl;
35392 }
35393 static void print_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
35394      PRINT_SPACE
35395      _OUT << "{" << std::endl;
35396      INDENT(4);
35397
35398      print_VkStructureType(obj->sType, "sType", 1);
35399
35400       if (obj->pNext) {
35401          dumpPNextChain(obj->pNext);
35402       } else {
35403          PRINT_SPACE
35404          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35405      }
35406
35407      print_VkBool32(obj->robustBufferAccess2, "robustBufferAccess2", 1);
35408
35409      print_VkBool32(obj->robustImageAccess2, "robustImageAccess2", 1);
35410
35411      print_VkBool32(obj->nullDescriptor, "nullDescriptor", 0);
35412
35413      INDENT(-4);
35414      PRINT_SPACE
35415      if (commaNeeded)
35416          _OUT << "}," << std::endl;
35417      else
35418          _OUT << "}" << std::endl;
35419 }
35420
35421 static void print_VkPhysicalDeviceRobustness2PropertiesEXT(VkPhysicalDeviceRobustness2PropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
35422      PRINT_SPACE
35423      _OUT << "{" << std::endl;
35424      INDENT(4);
35425
35426      print_VkStructureType(obj.sType, "sType", 1);
35427
35428       if (obj.pNext) {
35429          dumpPNextChain(obj.pNext);
35430       } else {
35431          PRINT_SPACE
35432          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35433      }
35434
35435      print_VkDeviceSize(obj.robustStorageBufferAccessSizeAlignment, "robustStorageBufferAccessSizeAlignment", 1);
35436
35437      print_VkDeviceSize(obj.robustUniformBufferAccessSizeAlignment, "robustUniformBufferAccessSizeAlignment", 0);
35438
35439      INDENT(-4);
35440      PRINT_SPACE
35441      if (commaNeeded)
35442          _OUT << "}," << std::endl;
35443      else
35444          _OUT << "}" << std::endl;
35445 }
35446 static void print_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
35447      PRINT_SPACE
35448      _OUT << "{" << std::endl;
35449      INDENT(4);
35450
35451      print_VkStructureType(obj->sType, "sType", 1);
35452
35453       if (obj->pNext) {
35454          dumpPNextChain(obj->pNext);
35455       } else {
35456          PRINT_SPACE
35457          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35458      }
35459
35460      print_VkDeviceSize(obj->robustStorageBufferAccessSizeAlignment, "robustStorageBufferAccessSizeAlignment", 1);
35461
35462      print_VkDeviceSize(obj->robustUniformBufferAccessSizeAlignment, "robustUniformBufferAccessSizeAlignment", 0);
35463
35464      INDENT(-4);
35465      PRINT_SPACE
35466      if (commaNeeded)
35467          _OUT << "}," << std::endl;
35468      else
35469          _OUT << "}" << std::endl;
35470 }
35471
35472 static void print_VkSamplerCustomBorderColorCreateInfoEXT(VkSamplerCustomBorderColorCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
35473      PRINT_SPACE
35474      _OUT << "{" << std::endl;
35475      INDENT(4);
35476
35477      print_VkStructureType(obj.sType, "sType", 1);
35478
35479       if (obj.pNext) {
35480          dumpPNextChain(obj.pNext);
35481       } else {
35482          PRINT_SPACE
35483          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35484      }
35485
35486      print_VkClearColorValue(obj.customBorderColor, "customBorderColor", 1);
35487
35488      print_VkFormat(obj.format, "format", 0);
35489
35490      INDENT(-4);
35491      PRINT_SPACE
35492      if (commaNeeded)
35493          _OUT << "}," << std::endl;
35494      else
35495          _OUT << "}" << std::endl;
35496 }
35497 static void print_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
35498      PRINT_SPACE
35499      _OUT << "{" << std::endl;
35500      INDENT(4);
35501
35502      print_VkStructureType(obj->sType, "sType", 1);
35503
35504       if (obj->pNext) {
35505          dumpPNextChain(obj->pNext);
35506       } else {
35507          PRINT_SPACE
35508          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35509      }
35510
35511      print_VkClearColorValue(obj->customBorderColor, "customBorderColor", 1);
35512
35513      print_VkFormat(obj->format, "format", 0);
35514
35515      INDENT(-4);
35516      PRINT_SPACE
35517      if (commaNeeded)
35518          _OUT << "}," << std::endl;
35519      else
35520          _OUT << "}" << std::endl;
35521 }
35522
35523 static void print_VkPhysicalDeviceCustomBorderColorPropertiesEXT(VkPhysicalDeviceCustomBorderColorPropertiesEXT obj, const std::string& s, bool commaNeeded=true) {
35524      PRINT_SPACE
35525      _OUT << "{" << std::endl;
35526      INDENT(4);
35527
35528      print_VkStructureType(obj.sType, "sType", 1);
35529
35530       if (obj.pNext) {
35531          dumpPNextChain(obj.pNext);
35532       } else {
35533          PRINT_SPACE
35534          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35535      }
35536
35537      print_uint32_t(obj.maxCustomBorderColorSamplers, "maxCustomBorderColorSamplers", 0);
35538
35539      INDENT(-4);
35540      PRINT_SPACE
35541      if (commaNeeded)
35542          _OUT << "}," << std::endl;
35543      else
35544          _OUT << "}" << std::endl;
35545 }
35546 static void print_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) {
35547      PRINT_SPACE
35548      _OUT << "{" << std::endl;
35549      INDENT(4);
35550
35551      print_VkStructureType(obj->sType, "sType", 1);
35552
35553       if (obj->pNext) {
35554          dumpPNextChain(obj->pNext);
35555       } else {
35556          PRINT_SPACE
35557          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35558      }
35559
35560      print_uint32_t(obj->maxCustomBorderColorSamplers, "maxCustomBorderColorSamplers", 0);
35561
35562      INDENT(-4);
35563      PRINT_SPACE
35564      if (commaNeeded)
35565          _OUT << "}," << std::endl;
35566      else
35567          _OUT << "}" << std::endl;
35568 }
35569
35570 static void print_VkPhysicalDeviceCustomBorderColorFeaturesEXT(VkPhysicalDeviceCustomBorderColorFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35571      PRINT_SPACE
35572      _OUT << "{" << std::endl;
35573      INDENT(4);
35574
35575      print_VkStructureType(obj.sType, "sType", 1);
35576
35577       if (obj.pNext) {
35578          dumpPNextChain(obj.pNext);
35579       } else {
35580          PRINT_SPACE
35581          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35582      }
35583
35584      print_VkBool32(obj.customBorderColors, "customBorderColors", 1);
35585
35586      print_VkBool32(obj.customBorderColorWithoutFormat, "customBorderColorWithoutFormat", 0);
35587
35588      INDENT(-4);
35589      PRINT_SPACE
35590      if (commaNeeded)
35591          _OUT << "}," << std::endl;
35592      else
35593          _OUT << "}" << std::endl;
35594 }
35595 static void print_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
35596      PRINT_SPACE
35597      _OUT << "{" << std::endl;
35598      INDENT(4);
35599
35600      print_VkStructureType(obj->sType, "sType", 1);
35601
35602       if (obj->pNext) {
35603          dumpPNextChain(obj->pNext);
35604       } else {
35605          PRINT_SPACE
35606          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35607      }
35608
35609      print_VkBool32(obj->customBorderColors, "customBorderColors", 1);
35610
35611      print_VkBool32(obj->customBorderColorWithoutFormat, "customBorderColorWithoutFormat", 0);
35612
35613      INDENT(-4);
35614      PRINT_SPACE
35615      if (commaNeeded)
35616          _OUT << "}," << std::endl;
35617      else
35618          _OUT << "}" << std::endl;
35619 }
35620
35621 static void print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35622      PRINT_SPACE
35623      _OUT << "{" << std::endl;
35624      INDENT(4);
35625
35626      print_VkStructureType(obj.sType, "sType", 1);
35627
35628       if (obj.pNext) {
35629          dumpPNextChain(obj.pNext);
35630       } else {
35631          PRINT_SPACE
35632          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35633      }
35634
35635      print_VkBool32(obj.ycbcr2plane444Formats, "ycbcr2plane444Formats", 0);
35636
35637      INDENT(-4);
35638      PRINT_SPACE
35639      if (commaNeeded)
35640          _OUT << "}," << std::endl;
35641      else
35642          _OUT << "}" << std::endl;
35643 }
35644 static void print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
35645      PRINT_SPACE
35646      _OUT << "{" << std::endl;
35647      INDENT(4);
35648
35649      print_VkStructureType(obj->sType, "sType", 1);
35650
35651       if (obj->pNext) {
35652          dumpPNextChain(obj->pNext);
35653       } else {
35654          PRINT_SPACE
35655          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35656      }
35657
35658      print_VkBool32(obj->ycbcr2plane444Formats, "ycbcr2plane444Formats", 0);
35659
35660      INDENT(-4);
35661      PRINT_SPACE
35662      if (commaNeeded)
35663          _OUT << "}," << std::endl;
35664      else
35665          _OUT << "}" << std::endl;
35666 }
35667
35668 static void print_VkPhysicalDeviceImageRobustnessFeaturesEXT(VkPhysicalDeviceImageRobustnessFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35669      PRINT_SPACE
35670      _OUT << "{" << std::endl;
35671      INDENT(4);
35672
35673      print_VkStructureType(obj.sType, "sType", 1);
35674
35675       if (obj.pNext) {
35676          dumpPNextChain(obj.pNext);
35677       } else {
35678          PRINT_SPACE
35679          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35680      }
35681
35682      print_VkBool32(obj.robustImageAccess, "robustImageAccess", 0);
35683
35684      INDENT(-4);
35685      PRINT_SPACE
35686      if (commaNeeded)
35687          _OUT << "}," << std::endl;
35688      else
35689          _OUT << "}" << std::endl;
35690 }
35691 static void print_VkPhysicalDeviceImageRobustnessFeaturesEXT(const VkPhysicalDeviceImageRobustnessFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
35692      PRINT_SPACE
35693      _OUT << "{" << std::endl;
35694      INDENT(4);
35695
35696      print_VkStructureType(obj->sType, "sType", 1);
35697
35698       if (obj->pNext) {
35699          dumpPNextChain(obj->pNext);
35700       } else {
35701          PRINT_SPACE
35702          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35703      }
35704
35705      print_VkBool32(obj->robustImageAccess, "robustImageAccess", 0);
35706
35707      INDENT(-4);
35708      PRINT_SPACE
35709      if (commaNeeded)
35710          _OUT << "}," << std::endl;
35711      else
35712          _OUT << "}" << std::endl;
35713 }
35714
35715 static void print_VkPhysicalDevice4444FormatsFeaturesEXT(VkPhysicalDevice4444FormatsFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35716      PRINT_SPACE
35717      _OUT << "{" << std::endl;
35718      INDENT(4);
35719
35720      print_VkStructureType(obj.sType, "sType", 1);
35721
35722       if (obj.pNext) {
35723          dumpPNextChain(obj.pNext);
35724       } else {
35725          PRINT_SPACE
35726          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35727      }
35728
35729      print_VkBool32(obj.formatA4R4G4B4, "formatA4R4G4B4", 1);
35730
35731      print_VkBool32(obj.formatA4B4G4R4, "formatA4B4G4R4", 0);
35732
35733      INDENT(-4);
35734      PRINT_SPACE
35735      if (commaNeeded)
35736          _OUT << "}," << std::endl;
35737      else
35738          _OUT << "}" << std::endl;
35739 }
35740 static void print_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
35741      PRINT_SPACE
35742      _OUT << "{" << std::endl;
35743      INDENT(4);
35744
35745      print_VkStructureType(obj->sType, "sType", 1);
35746
35747       if (obj->pNext) {
35748          dumpPNextChain(obj->pNext);
35749       } else {
35750          PRINT_SPACE
35751          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35752      }
35753
35754      print_VkBool32(obj->formatA4R4G4B4, "formatA4R4G4B4", 1);
35755
35756      print_VkBool32(obj->formatA4B4G4R4, "formatA4B4G4R4", 0);
35757
35758      INDENT(-4);
35759      PRINT_SPACE
35760      if (commaNeeded)
35761          _OUT << "}," << std::endl;
35762      else
35763          _OUT << "}" << std::endl;
35764 }
35765
35766 static void print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35767      PRINT_SPACE
35768      _OUT << "{" << std::endl;
35769      INDENT(4);
35770
35771      print_VkStructureType(obj.sType, "sType", 1);
35772
35773       if (obj.pNext) {
35774          dumpPNextChain(obj.pNext);
35775       } else {
35776          PRINT_SPACE
35777          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35778      }
35779
35780      print_VkBool32(obj.vertexInputDynamicState, "vertexInputDynamicState", 0);
35781
35782      INDENT(-4);
35783      PRINT_SPACE
35784      if (commaNeeded)
35785          _OUT << "}," << std::endl;
35786      else
35787          _OUT << "}" << std::endl;
35788 }
35789 static void print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
35790      PRINT_SPACE
35791      _OUT << "{" << std::endl;
35792      INDENT(4);
35793
35794      print_VkStructureType(obj->sType, "sType", 1);
35795
35796       if (obj->pNext) {
35797          dumpPNextChain(obj->pNext);
35798       } else {
35799          PRINT_SPACE
35800          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35801      }
35802
35803      print_VkBool32(obj->vertexInputDynamicState, "vertexInputDynamicState", 0);
35804
35805      INDENT(-4);
35806      PRINT_SPACE
35807      if (commaNeeded)
35808          _OUT << "}," << std::endl;
35809      else
35810          _OUT << "}" << std::endl;
35811 }
35812
35813 static void print_VkVertexInputBindingDescription2EXT(VkVertexInputBindingDescription2EXT obj, const std::string& s, bool commaNeeded=true) {
35814      PRINT_SPACE
35815      _OUT << "{" << std::endl;
35816      INDENT(4);
35817
35818      print_VkStructureType(obj.sType, "sType", 1);
35819
35820       if (obj.pNext) {
35821          dumpPNextChain(obj.pNext);
35822       } else {
35823          PRINT_SPACE
35824          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35825      }
35826
35827      print_uint32_t(obj.binding, "binding", 1);
35828
35829      print_uint32_t(obj.stride, "stride", 1);
35830
35831      print_VkVertexInputRate(obj.inputRate, "inputRate", 1);
35832
35833      print_uint32_t(obj.divisor, "divisor", 0);
35834
35835      INDENT(-4);
35836      PRINT_SPACE
35837      if (commaNeeded)
35838          _OUT << "}," << std::endl;
35839      else
35840          _OUT << "}" << std::endl;
35841 }
35842 static void print_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT * obj, const std::string& s, bool commaNeeded=true) {
35843      PRINT_SPACE
35844      _OUT << "{" << std::endl;
35845      INDENT(4);
35846
35847      print_VkStructureType(obj->sType, "sType", 1);
35848
35849       if (obj->pNext) {
35850          dumpPNextChain(obj->pNext);
35851       } else {
35852          PRINT_SPACE
35853          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35854      }
35855
35856      print_uint32_t(obj->binding, "binding", 1);
35857
35858      print_uint32_t(obj->stride, "stride", 1);
35859
35860      print_VkVertexInputRate(obj->inputRate, "inputRate", 1);
35861
35862      print_uint32_t(obj->divisor, "divisor", 0);
35863
35864      INDENT(-4);
35865      PRINT_SPACE
35866      if (commaNeeded)
35867          _OUT << "}," << std::endl;
35868      else
35869          _OUT << "}" << std::endl;
35870 }
35871
35872 static void print_VkVertexInputAttributeDescription2EXT(VkVertexInputAttributeDescription2EXT obj, const std::string& s, bool commaNeeded=true) {
35873      PRINT_SPACE
35874      _OUT << "{" << std::endl;
35875      INDENT(4);
35876
35877      print_VkStructureType(obj.sType, "sType", 1);
35878
35879       if (obj.pNext) {
35880          dumpPNextChain(obj.pNext);
35881       } else {
35882          PRINT_SPACE
35883          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35884      }
35885
35886      print_uint32_t(obj.location, "location", 1);
35887
35888      print_uint32_t(obj.binding, "binding", 1);
35889
35890      print_VkFormat(obj.format, "format", 1);
35891
35892      print_uint32_t(obj.offset, "offset", 0);
35893
35894      INDENT(-4);
35895      PRINT_SPACE
35896      if (commaNeeded)
35897          _OUT << "}," << std::endl;
35898      else
35899          _OUT << "}" << std::endl;
35900 }
35901 static void print_VkVertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT * obj, const std::string& s, bool commaNeeded=true) {
35902      PRINT_SPACE
35903      _OUT << "{" << std::endl;
35904      INDENT(4);
35905
35906      print_VkStructureType(obj->sType, "sType", 1);
35907
35908       if (obj->pNext) {
35909          dumpPNextChain(obj->pNext);
35910       } else {
35911          PRINT_SPACE
35912          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35913      }
35914
35915      print_uint32_t(obj->location, "location", 1);
35916
35917      print_uint32_t(obj->binding, "binding", 1);
35918
35919      print_VkFormat(obj->format, "format", 1);
35920
35921      print_uint32_t(obj->offset, "offset", 0);
35922
35923      INDENT(-4);
35924      PRINT_SPACE
35925      if (commaNeeded)
35926          _OUT << "}," << std::endl;
35927      else
35928          _OUT << "}" << std::endl;
35929 }
35930
35931 static void print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35932      PRINT_SPACE
35933      _OUT << "{" << std::endl;
35934      INDENT(4);
35935
35936      print_VkStructureType(obj.sType, "sType", 1);
35937
35938       if (obj.pNext) {
35939          dumpPNextChain(obj.pNext);
35940       } else {
35941          PRINT_SPACE
35942          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35943      }
35944
35945      print_VkBool32(obj.extendedDynamicState2, "extendedDynamicState2", 1);
35946
35947      print_VkBool32(obj.extendedDynamicState2LogicOp, "extendedDynamicState2LogicOp", 1);
35948
35949      print_VkBool32(obj.extendedDynamicState2PatchControlPoints, "extendedDynamicState2PatchControlPoints", 0);
35950
35951      INDENT(-4);
35952      PRINT_SPACE
35953      if (commaNeeded)
35954          _OUT << "}," << std::endl;
35955      else
35956          _OUT << "}" << std::endl;
35957 }
35958 static void print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
35959      PRINT_SPACE
35960      _OUT << "{" << std::endl;
35961      INDENT(4);
35962
35963      print_VkStructureType(obj->sType, "sType", 1);
35964
35965       if (obj->pNext) {
35966          dumpPNextChain(obj->pNext);
35967       } else {
35968          PRINT_SPACE
35969          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35970      }
35971
35972      print_VkBool32(obj->extendedDynamicState2, "extendedDynamicState2", 1);
35973
35974      print_VkBool32(obj->extendedDynamicState2LogicOp, "extendedDynamicState2LogicOp", 1);
35975
35976      print_VkBool32(obj->extendedDynamicState2PatchControlPoints, "extendedDynamicState2PatchControlPoints", 0);
35977
35978      INDENT(-4);
35979      PRINT_SPACE
35980      if (commaNeeded)
35981          _OUT << "}," << std::endl;
35982      else
35983          _OUT << "}" << std::endl;
35984 }
35985
35986 static void print_VkPhysicalDeviceColorWriteEnableFeaturesEXT(VkPhysicalDeviceColorWriteEnableFeaturesEXT obj, const std::string& s, bool commaNeeded=true) {
35987      PRINT_SPACE
35988      _OUT << "{" << std::endl;
35989      INDENT(4);
35990
35991      print_VkStructureType(obj.sType, "sType", 1);
35992
35993       if (obj.pNext) {
35994          dumpPNextChain(obj.pNext);
35995       } else {
35996          PRINT_SPACE
35997          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
35998      }
35999
36000      print_VkBool32(obj.colorWriteEnable, "colorWriteEnable", 0);
36001
36002      INDENT(-4);
36003      PRINT_SPACE
36004      if (commaNeeded)
36005          _OUT << "}," << std::endl;
36006      else
36007          _OUT << "}" << std::endl;
36008 }
36009 static void print_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) {
36010      PRINT_SPACE
36011      _OUT << "{" << std::endl;
36012      INDENT(4);
36013
36014      print_VkStructureType(obj->sType, "sType", 1);
36015
36016       if (obj->pNext) {
36017          dumpPNextChain(obj->pNext);
36018       } else {
36019          PRINT_SPACE
36020          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
36021      }
36022
36023      print_VkBool32(obj->colorWriteEnable, "colorWriteEnable", 0);
36024
36025      INDENT(-4);
36026      PRINT_SPACE
36027      if (commaNeeded)
36028          _OUT << "}," << std::endl;
36029      else
36030          _OUT << "}" << std::endl;
36031 }
36032
36033 static void print_VkPipelineColorWriteCreateInfoEXT(VkPipelineColorWriteCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) {
36034      PRINT_SPACE
36035      _OUT << "{" << std::endl;
36036      INDENT(4);
36037
36038      print_VkStructureType(obj.sType, "sType", 1);
36039
36040       if (obj.pNext) {
36041          dumpPNextChain(obj.pNext);
36042       } else {
36043          PRINT_SPACE
36044          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
36045      }
36046
36047      print_uint32_t(obj.attachmentCount, "attachmentCount", 1);
36048
36049      PRINT_SPACE
36050      _OUT << "\"pColorWriteEnables\":" << std::endl;
36051      PRINT_SPACE
36052      if (obj.pColorWriteEnables) {
36053        _OUT << "[" << std::endl;
36054        for (unsigned int i = 0; i < obj.attachmentCount; i++) {
36055            bool isCommaNeeded = (i+1) != obj.attachmentCount;
36056            print_VkBool32(obj.pColorWriteEnables[i], "", isCommaNeeded);
36057        }
36058        PRINT_SPACE
36059        _OUT << "]" << "" << std::endl;
36060      } else {
36061        _OUT << "\"NULL\"" << "" << std::endl;
36062      }
36063
36064      INDENT(-4);
36065      PRINT_SPACE
36066      if (commaNeeded)
36067          _OUT << "}," << std::endl;
36068      else
36069          _OUT << "}" << std::endl;
36070 }
36071 static void print_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) {
36072      PRINT_SPACE
36073      _OUT << "{" << std::endl;
36074      INDENT(4);
36075
36076      print_VkStructureType(obj->sType, "sType", 1);
36077
36078       if (obj->pNext) {
36079          dumpPNextChain(obj->pNext);
36080       } else {
36081          PRINT_SPACE
36082          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
36083      }
36084
36085      print_uint32_t(obj->attachmentCount, "attachmentCount", 1);
36086
36087      PRINT_SPACE
36088      _OUT << "\"pColorWriteEnables\":" << std::endl;
36089      PRINT_SPACE
36090      if (obj->pColorWriteEnables) {
36091        _OUT << "[" << std::endl;
36092        for (unsigned int i = 0; i < obj->attachmentCount; i++) {
36093            bool isCommaNeeded = (i+1) != obj->attachmentCount;
36094            print_VkBool32(obj->pColorWriteEnables[i], "", isCommaNeeded);
36095        }
36096        PRINT_SPACE
36097        _OUT << "]" << "" << std::endl;
36098      } else {
36099        _OUT << "\"NULL\"" << "" << std::endl;
36100      }
36101
36102      INDENT(-4);
36103      PRINT_SPACE
36104      if (commaNeeded)
36105          _OUT << "}," << std::endl;
36106      else
36107          _OUT << "}" << std::endl;
36108 }
36109
36110 static void print_VkApplicationParametersEXT(VkApplicationParametersEXT obj, const std::string& s, bool commaNeeded=true) {
36111      PRINT_SPACE
36112      _OUT << "{" << std::endl;
36113      INDENT(4);
36114
36115      print_VkStructureType(obj.sType, "sType", 1);
36116
36117       if (obj.pNext) {
36118          dumpPNextChain(obj.pNext);
36119       } else {
36120          PRINT_SPACE
36121          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
36122      }
36123
36124      print_uint32_t(obj.vendorID, "vendorID", 1);
36125
36126      print_uint32_t(obj.deviceID, "deviceID", 1);
36127
36128      print_uint32_t(obj.key, "key", 1);
36129
36130      print_uint64_t(obj.value, "value", 0);
36131
36132      INDENT(-4);
36133      PRINT_SPACE
36134      if (commaNeeded)
36135          _OUT << "}," << std::endl;
36136      else
36137          _OUT << "}" << std::endl;
36138 }
36139 static void print_VkApplicationParametersEXT(const VkApplicationParametersEXT * obj, const std::string& s, bool commaNeeded=true) {
36140      PRINT_SPACE
36141      _OUT << "{" << std::endl;
36142      INDENT(4);
36143
36144      print_VkStructureType(obj->sType, "sType", 1);
36145
36146       if (obj->pNext) {
36147          dumpPNextChain(obj->pNext);
36148       } else {
36149          PRINT_SPACE
36150          _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl;
36151      }
36152
36153      print_uint32_t(obj->vendorID, "vendorID", 1);
36154
36155      print_uint32_t(obj->deviceID, "deviceID", 1);
36156
36157      print_uint32_t(obj->key, "key", 1);
36158
36159      print_uint64_t(obj->value, "value", 0);
36160
36161      INDENT(-4);
36162      PRINT_SPACE
36163      if (commaNeeded)
36164          _OUT << "}," << std::endl;
36165      else
36166          _OUT << "}" << std::endl;
36167 }
36168
36169 /*************************************** Begin prototypes ***********************************/
36170 /*************************************** End prototypes ***********************************/
36171
36172 static void dumpPNextChain(const void* pNext) {
36173       VkBaseInStructure *pBase = (VkBaseInStructure*)pNext;
36174       if (pNext) {
36175            PRINT_SPACE
36176            _OUT << "\"pNext\":"<< std::endl;
36177
36178           switch (pBase->sType) {
36179              case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:print_VkDisplayPresentInfoKHR((VkDisplayPresentInfoKHR *) pNext, "VkDisplayPresentInfoKHR", true);
36180              break;
36181              case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:print_VkValidationFeaturesEXT((VkValidationFeaturesEXT *) pNext, "VkValidationFeaturesEXT", true);
36182              break;
36183              case VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT:print_VkApplicationParametersEXT((VkApplicationParametersEXT *) pNext, "VkApplicationParametersEXT", true);
36184              break;
36185              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:print_VkPhysicalDeviceFeatures2((VkPhysicalDeviceFeatures2 *) pNext, "VkPhysicalDeviceFeatures2", true);
36186              break;
36187              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:print_VkPhysicalDeviceDriverProperties((VkPhysicalDeviceDriverProperties *) pNext, "VkPhysicalDeviceDriverProperties", true);
36188              break;
36189              case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:print_VkPresentRegionsKHR((VkPresentRegionsKHR *) pNext, "VkPresentRegionsKHR", true);
36190              break;
36191              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:print_VkPhysicalDeviceVariablePointersFeatures((VkPhysicalDeviceVariablePointersFeatures *) pNext, "VkPhysicalDeviceVariablePointersFeatures", true);
36192              break;
36193              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:print_VkPhysicalDeviceExternalImageFormatInfo((VkPhysicalDeviceExternalImageFormatInfo *) pNext, "VkPhysicalDeviceExternalImageFormatInfo", true);
36194              break;
36195              case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:print_VkExternalImageFormatProperties((VkExternalImageFormatProperties *) pNext, "VkExternalImageFormatProperties", true);
36196              break;
36197              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:print_VkPhysicalDeviceIDProperties((VkPhysicalDeviceIDProperties *) pNext, "VkPhysicalDeviceIDProperties", true);
36198              break;
36199              case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:print_VkExternalMemoryImageCreateInfo((VkExternalMemoryImageCreateInfo *) pNext, "VkExternalMemoryImageCreateInfo", true);
36200              break;
36201              case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:print_VkExternalMemoryBufferCreateInfo((VkExternalMemoryBufferCreateInfo *) pNext, "VkExternalMemoryBufferCreateInfo", true);
36202              break;
36203              case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:print_VkExportMemoryAllocateInfo((VkExportMemoryAllocateInfo *) pNext, "VkExportMemoryAllocateInfo", true);
36204              break;
36205              case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:print_VkImportMemoryFdInfoKHR((VkImportMemoryFdInfoKHR *) pNext, "VkImportMemoryFdInfoKHR", true);
36206              break;
36207              case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:print_VkExportSemaphoreCreateInfo((VkExportSemaphoreCreateInfo *) pNext, "VkExportSemaphoreCreateInfo", true);
36208              break;
36209              case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:print_VkExportFenceCreateInfo((VkExportFenceCreateInfo *) pNext, "VkExportFenceCreateInfo", true);
36210              break;
36211              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:print_VkPhysicalDeviceMultiviewFeatures((VkPhysicalDeviceMultiviewFeatures *) pNext, "VkPhysicalDeviceMultiviewFeatures", true);
36212              break;
36213              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:print_VkPhysicalDeviceMultiviewProperties((VkPhysicalDeviceMultiviewProperties *) pNext, "VkPhysicalDeviceMultiviewProperties", true);
36214              break;
36215              case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:print_VkRenderPassMultiviewCreateInfo((VkRenderPassMultiviewCreateInfo *) pNext, "VkRenderPassMultiviewCreateInfo", true);
36216              break;
36217              case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:print_VkSwapchainCounterCreateInfoEXT((VkSwapchainCounterCreateInfoEXT *) pNext, "VkSwapchainCounterCreateInfoEXT", true);
36218              break;
36219              case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:print_VkMemoryAllocateFlagsInfo((VkMemoryAllocateFlagsInfo *) pNext, "VkMemoryAllocateFlagsInfo", true);
36220              break;
36221              case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:print_VkBindBufferMemoryDeviceGroupInfo((VkBindBufferMemoryDeviceGroupInfo *) pNext, "VkBindBufferMemoryDeviceGroupInfo", true);
36222              break;
36223              case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:print_VkBindImageMemoryDeviceGroupInfo((VkBindImageMemoryDeviceGroupInfo *) pNext, "VkBindImageMemoryDeviceGroupInfo", true);
36224              break;
36225              case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:print_VkDeviceGroupRenderPassBeginInfo((VkDeviceGroupRenderPassBeginInfo *) pNext, "VkDeviceGroupRenderPassBeginInfo", true);
36226              break;
36227              case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:print_VkDeviceGroupCommandBufferBeginInfo((VkDeviceGroupCommandBufferBeginInfo *) pNext, "VkDeviceGroupCommandBufferBeginInfo", true);
36228              break;
36229              case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:print_VkDeviceGroupSubmitInfo((VkDeviceGroupSubmitInfo *) pNext, "VkDeviceGroupSubmitInfo", true);
36230              break;
36231              case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:print_VkImageSwapchainCreateInfoKHR((VkImageSwapchainCreateInfoKHR *) pNext, "VkImageSwapchainCreateInfoKHR", true);
36232              break;
36233              case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:print_VkBindImageMemorySwapchainInfoKHR((VkBindImageMemorySwapchainInfoKHR *) pNext, "VkBindImageMemorySwapchainInfoKHR", true);
36234              break;
36235              case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:print_VkDeviceGroupPresentInfoKHR((VkDeviceGroupPresentInfoKHR *) pNext, "VkDeviceGroupPresentInfoKHR", true);
36236              break;
36237              case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:print_VkDeviceGroupDeviceCreateInfo((VkDeviceGroupDeviceCreateInfo *) pNext, "VkDeviceGroupDeviceCreateInfo", true);
36238              break;
36239              case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:print_VkDeviceGroupSwapchainCreateInfoKHR((VkDeviceGroupSwapchainCreateInfoKHR *) pNext, "VkDeviceGroupSwapchainCreateInfoKHR", true);
36240              break;
36241              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:print_VkPhysicalDeviceDiscardRectanglePropertiesEXT((VkPhysicalDeviceDiscardRectanglePropertiesEXT *) pNext, "VkPhysicalDeviceDiscardRectanglePropertiesEXT", true);
36242              break;
36243              case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:print_VkPipelineDiscardRectangleStateCreateInfoEXT((VkPipelineDiscardRectangleStateCreateInfoEXT *) pNext, "VkPipelineDiscardRectangleStateCreateInfoEXT", true);
36244              break;
36245              case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:print_VkRenderPassInputAttachmentAspectCreateInfo((VkRenderPassInputAttachmentAspectCreateInfo *) pNext, "VkRenderPassInputAttachmentAspectCreateInfo", true);
36246              break;
36247              case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:print_VkSharedPresentSurfaceCapabilitiesKHR((VkSharedPresentSurfaceCapabilitiesKHR *) pNext, "VkSharedPresentSurfaceCapabilitiesKHR", true);
36248              break;
36249              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:print_VkPhysicalDevice16BitStorageFeatures((VkPhysicalDevice16BitStorageFeatures *) pNext, "VkPhysicalDevice16BitStorageFeatures", true);
36250              break;
36251              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:print_VkPhysicalDeviceSubgroupProperties((VkPhysicalDeviceSubgroupProperties *) pNext, "VkPhysicalDeviceSubgroupProperties", true);
36252              break;
36253              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures((VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *) pNext, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures", true);
36254              break;
36255              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:print_VkPhysicalDevicePointClippingProperties((VkPhysicalDevicePointClippingProperties *) pNext, "VkPhysicalDevicePointClippingProperties", true);
36256              break;
36257              case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:print_VkMemoryDedicatedRequirements((VkMemoryDedicatedRequirements *) pNext, "VkMemoryDedicatedRequirements", true);
36258              break;
36259              case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:print_VkMemoryDedicatedAllocateInfo((VkMemoryDedicatedAllocateInfo *) pNext, "VkMemoryDedicatedAllocateInfo", true);
36260              break;
36261              case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:print_VkImageViewUsageCreateInfo((VkImageViewUsageCreateInfo *) pNext, "VkImageViewUsageCreateInfo", true);
36262              break;
36263              case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:print_VkPipelineTessellationDomainOriginStateCreateInfo((VkPipelineTessellationDomainOriginStateCreateInfo *) pNext, "VkPipelineTessellationDomainOriginStateCreateInfo", true);
36264              break;
36265              case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:print_VkSamplerYcbcrConversionInfo((VkSamplerYcbcrConversionInfo *) pNext, "VkSamplerYcbcrConversionInfo", true);
36266              break;
36267              case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:print_VkBindImagePlaneMemoryInfo((VkBindImagePlaneMemoryInfo *) pNext, "VkBindImagePlaneMemoryInfo", true);
36268              break;
36269              case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:print_VkImagePlaneMemoryRequirementsInfo((VkImagePlaneMemoryRequirementsInfo *) pNext, "VkImagePlaneMemoryRequirementsInfo", true);
36270              break;
36271              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:print_VkPhysicalDeviceSamplerYcbcrConversionFeatures((VkPhysicalDeviceSamplerYcbcrConversionFeatures *) pNext, "VkPhysicalDeviceSamplerYcbcrConversionFeatures", true);
36272              break;
36273              case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:print_VkSamplerYcbcrConversionImageFormatProperties((VkSamplerYcbcrConversionImageFormatProperties *) pNext, "VkSamplerYcbcrConversionImageFormatProperties", true);
36274              break;
36275              case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:print_VkProtectedSubmitInfo((VkProtectedSubmitInfo *) pNext, "VkProtectedSubmitInfo", true);
36276              break;
36277              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:print_VkPhysicalDeviceProtectedMemoryFeatures((VkPhysicalDeviceProtectedMemoryFeatures *) pNext, "VkPhysicalDeviceProtectedMemoryFeatures", true);
36278              break;
36279              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:print_VkPhysicalDeviceProtectedMemoryProperties((VkPhysicalDeviceProtectedMemoryProperties *) pNext, "VkPhysicalDeviceProtectedMemoryProperties", true);
36280              break;
36281              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:print_VkPhysicalDeviceSamplerFilterMinmaxProperties((VkPhysicalDeviceSamplerFilterMinmaxProperties *) pNext, "VkPhysicalDeviceSamplerFilterMinmaxProperties", true);
36282              break;
36283              case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:print_VkSampleLocationsInfoEXT((VkSampleLocationsInfoEXT *) pNext, "VkSampleLocationsInfoEXT", true);
36284              break;
36285              case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:print_VkRenderPassSampleLocationsBeginInfoEXT((VkRenderPassSampleLocationsBeginInfoEXT *) pNext, "VkRenderPassSampleLocationsBeginInfoEXT", true);
36286              break;
36287              case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:print_VkPipelineSampleLocationsStateCreateInfoEXT((VkPipelineSampleLocationsStateCreateInfoEXT *) pNext, "VkPipelineSampleLocationsStateCreateInfoEXT", true);
36288              break;
36289              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:print_VkPhysicalDeviceSampleLocationsPropertiesEXT((VkPhysicalDeviceSampleLocationsPropertiesEXT *) pNext, "VkPhysicalDeviceSampleLocationsPropertiesEXT", true);
36290              break;
36291              case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:print_VkSamplerReductionModeCreateInfo((VkSamplerReductionModeCreateInfo *) pNext, "VkSamplerReductionModeCreateInfo", true);
36292              break;
36293              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT((VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *) pNext, "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT", true);
36294              break;
36295              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT((VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *) pNext, "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT", true);
36296              break;
36297              case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:print_VkPipelineColorBlendAdvancedStateCreateInfoEXT((VkPipelineColorBlendAdvancedStateCreateInfoEXT *) pNext, "VkPipelineColorBlendAdvancedStateCreateInfoEXT", true);
36298              break;
36299              case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:print_VkImageFormatListCreateInfo((VkImageFormatListCreateInfo *) pNext, "VkImageFormatListCreateInfo", true);
36300              break;
36301              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:print_VkPhysicalDeviceMaintenance3Properties((VkPhysicalDeviceMaintenance3Properties *) pNext, "VkPhysicalDeviceMaintenance3Properties", true);
36302              break;
36303              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:print_VkPhysicalDeviceShaderDrawParametersFeatures((VkPhysicalDeviceShaderDrawParametersFeatures *) pNext, "VkPhysicalDeviceShaderDrawParametersFeatures", true);
36304              break;
36305              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:print_VkPhysicalDeviceShaderFloat16Int8Features((VkPhysicalDeviceShaderFloat16Int8Features *) pNext, "VkPhysicalDeviceShaderFloat16Int8Features", true);
36306              break;
36307              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:print_VkPhysicalDeviceFloatControlsProperties((VkPhysicalDeviceFloatControlsProperties *) pNext, "VkPhysicalDeviceFloatControlsProperties", true);
36308              break;
36309              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:print_VkPhysicalDeviceHostQueryResetFeatures((VkPhysicalDeviceHostQueryResetFeatures *) pNext, "VkPhysicalDeviceHostQueryResetFeatures", true);
36310              break;
36311              case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:print_VkDeviceQueueGlobalPriorityCreateInfoEXT((VkDeviceQueueGlobalPriorityCreateInfoEXT *) pNext, "VkDeviceQueueGlobalPriorityCreateInfoEXT", true);
36312              break;
36313              case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:print_VkDebugUtilsMessengerCreateInfoEXT((VkDebugUtilsMessengerCreateInfoEXT *) pNext, "VkDebugUtilsMessengerCreateInfoEXT", true);
36314              break;
36315              case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:print_VkImportMemoryHostPointerInfoEXT((VkImportMemoryHostPointerInfoEXT *) pNext, "VkImportMemoryHostPointerInfoEXT", true);
36316              break;
36317              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT((VkPhysicalDeviceExternalMemoryHostPropertiesEXT *) pNext, "VkPhysicalDeviceExternalMemoryHostPropertiesEXT", true);
36318              break;
36319              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT((VkPhysicalDeviceConservativeRasterizationPropertiesEXT *) pNext, "VkPhysicalDeviceConservativeRasterizationPropertiesEXT", true);
36320              break;
36321              case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:print_VkPipelineRasterizationConservativeStateCreateInfoEXT((VkPipelineRasterizationConservativeStateCreateInfoEXT *) pNext, "VkPipelineRasterizationConservativeStateCreateInfoEXT", true);
36322              break;
36323              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:print_VkPhysicalDeviceDescriptorIndexingFeatures((VkPhysicalDeviceDescriptorIndexingFeatures *) pNext, "VkPhysicalDeviceDescriptorIndexingFeatures", true);
36324              break;
36325              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:print_VkPhysicalDeviceDescriptorIndexingProperties((VkPhysicalDeviceDescriptorIndexingProperties *) pNext, "VkPhysicalDeviceDescriptorIndexingProperties", true);
36326              break;
36327              case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:print_VkDescriptorSetLayoutBindingFlagsCreateInfo((VkDescriptorSetLayoutBindingFlagsCreateInfo *) pNext, "VkDescriptorSetLayoutBindingFlagsCreateInfo", true);
36328              break;
36329              case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:print_VkDescriptorSetVariableDescriptorCountAllocateInfo((VkDescriptorSetVariableDescriptorCountAllocateInfo *) pNext, "VkDescriptorSetVariableDescriptorCountAllocateInfo", true);
36330              break;
36331              case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:print_VkDescriptorSetVariableDescriptorCountLayoutSupport((VkDescriptorSetVariableDescriptorCountLayoutSupport *) pNext, "VkDescriptorSetVariableDescriptorCountLayoutSupport", true);
36332              break;
36333              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:print_VkPhysicalDeviceTimelineSemaphoreFeatures((VkPhysicalDeviceTimelineSemaphoreFeatures *) pNext, "VkPhysicalDeviceTimelineSemaphoreFeatures", true);
36334              break;
36335              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:print_VkPhysicalDeviceTimelineSemaphoreProperties((VkPhysicalDeviceTimelineSemaphoreProperties *) pNext, "VkPhysicalDeviceTimelineSemaphoreProperties", true);
36336              break;
36337              case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:print_VkSemaphoreTypeCreateInfo((VkSemaphoreTypeCreateInfo *) pNext, "VkSemaphoreTypeCreateInfo", true);
36338              break;
36339              case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:print_VkTimelineSemaphoreSubmitInfo((VkTimelineSemaphoreSubmitInfo *) pNext, "VkTimelineSemaphoreSubmitInfo", true);
36340              break;
36341              case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:print_VkPipelineVertexInputDivisorStateCreateInfoEXT((VkPipelineVertexInputDivisorStateCreateInfoEXT *) pNext, "VkPipelineVertexInputDivisorStateCreateInfoEXT", true);
36342              break;
36343              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT((VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *) pNext, "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT", true);
36344              break;
36345              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:print_VkPhysicalDevicePCIBusInfoPropertiesEXT((VkPhysicalDevicePCIBusInfoPropertiesEXT *) pNext, "VkPhysicalDevicePCIBusInfoPropertiesEXT", true);
36346              break;
36347              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:print_VkPhysicalDevice8BitStorageFeatures((VkPhysicalDevice8BitStorageFeatures *) pNext, "VkPhysicalDevice8BitStorageFeatures", true);
36348              break;
36349              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:print_VkPhysicalDeviceVulkanMemoryModelFeatures((VkPhysicalDeviceVulkanMemoryModelFeatures *) pNext, "VkPhysicalDeviceVulkanMemoryModelFeatures", true);
36350              break;
36351              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:print_VkPhysicalDeviceShaderAtomicInt64Features((VkPhysicalDeviceShaderAtomicInt64Features *) pNext, "VkPhysicalDeviceShaderAtomicInt64Features", true);
36352              break;
36353              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT((VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *) pNext, "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT", true);
36354              break;
36355              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT((VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *) pNext, "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT", true);
36356              break;
36357              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:print_VkPhysicalDeviceDepthStencilResolveProperties((VkPhysicalDeviceDepthStencilResolveProperties *) pNext, "VkPhysicalDeviceDepthStencilResolveProperties", true);
36358              break;
36359              case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:print_VkSubpassDescriptionDepthStencilResolve((VkSubpassDescriptionDepthStencilResolve *) pNext, "VkSubpassDescriptionDepthStencilResolve", true);
36360              break;
36361              case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:print_VkImageViewASTCDecodeModeEXT((VkImageViewASTCDecodeModeEXT *) pNext, "VkImageViewASTCDecodeModeEXT", true);
36362              break;
36363              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:print_VkPhysicalDeviceASTCDecodeFeaturesEXT((VkPhysicalDeviceASTCDecodeFeaturesEXT *) pNext, "VkPhysicalDeviceASTCDecodeFeaturesEXT", true);
36364              break;
36365              case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:print_VkDrmFormatModifierPropertiesListEXT((VkDrmFormatModifierPropertiesListEXT *) pNext, "VkDrmFormatModifierPropertiesListEXT", true);
36366              break;
36367              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT((VkPhysicalDeviceImageDrmFormatModifierInfoEXT *) pNext, "VkPhysicalDeviceImageDrmFormatModifierInfoEXT", true);
36368              break;
36369              case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:print_VkImageDrmFormatModifierListCreateInfoEXT((VkImageDrmFormatModifierListCreateInfoEXT *) pNext, "VkImageDrmFormatModifierListCreateInfoEXT", true);
36370              break;
36371              case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:print_VkImageDrmFormatModifierExplicitCreateInfoEXT((VkImageDrmFormatModifierExplicitCreateInfoEXT *) pNext, "VkImageDrmFormatModifierExplicitCreateInfoEXT", true);
36372              break;
36373              case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:print_VkImageStencilUsageCreateInfo((VkImageStencilUsageCreateInfo *) pNext, "VkImageStencilUsageCreateInfo", true);
36374              break;
36375              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:print_VkPhysicalDeviceScalarBlockLayoutFeatures((VkPhysicalDeviceScalarBlockLayoutFeatures *) pNext, "VkPhysicalDeviceScalarBlockLayoutFeatures", true);
36376              break;
36377              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures((VkPhysicalDeviceUniformBufferStandardLayoutFeatures *) pNext, "VkPhysicalDeviceUniformBufferStandardLayoutFeatures", true);
36378              break;
36379              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:print_VkPhysicalDeviceDepthClipEnableFeaturesEXT((VkPhysicalDeviceDepthClipEnableFeaturesEXT *) pNext, "VkPhysicalDeviceDepthClipEnableFeaturesEXT", true);
36380              break;
36381              case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:print_VkPipelineRasterizationDepthClipStateCreateInfoEXT((VkPipelineRasterizationDepthClipStateCreateInfoEXT *) pNext, "VkPipelineRasterizationDepthClipStateCreateInfoEXT", true);
36382              break;
36383              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:print_VkPhysicalDeviceMemoryBudgetPropertiesEXT((VkPhysicalDeviceMemoryBudgetPropertiesEXT *) pNext, "VkPhysicalDeviceMemoryBudgetPropertiesEXT", true);
36384              break;
36385              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:print_VkPhysicalDeviceBufferDeviceAddressFeatures((VkPhysicalDeviceBufferDeviceAddressFeatures *) pNext, "VkPhysicalDeviceBufferDeviceAddressFeatures", true);
36386              break;
36387              case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:print_VkBufferOpaqueCaptureAddressCreateInfo((VkBufferOpaqueCaptureAddressCreateInfo *) pNext, "VkBufferOpaqueCaptureAddressCreateInfo", true);
36388              break;
36389              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:print_VkPhysicalDeviceImageViewImageFormatInfoEXT((VkPhysicalDeviceImageViewImageFormatInfoEXT *) pNext, "VkPhysicalDeviceImageViewImageFormatInfoEXT", true);
36390              break;
36391              case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:print_VkFilterCubicImageViewImageFormatPropertiesEXT((VkFilterCubicImageViewImageFormatPropertiesEXT *) pNext, "VkFilterCubicImageViewImageFormatPropertiesEXT", true);
36392              break;
36393              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:print_VkPhysicalDeviceImagelessFramebufferFeatures((VkPhysicalDeviceImagelessFramebufferFeatures *) pNext, "VkPhysicalDeviceImagelessFramebufferFeatures", true);
36394              break;
36395              case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:print_VkFramebufferAttachmentsCreateInfo((VkFramebufferAttachmentsCreateInfo *) pNext, "VkFramebufferAttachmentsCreateInfo", true);
36396              break;
36397              case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:print_VkRenderPassAttachmentBeginInfo((VkRenderPassAttachmentBeginInfo *) pNext, "VkRenderPassAttachmentBeginInfo", true);
36398              break;
36399              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT((VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *) pNext, "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT", true);
36400              break;
36401              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT((VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *) pNext, "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT", true);
36402              break;
36403              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:print_VkPhysicalDevicePerformanceQueryFeaturesKHR((VkPhysicalDevicePerformanceQueryFeaturesKHR *) pNext, "VkPhysicalDevicePerformanceQueryFeaturesKHR", true);
36404              break;
36405              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:print_VkPhysicalDevicePerformanceQueryPropertiesKHR((VkPhysicalDevicePerformanceQueryPropertiesKHR *) pNext, "VkPhysicalDevicePerformanceQueryPropertiesKHR", true);
36406              break;
36407              case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:print_VkQueryPoolPerformanceCreateInfoKHR((VkQueryPoolPerformanceCreateInfoKHR *) pNext, "VkQueryPoolPerformanceCreateInfoKHR", true);
36408              break;
36409              case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:print_VkPerformanceQuerySubmitInfoKHR((VkPerformanceQuerySubmitInfoKHR *) pNext, "VkPerformanceQuerySubmitInfoKHR", true);
36410              break;
36411              case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:print_VkPerformanceQueryReservationInfoKHR((VkPerformanceQueryReservationInfoKHR *) pNext, "VkPerformanceQueryReservationInfoKHR", true);
36412              break;
36413              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:print_VkPhysicalDeviceShaderClockFeaturesKHR((VkPhysicalDeviceShaderClockFeaturesKHR *) pNext, "VkPhysicalDeviceShaderClockFeaturesKHR", true);
36414              break;
36415              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT((VkPhysicalDeviceIndexTypeUint8FeaturesEXT *) pNext, "VkPhysicalDeviceIndexTypeUint8FeaturesEXT", true);
36416              break;
36417              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT((VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *) pNext, "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT", true);
36418              break;
36419              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures((VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *) pNext, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures", true);
36420              break;
36421              case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:print_VkAttachmentReferenceStencilLayout((VkAttachmentReferenceStencilLayout *) pNext, "VkAttachmentReferenceStencilLayout", true);
36422              break;
36423              case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:print_VkAttachmentDescriptionStencilLayout((VkAttachmentDescriptionStencilLayout *) pNext, "VkAttachmentDescriptionStencilLayout", true);
36424              break;
36425              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT((VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *) pNext, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT", true);
36426              break;
36427              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT((VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *) pNext, "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT", true);
36428              break;
36429              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT((VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *) pNext, "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT", true);
36430              break;
36431              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT((VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *) pNext, "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT", true);
36432              break;
36433              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT((VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *) pNext, "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT", true);
36434              break;
36435              case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT((VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *) pNext, "VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT", true);
36436              break;
36437              case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:print_VkMemoryOpaqueCaptureAddressAllocateInfo((VkMemoryOpaqueCaptureAddressAllocateInfo *) pNext, "VkMemoryOpaqueCaptureAddressAllocateInfo", true);
36438              break;
36439              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:print_VkPhysicalDeviceLineRasterizationFeaturesEXT((VkPhysicalDeviceLineRasterizationFeaturesEXT *) pNext, "VkPhysicalDeviceLineRasterizationFeaturesEXT", true);
36440              break;
36441              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:print_VkPhysicalDeviceLineRasterizationPropertiesEXT((VkPhysicalDeviceLineRasterizationPropertiesEXT *) pNext, "VkPhysicalDeviceLineRasterizationPropertiesEXT", true);
36442              break;
36443              case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:print_VkPipelineRasterizationLineStateCreateInfoEXT((VkPipelineRasterizationLineStateCreateInfoEXT *) pNext, "VkPipelineRasterizationLineStateCreateInfoEXT", true);
36444              break;
36445              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:print_VkPhysicalDeviceVulkan11Features((VkPhysicalDeviceVulkan11Features *) pNext, "VkPhysicalDeviceVulkan11Features", true);
36446              break;
36447              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:print_VkPhysicalDeviceVulkan11Properties((VkPhysicalDeviceVulkan11Properties *) pNext, "VkPhysicalDeviceVulkan11Properties", true);
36448              break;
36449              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:print_VkPhysicalDeviceVulkan12Features((VkPhysicalDeviceVulkan12Features *) pNext, "VkPhysicalDeviceVulkan12Features", true);
36450              break;
36451              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:print_VkPhysicalDeviceVulkan12Properties((VkPhysicalDeviceVulkan12Properties *) pNext, "VkPhysicalDeviceVulkan12Properties", true);
36452              break;
36453              case VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO:print_VkFaultCallbackInfo((VkFaultCallbackInfo *) pNext, "VkFaultCallbackInfo", true);
36454              break;
36455              case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:print_VkSamplerCustomBorderColorCreateInfoEXT((VkSamplerCustomBorderColorCreateInfoEXT *) pNext, "VkSamplerCustomBorderColorCreateInfoEXT", true);
36456              break;
36457              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:print_VkPhysicalDeviceCustomBorderColorPropertiesEXT((VkPhysicalDeviceCustomBorderColorPropertiesEXT *) pNext, "VkPhysicalDeviceCustomBorderColorPropertiesEXT", true);
36458              break;
36459              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:print_VkPhysicalDeviceCustomBorderColorFeaturesEXT((VkPhysicalDeviceCustomBorderColorFeaturesEXT *) pNext, "VkPhysicalDeviceCustomBorderColorFeaturesEXT", true);
36460              break;
36461              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT((VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *) pNext, "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT", true);
36462              break;
36463              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT((VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *) pNext, "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT", true);
36464              break;
36465              case VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO:print_VkPipelineOfflineCreateInfo((VkPipelineOfflineCreateInfo *) pNext, "VkPipelineOfflineCreateInfo", true);
36466              break;
36467              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:print_VkPhysicalDeviceRobustness2FeaturesEXT((VkPhysicalDeviceRobustness2FeaturesEXT *) pNext, "VkPhysicalDeviceRobustness2FeaturesEXT", true);
36468              break;
36469              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:print_VkPhysicalDeviceRobustness2PropertiesEXT((VkPhysicalDeviceRobustness2PropertiesEXT *) pNext, "VkPhysicalDeviceRobustness2PropertiesEXT", true);
36470              break;
36471              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:print_VkPhysicalDeviceImageRobustnessFeaturesEXT((VkPhysicalDeviceImageRobustnessFeaturesEXT *) pNext, "VkPhysicalDeviceImageRobustnessFeaturesEXT", true);
36472              break;
36473              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:print_VkPhysicalDevice4444FormatsFeaturesEXT((VkPhysicalDevice4444FormatsFeaturesEXT *) pNext, "VkPhysicalDevice4444FormatsFeaturesEXT", true);
36474              break;
36475              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT((VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *) pNext, "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT", true);
36476              break;
36477              case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:print_VkFragmentShadingRateAttachmentInfoKHR((VkFragmentShadingRateAttachmentInfoKHR *) pNext, "VkFragmentShadingRateAttachmentInfoKHR", true);
36478              break;
36479              case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:print_VkPipelineFragmentShadingRateStateCreateInfoKHR((VkPipelineFragmentShadingRateStateCreateInfoKHR *) pNext, "VkPipelineFragmentShadingRateStateCreateInfoKHR", true);
36480              break;
36481              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR((VkPhysicalDeviceFragmentShadingRateFeaturesKHR *) pNext, "VkPhysicalDeviceFragmentShadingRateFeaturesKHR", true);
36482              break;
36483              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR((VkPhysicalDeviceFragmentShadingRatePropertiesKHR *) pNext, "VkPhysicalDeviceFragmentShadingRatePropertiesKHR", true);
36484              break;
36485              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR((VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *) pNext, "VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR", true);
36486              break;
36487              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT((VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *) pNext, "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT", true);
36488              break;
36489              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:print_VkPhysicalDeviceColorWriteEnableFeaturesEXT((VkPhysicalDeviceColorWriteEnableFeaturesEXT *) pNext, "VkPhysicalDeviceColorWriteEnableFeaturesEXT", true);
36490              break;
36491              case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:print_VkPipelineColorWriteCreateInfoEXT((VkPipelineColorWriteCreateInfoEXT *) pNext, "VkPipelineColorWriteCreateInfoEXT", true);
36492              break;
36493              case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:print_VkMemoryBarrier2KHR((VkMemoryBarrier2KHR *) pNext, "VkMemoryBarrier2KHR", true);
36494              break;
36495              case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:print_VkQueueFamilyCheckpointProperties2NV((VkQueueFamilyCheckpointProperties2NV *) pNext, "VkQueueFamilyCheckpointProperties2NV", true);
36496              break;
36497              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:print_VkPhysicalDeviceSynchronization2FeaturesKHR((VkPhysicalDeviceSynchronization2FeaturesKHR *) pNext, "VkPhysicalDeviceSynchronization2FeaturesKHR", true);
36498              break;
36499              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES:print_VkPhysicalDeviceVulkanSC10Properties((VkPhysicalDeviceVulkanSC10Properties *) pNext, "VkPhysicalDeviceVulkanSC10Properties", true);
36500              break;
36501              case VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO:print_VkDeviceObjectReservationCreateInfo((VkDeviceObjectReservationCreateInfo *) pNext, "VkDeviceObjectReservationCreateInfo", true);
36502              break;
36503              case VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO:print_VkCommandPoolMemoryReservationCreateInfo((VkCommandPoolMemoryReservationCreateInfo *) pNext, "VkCommandPoolMemoryReservationCreateInfo", true);
36504              break;
36505              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES:print_VkPhysicalDeviceVulkanSC10Features((VkPhysicalDeviceVulkanSC10Features *) pNext, "VkPhysicalDeviceVulkanSC10Features", true);
36506              break;
36507              case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT((VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *) pNext, "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT", true);
36508              break;
36509              case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:print_VkDrmFormatModifierPropertiesList2EXT((VkDrmFormatModifierPropertiesList2EXT *) pNext, "VkDrmFormatModifierPropertiesList2EXT", true);
36510              break;
36511              default: assert(false); // No structure type matching
36512          }
36513      }
36514   }
36515
36516 }//End of namespace vk_json
36517
36518 #endif // _VULKAN_JSON_DATA_HPP