xref: /aosp_15_r20/external/deqp/external/vulkancts/framework/vulkan/generated/vulkansc/vulkan_json_data.hpp (revision 35238bce31c2a825756842865a792f8cf7f89930) 
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 /** This code is generated. To make changes, please modify the scripts or the relevant xml **/
26 /********************************************************************************************/
27 
28 #include <iostream>
29 #include <map>
30 #include <bitset>
31 #include <functional>
32 #include <sstream>
33 #include <cassert>
34 #include <cmath>
35 #ifndef VULKAN_JSON_CTS
36 #include <vulkan/vulkan.h>
37 #endif
38 
39 #ifdef _WIN32
40 #ifndef WIN32_LEAN_AND_MEAN
41 #define WIN32_LEAN_AND_MEAN
42 #endif
43 #define VC_EXTRALEAN
44 #define NOMINMAX
45 #include <windows.h>
46 #endif
47 
48 namespace vk_json
49 {
50 
51 static thread_local int s_num_spaces = 0;
52 static thread_local std::stringstream _string_stream;
53 
54 static void dumpPNextChain(const void *pNext);
55 
56 // By default, redirect to std::cout. Can stream it to a stringstream if needed.
57 //#define   _OUT std::cout
58 #define _OUT _string_stream
59 
60 // Helper utility to do indentation in the generated json file.
61 #define PRINT_SPACE                        \
62     for (int k = 0; k < s_num_spaces; k++) \
63         _OUT << " ";
64 
65 #define INDENT(sz) s_num_spaces += (sz);
66 
67 #define PRINT_VAL(c)                                       \
68     PRINT_SPACE                                            \
69     if (s != "")                                           \
70     {                                                      \
71         _OUT << "\"" << s << "\""                          \
72              << " : " << o << (c ? "," : "") << std::endl; \
73     }                                                      \
74     else                                                   \
75     {                                                      \
76         _OUT << o << (c ? "," : "") << std::endl;          \
77     }
78 
79 #define PRINT_STR(c)                                              \
80     PRINT_SPACE                                                   \
81     if (s != "")                                                  \
82     {                                                             \
83         _OUT << "\"" << s << "\""                                 \
84              << " : "                                             \
85              << "\"" << o << "\"" << (c ? "," : "") << std::endl; \
86     }                                                             \
87     else                                                          \
88     {                                                             \
89         _OUT << "\"" << o << "\"" << (c ? "," : "") << std::endl; \
90     }
91 
92 // To make sure the generated data is consistent across platforms,
93 // we typecast to 32-bit and dump the data.
94 // The value is not expected to exceed the range.
print_size_t(const size_t * o,const std::string & s,bool commaNeeded=true)95 static void print_size_t(const size_t *o, const std::string &s, bool commaNeeded = true)
96 {
97     PRINT_SPACE
98     _OUT << "\"" << s << "\""
99          << " : " << static_cast<uint32_t>(*o) << (commaNeeded ? "," : "") << std::endl;
100 }
print_size_t(size_t o,const std::string & s,bool commaNeeded=true)101 static void print_size_t(size_t o, const std::string &s, bool commaNeeded = true)
102 {
103     PRINT_SPACE
104     _OUT << "\"" << s << "\""
105          << " : " << static_cast<uint32_t>(o) << (commaNeeded ? "," : "") << std::endl;
106 }
107 
print_int32_t(int32_t o,const std::string & s,bool commaNeeded=true)108 static void print_int32_t(int32_t o, const std::string &s, bool commaNeeded = true)
109 {
110     PRINT_VAL(commaNeeded)
111 }
112 
print_int32_t(const int32_t * o,const std::string & s,bool commaNeeded=true)113 static void print_int32_t(const int32_t *o, const std::string &s, bool commaNeeded = true)
114 {
115     PRINT_VAL(commaNeeded)
116 }
117 
print_uint32_t(uint32_t o,const std::string & s,bool commaNeeded=true)118 static void print_uint32_t(uint32_t o, const std::string &s, bool commaNeeded = true)
119 {
120     PRINT_VAL(commaNeeded)
121 }
122 
print_uint32_t(const uint32_t * o,const std::string & s,bool commaNeeded=true)123 static void print_uint32_t(const uint32_t *o, const std::string &s, bool commaNeeded = true)
124 {
125     PRINT_VAL(commaNeeded)
126 }
127 
print_uint8_t(uint8_t o,const std::string & s,bool commaNeeded=true)128 static void print_uint8_t(uint8_t o, const std::string &s, bool commaNeeded = true)
129 {
130     PRINT_VAL(commaNeeded)
131 }
132 
print_uint8_t(const uint8_t * o,const std::string & s,bool commaNeeded=true)133 static void print_uint8_t(const uint8_t *o, const std::string &s, bool commaNeeded = true)
134 {
135     PRINT_VAL(commaNeeded)
136 }
137 
print_uint64_t(uint64_t o,const std::string & s,bool commaNeeded=true)138 static void print_uint64_t(uint64_t o, const std::string &s, bool commaNeeded = true)
139 {
140     PRINT_VAL(commaNeeded)
141 }
142 
print_uint64_t(const uint64_t * o,const std::string & s,bool commaNeeded=true)143 static void print_uint64_t(const uint64_t *o, const std::string &s, bool commaNeeded = true)
144 {
145     PRINT_VAL(commaNeeded)
146 }
147 
print_float(float o,const std::string & s,bool commaNeeded=true)148 static void print_float(float o, const std::string &s, bool commaNeeded = true)
149 {
150     if (std::isnan(o))
151     {
152         PRINT_SPACE
153         if (s != "")
154             _OUT << "\"" << s << "\""
155                  << " : \"NaN\"" << (commaNeeded ? "," : "") << std::endl;
156         else
157             _OUT << "\"NaN\"" << (commaNeeded ? "," : "") << std::endl;
158     }
159     else
160     {
161         PRINT_VAL(commaNeeded)
162     }
163 }
164 
print_float(const float * o,const std::string & s,bool commaNeeded=true)165 static void print_float(const float *o, const std::string &s, bool commaNeeded = true)
166 {
167     if (std::isnan(*o))
168     {
169         PRINT_SPACE
170         if (s != "")
171             _OUT << "\"" << s << "\""
172                  << " : \"NaN\"" << (commaNeeded ? "," : "") << std::endl;
173         else
174             _OUT << "\"NaN\"" << (commaNeeded ? "," : "") << std::endl;
175     }
176     else
177     {
178         PRINT_VAL(commaNeeded)
179     }
180 }
181 
print_int(int o,const std::string & s,bool commaNeeded=true)182 static void print_int(int o, const std::string &s, bool commaNeeded = true)
183 {
184     PRINT_VAL(commaNeeded)
185 }
186 
print_int(const int * o,const std::string & s,bool commaNeeded=true)187 static void print_int(const int *o, const std::string &s, bool commaNeeded = true)
188 {
189     PRINT_VAL(commaNeeded)
190 }
191 
print_double(double o,const std::string & s,bool commaNeeded=true)192 static void print_double(double o, const std::string &s, bool commaNeeded = true)
193 {
194     PRINT_VAL(commaNeeded)
195 }
196 
print_double(const double * o,const std::string & s,bool commaNeeded=true)197 static void print_double(const double *o, const std::string &s, bool commaNeeded = true)
198 {
199     PRINT_VAL(commaNeeded)
200 }
201 
print_int64_t(int64_t o,const std::string & s,bool commaNeeded=true)202 static void print_int64_t(int64_t o, const std::string &s, bool commaNeeded = true)
203 {
204     PRINT_VAL(commaNeeded)
205 }
206 
print_int64_t(const int64_t * o,const std::string & s,bool commaNeeded=true)207 static void print_int64_t(const int64_t *o, const std::string &s, bool commaNeeded = true)
208 {
209     PRINT_VAL(commaNeeded)
210 }
211 
print_uint16_t(uint16_t o,const std::string & s,bool commaNeeded=true)212 static void print_uint16_t(uint16_t o, const std::string &s, bool commaNeeded = true)
213 {
214     PRINT_VAL(commaNeeded)
215 }
216 
print_uint16_t(const uint16_t * o,const std::string & s,bool commaNeeded=true)217 static void print_uint16_t(const uint16_t *o, const std::string &s, bool commaNeeded = true)
218 {
219     PRINT_VAL(commaNeeded)
220 }
221 
print_char(const char * const * o,const std::string & s,bool commaNeeded=true)222 static void print_char(const char *const *o, const std::string &s, bool commaNeeded = true)
223 {
224     PRINT_STR(commaNeeded)
225 }
226 
print_char(char o,const std::string & s,bool commaNeeded=true)227 static void print_char(char o, const std::string &s, bool commaNeeded = true)
228 {
229     PRINT_VAL(commaNeeded)
230 }
231 
print_char(const char * o,const std::string & s,bool commaNeeded=true)232 static void print_char(const char *o, const std::string &s, bool commaNeeded = true)
233 {
234     PRINT_STR(commaNeeded)
235 }
236 
237 // Base 64 formater class from executor/xeTestLogWriter.cpp
238 
239 class Base64Formatter
240 {
241 public:
242     const uint8_t *data;
243     int numBytes;
244 
Base64Formatter(const uint8_t * data_,int numBytes_)245     Base64Formatter(const uint8_t *data_, int numBytes_) : data(data_), numBytes(numBytes_)
246     {
247     }
248 };
249 
operator <<(std::ostream & str,const Base64Formatter & fmt)250 std::ostream &operator<<(std::ostream &str, const Base64Formatter &fmt)
251 {
252     static const char s_base64Table[64] = {
253         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
254         'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
255         's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
256 
257     const uint8_t *data = fmt.data;
258     int numBytes        = fmt.numBytes;
259     int srcNdx          = 0;
260 
261     DE_ASSERT(data && (numBytes > 0));
262 
263     /* Loop all input chars. */
264     while (srcNdx < numBytes)
265     {
266         int numRead = de::min(3, numBytes - srcNdx);
267         uint8_t s0  = data[srcNdx];
268         uint8_t s1  = (numRead >= 2) ? data[srcNdx + 1] : 0;
269         uint8_t s2  = (numRead >= 3) ? data[srcNdx + 2] : 0;
270         char d[4];
271 
272         srcNdx += numRead;
273 
274         d[0] = s_base64Table[s0 >> 2];
275         d[1] = s_base64Table[((s0 & 0x3) << 4) | (s1 >> 4)];
276         d[2] = s_base64Table[((s1 & 0xF) << 2) | (s2 >> 6)];
277         d[3] = s_base64Table[s2 & 0x3F];
278 
279         if (numRead < 3)
280             d[3] = '=';
281         if (numRead < 2)
282             d[2] = '=';
283 
284         /* Write data. */
285         str.write(&d[0], sizeof(d));
286     }
287 
288     return str;
289 }
290 
toBase64(const uint8_t * bytes,int numBytes)291 inline Base64Formatter toBase64(const uint8_t *bytes, int numBytes)
292 {
293     return Base64Formatter(bytes, numBytes);
294 }
295 
print_void_data(const void * o,int oSize,const std::string & s,bool commaNeeded=true)296 static void print_void_data(const void *o, int oSize, const std::string &s, bool commaNeeded = true)
297 {
298     if (o != NULL && oSize != 0)
299     {
300         PRINT_SPACE _OUT << "\"" << s << "\""
301                          << " : "
302                          << "\"" << toBase64((uint8_t *)o, oSize) << "\"" << (commaNeeded ? "," : "") << std::endl;
303     }
304     else
305     {
306         PRINT_SPACE _OUT << "\"" << s << "\""
307                          << " : "
308                          << "\"NULL\"" << (commaNeeded ? "," : "") << std::endl;
309     }
310 }
311 
print_VkBool32(VkBool32 obj,const std::string & str,bool commaNeeded=true)312 static void print_VkBool32(VkBool32 obj, const std::string &str, bool commaNeeded = true)
313 {
314     PRINT_SPACE
315     _OUT << "\"" << str << "\""
316          << " : "
317          << "\"" << ((obj == 0) ? ("VK_FALSE") : ("VK_TRUE")) << "\"" << (commaNeeded ? "," : "") << std::endl;
318 }
print_VkBool32(const VkBool32 * obj,const std::string & str,bool commaNeeded=true)319 static void print_VkBool32(const VkBool32 *obj, const std::string &str, bool commaNeeded = true)
320 {
321     PRINT_SPACE
322     _OUT << "\"" << str << "\""
323          << " : "
324          << "\"" << ((obj == 0) ? ("VK_FALSE") : ("VK_TRUE")) << "\"" << (commaNeeded ? "," : "") << std::endl;
325 }
326 
print_VkDeviceAddress(VkDeviceAddress obj,const std::string & str,bool commaNeeded=true)327 static void print_VkDeviceAddress(VkDeviceAddress obj, const std::string &str, bool commaNeeded = true)
328 {
329     PRINT_SPACE
330     _OUT << "\"" << str << "\""
331          << " : "
332          << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
333 }
print_VkDeviceAddress(const VkDeviceAddress * obj,const std::string & str,bool commaNeeded=true)334 static void print_VkDeviceAddress(const VkDeviceAddress *obj, const std::string &str, bool commaNeeded = true)
335 {
336     PRINT_SPACE
337     _OUT << "\"" << str << "\""
338          << " : "
339          << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
340 }
341 
print_VkDeviceSize(VkDeviceSize obj,const std::string & str,bool commaNeeded=true)342 static void print_VkDeviceSize(VkDeviceSize obj, const std::string &str, bool commaNeeded = true)
343 {
344     PRINT_SPACE
345     _OUT << "\"" << str << "\""
346          << " : "
347          << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
348 }
print_VkDeviceSize(const VkDeviceSize * obj,const std::string & str,bool commaNeeded=true)349 static void print_VkDeviceSize(const VkDeviceSize *obj, const std::string &str, bool commaNeeded = true)
350 {
351     PRINT_SPACE
352     _OUT << "\"" << str << "\""
353          << " : "
354          << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
355 }
356 
print_VkFlags(VkFlags obj,const std::string & str,bool commaNeeded=true)357 static void print_VkFlags(VkFlags obj, const std::string &str, bool commaNeeded = true)
358 {
359     PRINT_SPACE
360     _OUT << "\"" << str << "\""
361          << " : "
362          << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
363 }
print_VkFlags(const VkFlags * obj,const std::string & str,bool commaNeeded=true)364 static void print_VkFlags(const VkFlags *obj, const std::string &str, bool commaNeeded = true)
365 {
366     PRINT_SPACE
367     _OUT << "\"" << str << "\""
368          << " : "
369          << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
370 }
371 
print_VkSampleMask(VkSampleMask obj,const std::string & str,bool commaNeeded=true)372 static void print_VkSampleMask(VkSampleMask obj, const std::string &str, bool commaNeeded = true)
373 {
374     PRINT_SPACE
375     _OUT << "\"" << str << "\""
376          << " : "
377          << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
378 }
print_VkSampleMask(const VkSampleMask * obj,const std::string & str,bool commaNeeded=true)379 static void print_VkSampleMask(const VkSampleMask *obj, const std::string &str, bool commaNeeded = true)
380 {
381     PRINT_SPACE
382     _OUT << "\"" << str << "\""
383          << " : "
384          << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
385 }
386 
print_VkBuffer(VkBuffer obj,const std::string & str,bool commaNeeded=true)387 static void print_VkBuffer(VkBuffer obj, const std::string &str, bool commaNeeded = true)
388 {
389     PRINT_SPACE
390     if (commaNeeded)
391         _OUT << "\"" << str << "\""
392              << "," << std::endl;
393     else
394         _OUT << "\"" << str << "\"" << std::endl;
395 }
print_VkBuffer(const VkBuffer * obj,const std::string & str,bool commaNeeded=true)396 static void print_VkBuffer(const VkBuffer *obj, const std::string &str, bool commaNeeded = true)
397 {
398     PRINT_SPACE
399     if (commaNeeded)
400         _OUT << "\"" << str << "\""
401              << "," << std::endl;
402     else
403         _OUT << "\"" << str << "\"" << std::endl;
404 }
405 
print_VkImage(VkImage obj,const std::string & str,bool commaNeeded=true)406 static void print_VkImage(VkImage obj, const std::string &str, bool commaNeeded = true)
407 {
408     PRINT_SPACE
409     if (commaNeeded)
410         _OUT << "\"" << str << "\""
411              << "," << std::endl;
412     else
413         _OUT << "\"" << str << "\"" << std::endl;
414 }
print_VkImage(const VkImage * obj,const std::string & str,bool commaNeeded=true)415 static void print_VkImage(const VkImage *obj, const std::string &str, bool commaNeeded = true)
416 {
417     PRINT_SPACE
418     if (commaNeeded)
419         _OUT << "\"" << str << "\""
420              << "," << std::endl;
421     else
422         _OUT << "\"" << str << "\"" << std::endl;
423 }
424 
print_VkInstance(VkInstance obj,const std::string & str,bool commaNeeded=true)425 static void print_VkInstance(VkInstance obj, const std::string &str, bool commaNeeded = true)
426 {
427     PRINT_SPACE
428     if (commaNeeded)
429         _OUT << "\"" << str << "\""
430              << "," << std::endl;
431     else
432         _OUT << "\"" << str << "\"" << std::endl;
433 }
print_VkInstance(const VkInstance * obj,const std::string & str,bool commaNeeded=true)434 static void print_VkInstance(const VkInstance *obj, const std::string &str, bool commaNeeded = true)
435 {
436     PRINT_SPACE
437     if (commaNeeded)
438         _OUT << "\"" << str << "\""
439              << "," << std::endl;
440     else
441         _OUT << "\"" << str << "\"" << std::endl;
442 }
443 
print_VkPhysicalDevice(VkPhysicalDevice obj,const std::string & str,bool commaNeeded=true)444 static void print_VkPhysicalDevice(VkPhysicalDevice obj, const std::string &str, bool commaNeeded = true)
445 {
446     PRINT_SPACE
447     if (commaNeeded)
448         _OUT << "\"" << str << "\""
449              << "," << std::endl;
450     else
451         _OUT << "\"" << str << "\"" << std::endl;
452 }
print_VkPhysicalDevice(const VkPhysicalDevice * obj,const std::string & str,bool commaNeeded=true)453 static void print_VkPhysicalDevice(const VkPhysicalDevice *obj, const std::string &str, bool commaNeeded = true)
454 {
455     PRINT_SPACE
456     if (commaNeeded)
457         _OUT << "\"" << str << "\""
458              << "," << std::endl;
459     else
460         _OUT << "\"" << str << "\"" << std::endl;
461 }
462 
print_VkDevice(VkDevice obj,const std::string & str,bool commaNeeded=true)463 static void print_VkDevice(VkDevice obj, const std::string &str, bool commaNeeded = true)
464 {
465     PRINT_SPACE
466     if (commaNeeded)
467         _OUT << "\"" << str << "\""
468              << "," << std::endl;
469     else
470         _OUT << "\"" << str << "\"" << std::endl;
471 }
print_VkDevice(const VkDevice * obj,const std::string & str,bool commaNeeded=true)472 static void print_VkDevice(const VkDevice *obj, const std::string &str, bool commaNeeded = true)
473 {
474     PRINT_SPACE
475     if (commaNeeded)
476         _OUT << "\"" << str << "\""
477              << "," << std::endl;
478     else
479         _OUT << "\"" << str << "\"" << std::endl;
480 }
481 
print_VkQueue(VkQueue obj,const std::string & str,bool commaNeeded=true)482 static void print_VkQueue(VkQueue obj, const std::string &str, bool commaNeeded = true)
483 {
484     PRINT_SPACE
485     if (commaNeeded)
486         _OUT << "\"" << str << "\""
487              << "," << std::endl;
488     else
489         _OUT << "\"" << str << "\"" << std::endl;
490 }
print_VkQueue(const VkQueue * obj,const std::string & str,bool commaNeeded=true)491 static void print_VkQueue(const VkQueue *obj, const std::string &str, bool commaNeeded = true)
492 {
493     PRINT_SPACE
494     if (commaNeeded)
495         _OUT << "\"" << str << "\""
496              << "," << std::endl;
497     else
498         _OUT << "\"" << str << "\"" << std::endl;
499 }
500 
print_VkSemaphore(VkSemaphore obj,const std::string & str,bool commaNeeded=true)501 static void print_VkSemaphore(VkSemaphore obj, const std::string &str, bool commaNeeded = true)
502 {
503     PRINT_SPACE
504     if (commaNeeded)
505         _OUT << "\"" << str << "\""
506              << "," << std::endl;
507     else
508         _OUT << "\"" << str << "\"" << std::endl;
509 }
print_VkSemaphore(const VkSemaphore * obj,const std::string & str,bool commaNeeded=true)510 static void print_VkSemaphore(const VkSemaphore *obj, const std::string &str, bool commaNeeded = true)
511 {
512     PRINT_SPACE
513     if (commaNeeded)
514         _OUT << "\"" << str << "\""
515              << "," << std::endl;
516     else
517         _OUT << "\"" << str << "\"" << std::endl;
518 }
519 
print_VkCommandBuffer(VkCommandBuffer obj,const std::string & str,bool commaNeeded=true)520 static void print_VkCommandBuffer(VkCommandBuffer obj, const std::string &str, bool commaNeeded = true)
521 {
522     PRINT_SPACE
523     if (commaNeeded)
524         _OUT << "\"" << str << "\""
525              << "," << std::endl;
526     else
527         _OUT << "\"" << str << "\"" << std::endl;
528 }
print_VkCommandBuffer(const VkCommandBuffer * obj,const std::string & str,bool commaNeeded=true)529 static void print_VkCommandBuffer(const VkCommandBuffer *obj, const std::string &str, bool commaNeeded = true)
530 {
531     PRINT_SPACE
532     if (commaNeeded)
533         _OUT << "\"" << str << "\""
534              << "," << std::endl;
535     else
536         _OUT << "\"" << str << "\"" << std::endl;
537 }
538 
print_VkFence(VkFence obj,const std::string & str,bool commaNeeded=true)539 static void print_VkFence(VkFence obj, const std::string &str, bool commaNeeded = true)
540 {
541     PRINT_SPACE
542     if (commaNeeded)
543         _OUT << "\"" << str << "\""
544              << "," << std::endl;
545     else
546         _OUT << "\"" << str << "\"" << std::endl;
547 }
print_VkFence(const VkFence * obj,const std::string & str,bool commaNeeded=true)548 static void print_VkFence(const VkFence *obj, const std::string &str, bool commaNeeded = true)
549 {
550     PRINT_SPACE
551     if (commaNeeded)
552         _OUT << "\"" << str << "\""
553              << "," << std::endl;
554     else
555         _OUT << "\"" << str << "\"" << std::endl;
556 }
557 
print_VkDeviceMemory(VkDeviceMemory obj,const std::string & str,bool commaNeeded=true)558 static void print_VkDeviceMemory(VkDeviceMemory obj, const std::string &str, bool commaNeeded = true)
559 {
560     PRINT_SPACE
561     if (commaNeeded)
562         _OUT << "\"" << str << "\""
563              << "," << std::endl;
564     else
565         _OUT << "\"" << str << "\"" << std::endl;
566 }
print_VkDeviceMemory(const VkDeviceMemory * obj,const std::string & str,bool commaNeeded=true)567 static void print_VkDeviceMemory(const VkDeviceMemory *obj, const std::string &str, bool commaNeeded = true)
568 {
569     PRINT_SPACE
570     if (commaNeeded)
571         _OUT << "\"" << str << "\""
572              << "," << std::endl;
573     else
574         _OUT << "\"" << str << "\"" << std::endl;
575 }
576 
print_VkEvent(VkEvent obj,const std::string & str,bool commaNeeded=true)577 static void print_VkEvent(VkEvent obj, const std::string &str, bool commaNeeded = true)
578 {
579     PRINT_SPACE
580     if (commaNeeded)
581         _OUT << "\"" << str << "\""
582              << "," << std::endl;
583     else
584         _OUT << "\"" << str << "\"" << std::endl;
585 }
print_VkEvent(const VkEvent * obj,const std::string & str,bool commaNeeded=true)586 static void print_VkEvent(const VkEvent *obj, const std::string &str, bool commaNeeded = true)
587 {
588     PRINT_SPACE
589     if (commaNeeded)
590         _OUT << "\"" << str << "\""
591              << "," << std::endl;
592     else
593         _OUT << "\"" << str << "\"" << std::endl;
594 }
595 
print_VkQueryPool(VkQueryPool obj,const std::string & str,bool commaNeeded=true)596 static void print_VkQueryPool(VkQueryPool obj, const std::string &str, bool commaNeeded = true)
597 {
598     PRINT_SPACE
599     if (commaNeeded)
600         _OUT << "\"" << str << "\""
601              << "," << std::endl;
602     else
603         _OUT << "\"" << str << "\"" << std::endl;
604 }
print_VkQueryPool(const VkQueryPool * obj,const std::string & str,bool commaNeeded=true)605 static void print_VkQueryPool(const VkQueryPool *obj, const std::string &str, bool commaNeeded = true)
606 {
607     PRINT_SPACE
608     if (commaNeeded)
609         _OUT << "\"" << str << "\""
610              << "," << std::endl;
611     else
612         _OUT << "\"" << str << "\"" << std::endl;
613 }
614 
print_VkBufferView(VkBufferView obj,const std::string & str,bool commaNeeded=true)615 static void print_VkBufferView(VkBufferView obj, const std::string &str, bool commaNeeded = true)
616 {
617     PRINT_SPACE
618     if (commaNeeded)
619         _OUT << "\"" << str << "\""
620              << "," << std::endl;
621     else
622         _OUT << "\"" << str << "\"" << std::endl;
623 }
print_VkBufferView(const VkBufferView * obj,const std::string & str,bool commaNeeded=true)624 static void print_VkBufferView(const VkBufferView *obj, const std::string &str, bool commaNeeded = true)
625 {
626     PRINT_SPACE
627     if (commaNeeded)
628         _OUT << "\"" << str << "\""
629              << "," << std::endl;
630     else
631         _OUT << "\"" << str << "\"" << std::endl;
632 }
633 
print_VkImageView(VkImageView obj,const std::string & str,bool commaNeeded=true)634 static void print_VkImageView(VkImageView obj, const std::string &str, bool commaNeeded = true)
635 {
636     PRINT_SPACE
637     if (commaNeeded)
638         _OUT << "\"" << str << "\""
639              << "," << std::endl;
640     else
641         _OUT << "\"" << str << "\"" << std::endl;
642 }
print_VkImageView(const VkImageView * obj,const std::string & str,bool commaNeeded=true)643 static void print_VkImageView(const VkImageView *obj, const std::string &str, bool commaNeeded = true)
644 {
645     PRINT_SPACE
646     if (commaNeeded)
647         _OUT << "\"" << str << "\""
648              << "," << std::endl;
649     else
650         _OUT << "\"" << str << "\"" << std::endl;
651 }
652 
print_VkShaderModule(VkShaderModule obj,const std::string & str,bool commaNeeded=true)653 static void print_VkShaderModule(VkShaderModule obj, const std::string &str, bool commaNeeded = true)
654 {
655     PRINT_SPACE
656     if (commaNeeded)
657         _OUT << "\"" << str << "\""
658              << "," << std::endl;
659     else
660         _OUT << "\"" << str << "\"" << std::endl;
661 }
print_VkShaderModule(const VkShaderModule * obj,const std::string & str,bool commaNeeded=true)662 static void print_VkShaderModule(const VkShaderModule *obj, const std::string &str, bool commaNeeded = true)
663 {
664     PRINT_SPACE
665     if (commaNeeded)
666         _OUT << "\"" << str << "\""
667              << "," << std::endl;
668     else
669         _OUT << "\"" << str << "\"" << std::endl;
670 }
671 
print_VkPipelineCache(VkPipelineCache obj,const std::string & str,bool commaNeeded=true)672 static void print_VkPipelineCache(VkPipelineCache obj, const std::string &str, bool commaNeeded = true)
673 {
674     PRINT_SPACE
675     if (commaNeeded)
676         _OUT << "\"" << str << "\""
677              << "," << std::endl;
678     else
679         _OUT << "\"" << str << "\"" << std::endl;
680 }
print_VkPipelineCache(const VkPipelineCache * obj,const std::string & str,bool commaNeeded=true)681 static void print_VkPipelineCache(const VkPipelineCache *obj, const std::string &str, bool commaNeeded = true)
682 {
683     PRINT_SPACE
684     if (commaNeeded)
685         _OUT << "\"" << str << "\""
686              << "," << std::endl;
687     else
688         _OUT << "\"" << str << "\"" << std::endl;
689 }
690 
print_VkPipelineLayout(VkPipelineLayout obj,const std::string & str,bool commaNeeded=true)691 static void print_VkPipelineLayout(VkPipelineLayout obj, const std::string &str, bool commaNeeded = true)
692 {
693     PRINT_SPACE
694     if (commaNeeded)
695         _OUT << "\"" << str << "\""
696              << "," << std::endl;
697     else
698         _OUT << "\"" << str << "\"" << std::endl;
699 }
print_VkPipelineLayout(const VkPipelineLayout * obj,const std::string & str,bool commaNeeded=true)700 static void print_VkPipelineLayout(const VkPipelineLayout *obj, const std::string &str, bool commaNeeded = true)
701 {
702     PRINT_SPACE
703     if (commaNeeded)
704         _OUT << "\"" << str << "\""
705              << "," << std::endl;
706     else
707         _OUT << "\"" << str << "\"" << std::endl;
708 }
709 
print_VkPipeline(VkPipeline obj,const std::string & str,bool commaNeeded=true)710 static void print_VkPipeline(VkPipeline obj, const std::string &str, bool commaNeeded = true)
711 {
712     PRINT_SPACE
713     if (commaNeeded)
714         _OUT << "\"" << str << "\""
715              << "," << std::endl;
716     else
717         _OUT << "\"" << str << "\"" << std::endl;
718 }
print_VkPipeline(const VkPipeline * obj,const std::string & str,bool commaNeeded=true)719 static void print_VkPipeline(const VkPipeline *obj, const std::string &str, bool commaNeeded = true)
720 {
721     PRINT_SPACE
722     if (commaNeeded)
723         _OUT << "\"" << str << "\""
724              << "," << std::endl;
725     else
726         _OUT << "\"" << str << "\"" << std::endl;
727 }
728 
print_VkRenderPass(VkRenderPass obj,const std::string & str,bool commaNeeded=true)729 static void print_VkRenderPass(VkRenderPass obj, const std::string &str, bool commaNeeded = true)
730 {
731     PRINT_SPACE
732     if (commaNeeded)
733         _OUT << "\"" << str << "\""
734              << "," << std::endl;
735     else
736         _OUT << "\"" << str << "\"" << std::endl;
737 }
print_VkRenderPass(const VkRenderPass * obj,const std::string & str,bool commaNeeded=true)738 static void print_VkRenderPass(const VkRenderPass *obj, const std::string &str, bool commaNeeded = true)
739 {
740     PRINT_SPACE
741     if (commaNeeded)
742         _OUT << "\"" << str << "\""
743              << "," << std::endl;
744     else
745         _OUT << "\"" << str << "\"" << std::endl;
746 }
747 
print_VkDescriptorSetLayout(VkDescriptorSetLayout obj,const std::string & str,bool commaNeeded=true)748 static void print_VkDescriptorSetLayout(VkDescriptorSetLayout obj, const std::string &str, bool commaNeeded = true)
749 {
750     PRINT_SPACE
751     if (commaNeeded)
752         _OUT << "\"" << str << "\""
753              << "," << std::endl;
754     else
755         _OUT << "\"" << str << "\"" << std::endl;
756 }
print_VkDescriptorSetLayout(const VkDescriptorSetLayout * obj,const std::string & str,bool commaNeeded=true)757 static void print_VkDescriptorSetLayout(const VkDescriptorSetLayout *obj, const std::string &str,
758                                         bool commaNeeded = true)
759 {
760     PRINT_SPACE
761     if (commaNeeded)
762         _OUT << "\"" << str << "\""
763              << "," << std::endl;
764     else
765         _OUT << "\"" << str << "\"" << std::endl;
766 }
767 
print_VkSampler(VkSampler obj,const std::string & str,bool commaNeeded=true)768 static void print_VkSampler(VkSampler obj, const std::string &str, bool commaNeeded = true)
769 {
770     PRINT_SPACE
771     if (commaNeeded)
772         _OUT << "\"" << str << "\""
773              << "," << std::endl;
774     else
775         _OUT << "\"" << str << "\"" << std::endl;
776 }
print_VkSampler(const VkSampler * obj,const std::string & str,bool commaNeeded=true)777 static void print_VkSampler(const VkSampler *obj, const std::string &str, bool commaNeeded = true)
778 {
779     PRINT_SPACE
780     if (commaNeeded)
781         _OUT << "\"" << str << "\""
782              << "," << std::endl;
783     else
784         _OUT << "\"" << str << "\"" << std::endl;
785 }
786 
print_VkDescriptorSet(VkDescriptorSet obj,const std::string & str,bool commaNeeded=true)787 static void print_VkDescriptorSet(VkDescriptorSet obj, const std::string &str, bool commaNeeded = true)
788 {
789     PRINT_SPACE
790     if (commaNeeded)
791         _OUT << "\"" << str << "\""
792              << "," << std::endl;
793     else
794         _OUT << "\"" << str << "\"" << std::endl;
795 }
print_VkDescriptorSet(const VkDescriptorSet * obj,const std::string & str,bool commaNeeded=true)796 static void print_VkDescriptorSet(const VkDescriptorSet *obj, const std::string &str, bool commaNeeded = true)
797 {
798     PRINT_SPACE
799     if (commaNeeded)
800         _OUT << "\"" << str << "\""
801              << "," << std::endl;
802     else
803         _OUT << "\"" << str << "\"" << std::endl;
804 }
805 
print_VkDescriptorPool(VkDescriptorPool obj,const std::string & str,bool commaNeeded=true)806 static void print_VkDescriptorPool(VkDescriptorPool obj, const std::string &str, bool commaNeeded = true)
807 {
808     PRINT_SPACE
809     if (commaNeeded)
810         _OUT << "\"" << str << "\""
811              << "," << std::endl;
812     else
813         _OUT << "\"" << str << "\"" << std::endl;
814 }
print_VkDescriptorPool(const VkDescriptorPool * obj,const std::string & str,bool commaNeeded=true)815 static void print_VkDescriptorPool(const VkDescriptorPool *obj, const std::string &str, bool commaNeeded = true)
816 {
817     PRINT_SPACE
818     if (commaNeeded)
819         _OUT << "\"" << str << "\""
820              << "," << std::endl;
821     else
822         _OUT << "\"" << str << "\"" << std::endl;
823 }
824 
print_VkFramebuffer(VkFramebuffer obj,const std::string & str,bool commaNeeded=true)825 static void print_VkFramebuffer(VkFramebuffer obj, const std::string &str, bool commaNeeded = true)
826 {
827     PRINT_SPACE
828     if (commaNeeded)
829         _OUT << "\"" << str << "\""
830              << "," << std::endl;
831     else
832         _OUT << "\"" << str << "\"" << std::endl;
833 }
print_VkFramebuffer(const VkFramebuffer * obj,const std::string & str,bool commaNeeded=true)834 static void print_VkFramebuffer(const VkFramebuffer *obj, const std::string &str, bool commaNeeded = true)
835 {
836     PRINT_SPACE
837     if (commaNeeded)
838         _OUT << "\"" << str << "\""
839              << "," << std::endl;
840     else
841         _OUT << "\"" << str << "\"" << std::endl;
842 }
843 
print_VkCommandPool(VkCommandPool obj,const std::string & str,bool commaNeeded=true)844 static void print_VkCommandPool(VkCommandPool obj, const std::string &str, bool commaNeeded = true)
845 {
846     PRINT_SPACE
847     if (commaNeeded)
848         _OUT << "\"" << str << "\""
849              << "," << std::endl;
850     else
851         _OUT << "\"" << str << "\"" << std::endl;
852 }
print_VkCommandPool(const VkCommandPool * obj,const std::string & str,bool commaNeeded=true)853 static void print_VkCommandPool(const VkCommandPool *obj, const std::string &str, bool commaNeeded = true)
854 {
855     PRINT_SPACE
856     if (commaNeeded)
857         _OUT << "\"" << str << "\""
858              << "," << std::endl;
859     else
860         _OUT << "\"" << str << "\"" << std::endl;
861 }
862 
863 static std::map<uint64_t, std::string> VkResult_map = {
864     std::make_pair(0, "VK_SUCCESS"),
865     std::make_pair(1, "VK_NOT_READY"),
866     std::make_pair(2, "VK_TIMEOUT"),
867     std::make_pair(3, "VK_EVENT_SET"),
868     std::make_pair(4, "VK_EVENT_RESET"),
869     std::make_pair(5, "VK_INCOMPLETE"),
870     std::make_pair(-1, "VK_ERROR_OUT_OF_HOST_MEMORY"),
871     std::make_pair(-2, "VK_ERROR_OUT_OF_DEVICE_MEMORY"),
872     std::make_pair(-3, "VK_ERROR_INITIALIZATION_FAILED"),
873     std::make_pair(-4, "VK_ERROR_DEVICE_LOST"),
874     std::make_pair(-5, "VK_ERROR_MEMORY_MAP_FAILED"),
875     std::make_pair(-6, "VK_ERROR_LAYER_NOT_PRESENT"),
876     std::make_pair(-7, "VK_ERROR_EXTENSION_NOT_PRESENT"),
877     std::make_pair(-8, "VK_ERROR_FEATURE_NOT_PRESENT"),
878     std::make_pair(-9, "VK_ERROR_INCOMPATIBLE_DRIVER"),
879     std::make_pair(-10, "VK_ERROR_TOO_MANY_OBJECTS"),
880     std::make_pair(-11, "VK_ERROR_FORMAT_NOT_SUPPORTED"),
881     std::make_pair(-12, "VK_ERROR_FRAGMENTED_POOL"),
882     std::make_pair(-13, "VK_ERROR_UNKNOWN"),
883     std::make_pair(1000069000, "VK_ERROR_OUT_OF_POOL_MEMORY"),
884     std::make_pair(1000072003, "VK_ERROR_INVALID_EXTERNAL_HANDLE"),
885     std::make_pair(1000161000, "VK_ERROR_FRAGMENTATION"),
886     std::make_pair(1000257000, "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"),
887     std::make_pair(1000011001, "VK_ERROR_VALIDATION_FAILED"),
888     std::make_pair(1000298000, "VK_ERROR_INVALID_PIPELINE_CACHE_DATA"),
889     std::make_pair(1000298001, "VK_ERROR_NO_PIPELINE_MATCH"),
890     std::make_pair(1000000000, "VK_ERROR_SURFACE_LOST_KHR"),
891     std::make_pair(1000000001, "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"),
892     std::make_pair(1000001003, "VK_SUBOPTIMAL_KHR"),
893     std::make_pair(1000001004, "VK_ERROR_OUT_OF_DATE_KHR"),
894     std::make_pair(1000003001, "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"),
895     std::make_pair(1000012000, "VK_ERROR_INVALID_SHADER_NV"),
896     std::make_pair(1000158000, "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"),
897     std::make_pair(1000174001, "VK_ERROR_NOT_PERMITTED_EXT"),
898     std::make_pair(1000255000, "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"),
899     std::make_pair(1000268000, "VK_THREAD_IDLE_KHR"),
900     std::make_pair(1000268001, "VK_THREAD_DONE_KHR"),
901     std::make_pair(1000268002, "VK_OPERATION_DEFERRED_KHR"),
902     std::make_pair(1000268003, "VK_OPERATION_NOT_DEFERRED_KHR"),
903     std::make_pair(1000297000, "VK_PIPELINE_COMPILE_REQUIRED_EXT"),
904 };
print_VkResult(VkResult obj,const std::string & str,bool commaNeeded=true)905 static void print_VkResult(VkResult obj, const std::string &str, bool commaNeeded = true)
906 {
907     PRINT_SPACE
908     if (str != "")
909         _OUT << "\"" << str << "\""
910              << " : ";
911     if (commaNeeded)
912         _OUT << "\"" << VkResult_map[obj] << "\"," << std::endl;
913     else
914         _OUT << "\"" << VkResult_map[obj] << "\"" << std::endl;
915 }
print_VkResult(const VkResult * obj,const std::string & str,bool commaNeeded=true)916 static void print_VkResult(const VkResult *obj, const std::string &str, bool commaNeeded = true)
917 {
918     PRINT_SPACE
919     if (str != "")
920         _OUT << "\"" << str << "\""
921              << " : ";
922     if (commaNeeded)
923         _OUT << "\"" << VkResult_map[*obj] << "\"," << std::endl;
924     else
925         _OUT << "\"" << VkResult_map[*obj] << "\"" << std::endl;
926 }
927 
928 static std::map<uint64_t, std::string> VkStructureType_map = {
929     std::make_pair(0, "VK_STRUCTURE_TYPE_APPLICATION_INFO"),
930     std::make_pair(1, "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO"),
931     std::make_pair(2, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO"),
932     std::make_pair(3, "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO"),
933     std::make_pair(4, "VK_STRUCTURE_TYPE_SUBMIT_INFO"),
934     std::make_pair(5, "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO"),
935     std::make_pair(6, "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE"),
936     std::make_pair(8, "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO"),
937     std::make_pair(9, "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO"),
938     std::make_pair(10, "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO"),
939     std::make_pair(11, "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO"),
940     std::make_pair(12, "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO"),
941     std::make_pair(13, "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO"),
942     std::make_pair(14, "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO"),
943     std::make_pair(15, "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO"),
944     std::make_pair(17, "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO"),
945     std::make_pair(18, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO"),
946     std::make_pair(19, "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO"),
947     std::make_pair(20, "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO"),
948     std::make_pair(21, "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO"),
949     std::make_pair(22, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO"),
950     std::make_pair(23, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO"),
951     std::make_pair(24, "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO"),
952     std::make_pair(25, "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO"),
953     std::make_pair(26, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO"),
954     std::make_pair(27, "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO"),
955     std::make_pair(28, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO"),
956     std::make_pair(29, "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO"),
957     std::make_pair(30, "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO"),
958     std::make_pair(31, "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO"),
959     std::make_pair(32, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO"),
960     std::make_pair(33, "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO"),
961     std::make_pair(34, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO"),
962     std::make_pair(35, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET"),
963     std::make_pair(36, "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET"),
964     std::make_pair(37, "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO"),
965     std::make_pair(38, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO"),
966     std::make_pair(39, "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO"),
967     std::make_pair(40, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO"),
968     std::make_pair(41, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO"),
969     std::make_pair(42, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO"),
970     std::make_pair(43, "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO"),
971     std::make_pair(44, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER"),
972     std::make_pair(45, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER"),
973     std::make_pair(46, "VK_STRUCTURE_TYPE_MEMORY_BARRIER"),
974     std::make_pair(47, "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO"),
975     std::make_pair(48, "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO"),
976     std::make_pair(1000094000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES"),
977     std::make_pair(1000157000, "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO"),
978     std::make_pair(1000157001, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO"),
979     std::make_pair(1000083000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"),
980     std::make_pair(1000127000, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS"),
981     std::make_pair(1000127001, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO"),
982     std::make_pair(1000060000, "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO"),
983     std::make_pair(1000060003, "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"),
984     std::make_pair(1000060004, "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO"),
985     std::make_pair(1000060005, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO"),
986     std::make_pair(1000060013, "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO"),
987     std::make_pair(1000060014, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO"),
988     std::make_pair(1000070000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES"),
989     std::make_pair(1000070001, "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO"),
990     std::make_pair(1000146000, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2"),
991     std::make_pair(1000146001, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2"),
992     std::make_pair(1000146003, "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2"),
993     std::make_pair(1000059000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2"),
994     std::make_pair(1000059001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2"),
995     std::make_pair(1000059002, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2"),
996     std::make_pair(1000059003, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2"),
997     std::make_pair(1000059004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2"),
998     std::make_pair(1000059005, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2"),
999     std::make_pair(1000059006, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2"),
1000     std::make_pair(1000117000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES"),
1001     std::make_pair(1000117001, "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO"),
1002     std::make_pair(1000117002, "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO"),
1003     std::make_pair(1000117003, "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO"),
1004     std::make_pair(1000053000, "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO"),
1005     std::make_pair(1000053001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES"),
1006     std::make_pair(1000053002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES"),
1007     std::make_pair(1000120000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"),
1008     std::make_pair(1000145000, "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO"),
1009     std::make_pair(1000145001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES"),
1010     std::make_pair(1000145002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES"),
1011     std::make_pair(1000145003, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2"),
1012     std::make_pair(1000156000, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO"),
1013     std::make_pair(1000156001, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO"),
1014     std::make_pair(1000156002, "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO"),
1015     std::make_pair(1000156003, "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO"),
1016     std::make_pair(1000156004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES"),
1017     std::make_pair(1000156005, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES"),
1018     std::make_pair(1000071000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO"),
1019     std::make_pair(1000071001, "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES"),
1020     std::make_pair(1000071002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO"),
1021     std::make_pair(1000071003, "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES"),
1022     std::make_pair(1000071004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES"),
1023     std::make_pair(1000072000, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO"),
1024     std::make_pair(1000072001, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO"),
1025     std::make_pair(1000072002, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO"),
1026     std::make_pair(1000112000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO"),
1027     std::make_pair(1000112001, "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES"),
1028     std::make_pair(1000113000, "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO"),
1029     std::make_pair(1000077000, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO"),
1030     std::make_pair(1000076000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"),
1031     std::make_pair(1000076001, "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES"),
1032     std::make_pair(1000168000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES"),
1033     std::make_pair(1000168001, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT"),
1034     std::make_pair(1000063000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES"),
1035     std::make_pair(49, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES"),
1036     std::make_pair(50, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES"),
1037     std::make_pair(51, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES"),
1038     std::make_pair(52, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES"),
1039     std::make_pair(1000147000, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO"),
1040     std::make_pair(1000109000, "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2"),
1041     std::make_pair(1000109001, "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2"),
1042     std::make_pair(1000109002, "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2"),
1043     std::make_pair(1000109003, "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2"),
1044     std::make_pair(1000109004, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2"),
1045     std::make_pair(1000109005, "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO"),
1046     std::make_pair(1000109006, "VK_STRUCTURE_TYPE_SUBPASS_END_INFO"),
1047     std::make_pair(1000177000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"),
1048     std::make_pair(1000196000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES"),
1049     std::make_pair(1000180000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"),
1050     std::make_pair(1000082000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"),
1051     std::make_pair(1000197000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES"),
1052     std::make_pair(1000161000, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO"),
1053     std::make_pair(1000161001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES"),
1054     std::make_pair(1000161002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES"),
1055     std::make_pair(1000161003, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO"),
1056     std::make_pair(1000161004, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT"),
1057     std::make_pair(1000199000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES"),
1058     std::make_pair(1000199001, "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE"),
1059     std::make_pair(1000221000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"),
1060     std::make_pair(1000246000, "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO"),
1061     std::make_pair(1000130000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES"),
1062     std::make_pair(1000130001, "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO"),
1063     std::make_pair(1000211000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"),
1064     std::make_pair(1000108000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES"),
1065     std::make_pair(1000108001, "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO"),
1066     std::make_pair(1000108002, "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"),
1067     std::make_pair(1000108003, "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO"),
1068     std::make_pair(1000253000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES"),
1069     std::make_pair(1000175000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES"),
1070     std::make_pair(1000241000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES"),
1071     std::make_pair(1000241001, "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT"),
1072     std::make_pair(1000241002, "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT"),
1073     std::make_pair(1000261000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"),
1074     std::make_pair(1000207000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"),
1075     std::make_pair(1000207001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES"),
1076     std::make_pair(1000207002, "VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO"),
1077     std::make_pair(1000207003, "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO"),
1078     std::make_pair(1000207004, "VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO"),
1079     std::make_pair(1000207005, "VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO"),
1080     std::make_pair(1000257000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES"),
1081     std::make_pair(1000244001, "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO"),
1082     std::make_pair(1000257002, "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO"),
1083     std::make_pair(1000257003, "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"),
1084     std::make_pair(1000257004, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO"),
1085     std::make_pair(1000298000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES"),
1086     std::make_pair(1000298001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES"),
1087     std::make_pair(1000298002, "VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO"),
1088     std::make_pair(1000298003, "VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO"),
1089     std::make_pair(1000298004, "VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION"),
1090     std::make_pair(1000298005, "VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE"),
1091     std::make_pair(1000298007, "VK_STRUCTURE_TYPE_FAULT_DATA"),
1092     std::make_pair(1000298008, "VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO"),
1093     std::make_pair(1000298010, "VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO"),
1094     std::make_pair(1000001000, "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR"),
1095     std::make_pair(1000001001, "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR"),
1096     std::make_pair(1000060007, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"),
1097     std::make_pair(1000060008, "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR"),
1098     std::make_pair(1000060009, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"),
1099     std::make_pair(1000060010, "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR"),
1100     std::make_pair(1000060011, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR"),
1101     std::make_pair(1000060012, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"),
1102     std::make_pair(1000002000, "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR"),
1103     std::make_pair(1000002001, "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR"),
1104     std::make_pair(1000003000, "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR"),
1105     std::make_pair(1000004000, "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR"),
1106     std::make_pair(1000005000, "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR"),
1107     std::make_pair(1000006000, "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR"),
1108     std::make_pair(1000008000, "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR"),
1109     std::make_pair(1000009000, "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR"),
1110     std::make_pair(1000010000, "VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID"),
1111     std::make_pair(1000010001, "VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID"),
1112     std::make_pair(1000010002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID"),
1113     std::make_pair(1000011000, "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT"),
1114     std::make_pair(1000018000, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD"),
1115     std::make_pair(1000022000, "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT"),
1116     std::make_pair(1000022001, "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT"),
1117     std::make_pair(1000022002, "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT"),
1118     std::make_pair(1000023000, "VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR"),
1119     std::make_pair(1000023001, "VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR"),
1120     std::make_pair(1000023002, "VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR"),
1121     std::make_pair(1000023003, "VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR"),
1122     std::make_pair(1000023004, "VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR"),
1123     std::make_pair(1000023005, "VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR"),
1124     std::make_pair(1000023006, "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR"),
1125     std::make_pair(1000023007, "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR"),
1126     std::make_pair(1000023008, "VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR"),
1127     std::make_pair(1000023009, "VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR"),
1128     std::make_pair(1000023010, "VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR"),
1129     std::make_pair(1000023011, "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR"),
1130     std::make_pair(1000023012, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR"),
1131     std::make_pair(1000023013, "VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR"),
1132     std::make_pair(1000023014, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR"),
1133     std::make_pair(1000023015, "VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR"),
1134     std::make_pair(1000024000, "VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR"),
1135     std::make_pair(1000026000, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV"),
1136     std::make_pair(1000026001, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV"),
1137     std::make_pair(1000026002, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV"),
1138     std::make_pair(1000028000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT"),
1139     std::make_pair(1000028001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT"),
1140     std::make_pair(1000028002, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT"),
1141     std::make_pair(1000029000, "VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX"),
1142     std::make_pair(1000029001, "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX"),
1143     std::make_pair(1000029002, "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX"),
1144     std::make_pair(1000030000, "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX"),
1145     std::make_pair(1000030001, "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"),
1146     std::make_pair(1000038000, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT"),
1147     std::make_pair(1000038001, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT"),
1148     std::make_pair(1000038002, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"),
1149     std::make_pair(1000038003, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"),
1150     std::make_pair(1000038004, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT"),
1151     std::make_pair(1000038005, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT"),
1152     std::make_pair(1000038006, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT"),
1153     std::make_pair(1000038007, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT"),
1154     std::make_pair(1000038008, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT"),
1155     std::make_pair(1000038009, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT"),
1156     std::make_pair(1000038010, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT"),
1157     std::make_pair(1000039000, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT"),
1158     std::make_pair(1000039001, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT"),
1159     std::make_pair(1000039002, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"),
1160     std::make_pair(1000039003, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"),
1161     std::make_pair(1000039004, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT"),
1162     std::make_pair(1000039005, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT"),
1163     std::make_pair(1000039006, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_EXT"),
1164     std::make_pair(1000039007, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT"),
1165     std::make_pair(1000039008, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT"),
1166     std::make_pair(1000039009, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT"),
1167     std::make_pair(1000039010, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT"),
1168     std::make_pair(1000039011, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT"),
1169     std::make_pair(1000040000, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR"),
1170     std::make_pair(1000040001, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT"),
1171     std::make_pair(1000040002, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR"),
1172     std::make_pair(1000040003, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT"),
1173     std::make_pair(1000040004, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT"),
1174     std::make_pair(1000040005, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"),
1175     std::make_pair(1000040006, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR"),
1176     std::make_pair(1000040007, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR"),
1177     std::make_pair(1000041000, "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD"),
1178     std::make_pair(1000044000, "VK_STRUCTURE_TYPE_RENDERING_INFO_KHR"),
1179     std::make_pair(1000044001, "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR"),
1180     std::make_pair(1000044002, "VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR"),
1181     std::make_pair(1000044003, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR"),
1182     std::make_pair(1000044004, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR"),
1183     std::make_pair(1000044006, "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"),
1184     std::make_pair(1000044007, "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT"),
1185     std::make_pair(1000044008, "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD"),
1186     std::make_pair(1000044009, "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX"),
1187     std::make_pair(1000049000, "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP"),
1188     std::make_pair(1000050000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV"),
1189     std::make_pair(1000051000, "VK_STRUCTURE_TYPE_PRIVATE_VENDOR_INFO_RESERVED_OFFSET_0_NV"),
1190     std::make_pair(1000056000, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV"),
1191     std::make_pair(1000056001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV"),
1192     std::make_pair(1000057000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"),
1193     std::make_pair(1000057001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"),
1194     std::make_pair(1000058000, "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV"),
1195     std::make_pair(1000060007, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"),
1196     std::make_pair(1000060008, "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR"),
1197     std::make_pair(1000060009, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"),
1198     std::make_pair(1000060010, "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR"),
1199     std::make_pair(1000060011, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR"),
1200     std::make_pair(1000060012, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"),
1201     std::make_pair(1000061000, "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT"),
1202     std::make_pair(1000062000, "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN"),
1203     std::make_pair(1000066000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT"),
1204     std::make_pair(1000067000, "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT"),
1205     std::make_pair(1000067001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT"),
1206     std::make_pair(1000073000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR"),
1207     std::make_pair(1000073001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR"),
1208     std::make_pair(1000073002, "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR"),
1209     std::make_pair(1000073003, "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR"),
1210     std::make_pair(1000074000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR"),
1211     std::make_pair(1000074001, "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR"),
1212     std::make_pair(1000074002, "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR"),
1213     std::make_pair(1000075000, "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR"),
1214     std::make_pair(1000078000, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"),
1215     std::make_pair(1000078001, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"),
1216     std::make_pair(1000078002, "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR"),
1217     std::make_pair(1000078003, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR"),
1218     std::make_pair(1000079000, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"),
1219     std::make_pair(1000079001, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR"),
1220     std::make_pair(1000080000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"),
1221     std::make_pair(1000081000, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT"),
1222     std::make_pair(1000081001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT"),
1223     std::make_pair(1000081002, "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT"),
1224     std::make_pair(1000084000, "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR"),
1225     std::make_pair(1000087000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV"),
1226     std::make_pair(1000090000, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT"),
1227     std::make_pair(1000091000, "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT"),
1228     std::make_pair(1000091001, "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT"),
1229     std::make_pair(1000091002, "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT"),
1230     std::make_pair(1000091003, "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT"),
1231     std::make_pair(1000092000, "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE"),
1232     std::make_pair(1000097000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"),
1233     std::make_pair(1000098000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV"),
1234     std::make_pair(1000099000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"),
1235     std::make_pair(1000099001, "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT"),
1236     std::make_pair(1000101000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT"),
1237     std::make_pair(1000101001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT"),
1238     std::make_pair(1000102000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT"),
1239     std::make_pair(1000102001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT"),
1240     std::make_pair(1000105000, "VK_STRUCTURE_TYPE_HDR_METADATA_EXT"),
1241     std::make_pair(1000111000, "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR"),
1242     std::make_pair(1000114000, "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"),
1243     std::make_pair(1000114001, "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"),
1244     std::make_pair(1000114002, "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR"),
1245     std::make_pair(1000115000, "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR"),
1246     std::make_pair(1000115001, "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR"),
1247     std::make_pair(1000116000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR"),
1248     std::make_pair(1000116001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR"),
1249     std::make_pair(1000116002, "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR"),
1250     std::make_pair(1000116003, "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR"),
1251     std::make_pair(1000116004, "VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR"),
1252     std::make_pair(1000116005, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR"),
1253     std::make_pair(1000116006, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR"),
1254     std::make_pair(1000116007, "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR"),
1255     std::make_pair(1000119000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"),
1256     std::make_pair(1000119001, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR"),
1257     std::make_pair(1000119002, "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR"),
1258     std::make_pair(1000121000, "VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR"),
1259     std::make_pair(1000121001, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR"),
1260     std::make_pair(1000121002, "VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR"),
1261     std::make_pair(1000121003, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR"),
1262     std::make_pair(1000121004, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR"),
1263     std::make_pair(1000122000, "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK"),
1264     std::make_pair(1000123000, "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK"),
1265     std::make_pair(1000128000, "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT"),
1266     std::make_pair(1000128001, "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT"),
1267     std::make_pair(1000128002, "VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT"),
1268     std::make_pair(1000128003, "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT"),
1269     std::make_pair(1000128004, "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT"),
1270     std::make_pair(1000129000, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID"),
1271     std::make_pair(1000129001, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID"),
1272     std::make_pair(1000129002, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID"),
1273     std::make_pair(1000129003, "VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"),
1274     std::make_pair(1000129004, "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"),
1275     std::make_pair(1000129005, "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID"),
1276     std::make_pair(1000129006, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID"),
1277     std::make_pair(1000138000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT"),
1278     std::make_pair(1000138001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT"),
1279     std::make_pair(1000138002, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT"),
1280     std::make_pair(1000138003, "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT"),
1281     std::make_pair(1000143000, "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT"),
1282     std::make_pair(1000143001, "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT"),
1283     std::make_pair(1000143002, "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT"),
1284     std::make_pair(1000143003, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT"),
1285     std::make_pair(1000143004, "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT"),
1286     std::make_pair(1000148000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT"),
1287     std::make_pair(1000148001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT"),
1288     std::make_pair(1000148002, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT"),
1289     std::make_pair(1000149000, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV"),
1290     std::make_pair(1000150007, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR"),
1291     std::make_pair(1000150000, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR"),
1292     std::make_pair(1000150002, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR"),
1293     std::make_pair(1000150003, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR"),
1294     std::make_pair(1000150004, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR"),
1295     std::make_pair(1000150005, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR"),
1296     std::make_pair(1000150006, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR"),
1297     std::make_pair(1000150009, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR"),
1298     std::make_pair(1000150010, "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR"),
1299     std::make_pair(1000150011, "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR"),
1300     std::make_pair(1000150012, "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR"),
1301     std::make_pair(1000150013, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR"),
1302     std::make_pair(1000150014, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR"),
1303     std::make_pair(1000150017, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR"),
1304     std::make_pair(1000150020, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR"),
1305     std::make_pair(1000347000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR"),
1306     std::make_pair(1000347001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR"),
1307     std::make_pair(1000150015, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR"),
1308     std::make_pair(1000150016, "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR"),
1309     std::make_pair(1000150018, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR"),
1310     std::make_pair(1000348013, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR"),
1311     std::make_pair(1000152000, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV"),
1312     std::make_pair(1000154000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV"),
1313     std::make_pair(1000154001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV"),
1314     std::make_pair(1000158000, "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT"),
1315     std::make_pair(1000158002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT"),
1316     std::make_pair(1000158003, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT"),
1317     std::make_pair(1000158004, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT"),
1318     std::make_pair(1000158005, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT"),
1319     std::make_pair(1000158006, "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT"),
1320     std::make_pair(1000160000, "VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT"),
1321     std::make_pair(1000160001, "VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT"),
1322     std::make_pair(1000163000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR"),
1323     std::make_pair(1000163001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR"),
1324     std::make_pair(1000164000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV"),
1325     std::make_pair(1000164001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV"),
1326     std::make_pair(1000164002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV"),
1327     std::make_pair(1000164005, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV"),
1328     std::make_pair(1000165000, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV"),
1329     std::make_pair(1000165001, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV"),
1330     std::make_pair(1000165003, "VK_STRUCTURE_TYPE_GEOMETRY_NV"),
1331     std::make_pair(1000165004, "VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV"),
1332     std::make_pair(1000165005, "VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV"),
1333     std::make_pair(1000165006, "VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV"),
1334     std::make_pair(1000165007, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV"),
1335     std::make_pair(1000165008, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV"),
1336     std::make_pair(1000165009, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV"),
1337     std::make_pair(1000165011, "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV"),
1338     std::make_pair(1000165012, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV"),
1339     std::make_pair(1000166000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV"),
1340     std::make_pair(1000166001, "VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV"),
1341     std::make_pair(1000170000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT"),
1342     std::make_pair(1000170001, "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT"),
1343     std::make_pair(1000174000, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT"),
1344     std::make_pair(1000178000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT"),
1345     std::make_pair(1000178001, "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT"),
1346     std::make_pair(1000178002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT"),
1347     std::make_pair(1000181000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR"),
1348     std::make_pair(1000183000, "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"),
1349     std::make_pair(1000184000, "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT"),
1350     std::make_pair(1000185000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"),
1351     std::make_pair(1000187000, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT"),
1352     std::make_pair(1000187001, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT"),
1353     std::make_pair(1000187002, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"),
1354     std::make_pair(1000187003, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"),
1355     std::make_pair(1000187004, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT"),
1356     std::make_pair(1000187005, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT"),
1357     std::make_pair(1000187006, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT"),
1358     std::make_pair(1000189000, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD"),
1359     std::make_pair(1000190000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"),
1360     std::make_pair(1000190001, "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT"),
1361     std::make_pair(1000190002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT"),
1362     std::make_pair(1000191000, "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP"),
1363     std::make_pair(1000192000, "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT"),
1364     std::make_pair(1000201000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV"),
1365     std::make_pair(1000202000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV"),
1366     std::make_pair(1000202001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV"),
1367     std::make_pair(1000203000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV"),
1368     std::make_pair(1000204000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV"),
1369     std::make_pair(1000205000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV"),
1370     std::make_pair(1000205002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV"),
1371     std::make_pair(1000206000, "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV"),
1372     std::make_pair(1000206001, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV"),
1373     std::make_pair(1000209000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL"),
1374     std::make_pair(1000210000, "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL"),
1375     std::make_pair(1000210001, "VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL"),
1376     std::make_pair(1000210002, "VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL"),
1377     std::make_pair(1000210003, "VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL"),
1378     std::make_pair(1000210004, "VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL"),
1379     std::make_pair(1000210005, "VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL"),
1380     std::make_pair(1000212000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT"),
1381     std::make_pair(1000213000, "VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD"),
1382     std::make_pair(1000213001, "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD"),
1383     std::make_pair(1000214000, "VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA"),
1384     std::make_pair(1000215000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR"),
1385     std::make_pair(1000217000, "VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT"),
1386     std::make_pair(1000218000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT"),
1387     std::make_pair(1000218001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT"),
1388     std::make_pair(1000218002, "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT"),
1389     std::make_pair(1000225000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT"),
1390     std::make_pair(1000225001, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT"),
1391     std::make_pair(1000225002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT"),
1392     std::make_pair(1000226000, "VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"),
1393     std::make_pair(1000226001, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR"),
1394     std::make_pair(1000226002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR"),
1395     std::make_pair(1000226003, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR"),
1396     std::make_pair(1000226004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR"),
1397     std::make_pair(1000227000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD"),
1398     std::make_pair(1000229000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD"),
1399     std::make_pair(1000234000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT"),
1400     std::make_pair(1000237000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT"),
1401     std::make_pair(1000238000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT"),
1402     std::make_pair(1000238001, "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT"),
1403     std::make_pair(1000239000, "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR"),
1404     std::make_pair(1000240000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV"),
1405     std::make_pair(1000244000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT"),
1406     std::make_pair(1000244002, "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT"),
1407     std::make_pair(1000245000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT"),
1408     std::make_pair(1000247000, "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT"),
1409     std::make_pair(1000248000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR"),
1410     std::make_pair(1000249000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV"),
1411     std::make_pair(1000249001, "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV"),
1412     std::make_pair(1000249002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV"),
1413     std::make_pair(1000250000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV"),
1414     std::make_pair(1000250001, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV"),
1415     std::make_pair(1000250002, "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV"),
1416     std::make_pair(1000251000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT"),
1417     std::make_pair(1000252000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT"),
1418     std::make_pair(1000254000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT"),
1419     std::make_pair(1000254001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT"),
1420     std::make_pair(1000254002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT"),
1421     std::make_pair(1000255000, "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT"),
1422     std::make_pair(1000255002, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT"),
1423     std::make_pair(1000255001, "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT"),
1424     std::make_pair(1000256000, "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT"),
1425     std::make_pair(1000259000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT"),
1426     std::make_pair(1000259001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT"),
1427     std::make_pair(1000259002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT"),
1428     std::make_pair(1000260000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT"),
1429     std::make_pair(1000265000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT"),
1430     std::make_pair(1000267000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT"),
1431     std::make_pair(1000269000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR"),
1432     std::make_pair(1000269001, "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR"),
1433     std::make_pair(1000269002, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR"),
1434     std::make_pair(1000269003, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR"),
1435     std::make_pair(1000269004, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR"),
1436     std::make_pair(1000269005, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR"),
1437     std::make_pair(1000273000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT"),
1438     std::make_pair(1000276000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT"),
1439     std::make_pair(1000277000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV"),
1440     std::make_pair(1000277001, "VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV"),
1441     std::make_pair(1000277002, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV"),
1442     std::make_pair(1000277003, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV"),
1443     std::make_pair(1000277004, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV"),
1444     std::make_pair(1000277005, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV"),
1445     std::make_pair(1000277006, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV"),
1446     std::make_pair(1000277007, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV"),
1447     std::make_pair(1000278000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV"),
1448     std::make_pair(1000278001, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV"),
1449     std::make_pair(1000280000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR"),
1450     std::make_pair(1000280001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR"),
1451     std::make_pair(1000281000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT"),
1452     std::make_pair(1000281001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT"),
1453     std::make_pair(1000282000, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM"),
1454     std::make_pair(1000282001, "VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM"),
1455     std::make_pair(1000284000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT"),
1456     std::make_pair(1000284001, "VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT"),
1457     std::make_pair(1000284002, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT"),
1458     std::make_pair(1000286000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT"),
1459     std::make_pair(1000286001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT"),
1460     std::make_pair(1000287000, "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT"),
1461     std::make_pair(1000287001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT"),
1462     std::make_pair(1000287002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT"),
1463     std::make_pair(1000290000, "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR"),
1464     std::make_pair(1000294000, "VK_STRUCTURE_TYPE_PRESENT_ID_KHR"),
1465     std::make_pair(1000294001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR"),
1466     std::make_pair(1000295000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT"),
1467     std::make_pair(1000295001, "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT"),
1468     std::make_pair(1000295002, "VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT"),
1469     std::make_pair(1000297000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT"),
1470     std::make_pair(1000299000, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR"),
1471     std::make_pair(1000299001, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"),
1472     std::make_pair(1000299002, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR"),
1473     std::make_pair(1000300000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV"),
1474     std::make_pair(1000300001, "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV"),
1475     std::make_pair(1000308000, "VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR"),
1476     std::make_pair(1000309000, "VK_STRUCTURE_TYPE_RESERVED_QCOM"),
1477     std::make_pair(1000314000, "VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR"),
1478     std::make_pair(1000314001, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR"),
1479     std::make_pair(1000314002, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR"),
1480     std::make_pair(1000314003, "VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR"),
1481     std::make_pair(1000314004, "VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR"),
1482     std::make_pair(1000314005, "VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR"),
1483     std::make_pair(1000314006, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR"),
1484     std::make_pair(1000314007, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR"),
1485     std::make_pair(1000314008, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV"),
1486     std::make_pair(1000314009, "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV"),
1487     std::make_pair(1000323000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR"),
1488     std::make_pair(1000325000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR"),
1489     std::make_pair(1000326000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV"),
1490     std::make_pair(1000326001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV"),
1491     std::make_pair(1000326002, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV"),
1492     std::make_pair(1000327000, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV"),
1493     std::make_pair(1000327001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV"),
1494     std::make_pair(1000327002, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV"),
1495     std::make_pair(1000330000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT"),
1496     std::make_pair(1000332000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT"),
1497     std::make_pair(1000332001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT"),
1498     std::make_pair(1000333000, "VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM"),
1499     std::make_pair(1000335000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT"),
1500     std::make_pair(1000336000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR"),
1501     std::make_pair(1000337000, "VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR"),
1502     std::make_pair(1000337001, "VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR"),
1503     std::make_pair(1000337002, "VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR"),
1504     std::make_pair(1000337003, "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR"),
1505     std::make_pair(1000337004, "VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR"),
1506     std::make_pair(1000337005, "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR"),
1507     std::make_pair(1000337006, "VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR"),
1508     std::make_pair(1000337007, "VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR"),
1509     std::make_pair(1000337008, "VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR"),
1510     std::make_pair(1000337009, "VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR"),
1511     std::make_pair(1000337010, "VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR"),
1512     std::make_pair(1000340000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT"),
1513     std::make_pair(1000342000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM"),
1514     std::make_pair(1000344000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT"),
1515     std::make_pair(1000346000, "VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT"),
1516     std::make_pair(1000351000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE"),
1517     std::make_pair(1000351002, "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE"),
1518     std::make_pair(1000352000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT"),
1519     std::make_pair(1000352001, "VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT"),
1520     std::make_pair(1000352002, "VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT"),
1521     std::make_pair(1000353000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"),
1522     std::make_pair(1000355000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT"),
1523     std::make_pair(1000355001, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT"),
1524     std::make_pair(1000356000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT"),
1525     std::make_pair(1000360000, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR"),
1526     std::make_pair(1000364000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA"),
1527     std::make_pair(1000364001, "VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA"),
1528     std::make_pair(1000364002, "VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA"),
1529     std::make_pair(1000365000, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA"),
1530     std::make_pair(1000365001, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA"),
1531     std::make_pair(1000366000, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA"),
1532     std::make_pair(1000366001, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA"),
1533     std::make_pair(1000366002, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA"),
1534     std::make_pair(1000366003, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA"),
1535     std::make_pair(1000366004, "VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA"),
1536     std::make_pair(1000366005, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA"),
1537     std::make_pair(1000366006, "VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA"),
1538     std::make_pair(1000366007, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA"),
1539     std::make_pair(1000366008, "VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA"),
1540     std::make_pair(1000366009, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA"),
1541     std::make_pair(1000369000, "VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI"),
1542     std::make_pair(1000369001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI"),
1543     std::make_pair(1000369002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI"),
1544     std::make_pair(1000370000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI"),
1545     std::make_pair(1000371000, "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV"),
1546     std::make_pair(1000371001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV"),
1547     std::make_pair(1000373000, "VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV"),
1548     std::make_pair(1000373001, "VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV"),
1549     std::make_pair(1000373002, "VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV"),
1550     std::make_pair(1000373003, "VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV"),
1551     std::make_pair(1000373004, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_SCI_SYNC_INFO_NV"),
1552     std::make_pair(1000373005, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV"),
1553     std::make_pair(1000373006, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_SCI_SYNC_INFO_NV"),
1554     std::make_pair(1000373007, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV"),
1555     std::make_pair(1000374000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_SCI_BUF_INFO_NV"),
1556     std::make_pair(1000374001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_SCI_BUF_INFO_NV"),
1557     std::make_pair(1000374002, "VK_STRUCTURE_TYPE_MEMORY_GET_SCI_BUF_INFO_NV"),
1558     std::make_pair(1000374003, "VK_STRUCTURE_TYPE_MEMORY_SCI_BUF_PROPERTIES_NV"),
1559     std::make_pair(1000374004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV"),
1560     std::make_pair(1000377000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT"),
1561     std::make_pair(1000378000, "VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX"),
1562     std::make_pair(1000381000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT"),
1563     std::make_pair(1000381001, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT"),
1564     std::make_pair(1000388000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT"),
1565     std::make_pair(1000388001, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT"),
1566     std::make_pair(1000391000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT"),
1567     std::make_pair(1000391001, "VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT"),
1568     std::make_pair(1000392000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT"),
1569     std::make_pair(1000392001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT"),
1570     std::make_pair(1000411000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT"),
1571     std::make_pair(1000411001, "VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT"),
1572     std::make_pair(1000412000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT"),
1573     std::make_pair(1000413000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR"),
1574     std::make_pair(1000413001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR"),
1575     std::make_pair(1000413002, "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR"),
1576     std::make_pair(1000413003, "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR"),
1577     std::make_pair(1000435000, "VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT"),
1578     std::make_pair(1000489000, "VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_POOL_CREATE_INFO_NV"),
1579     std::make_pair(1000489001, "VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_CREATE_INFO_NV"),
1580     std::make_pair(1000489002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV"),
1581     std::make_pair(1000373000, "VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV"),
1582     std::make_pair(1000373001, "VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV"),
1583     std::make_pair(1000373002, "VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV"),
1584     std::make_pair(1000373003, "VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV"),
1585     std::make_pair(1000489003, "VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV"),
1586 };
print_VkStructureType(VkStructureType obj,const std::string & str,bool commaNeeded=true)1587 static void print_VkStructureType(VkStructureType obj, const std::string &str, bool commaNeeded = true)
1588 {
1589     PRINT_SPACE
1590     if (str != "")
1591         _OUT << "\"" << str << "\""
1592              << " : ";
1593     if (commaNeeded)
1594         _OUT << "\"" << VkStructureType_map[obj] << "\"," << std::endl;
1595     else
1596         _OUT << "\"" << VkStructureType_map[obj] << "\"" << std::endl;
1597 }
print_VkStructureType(const VkStructureType * obj,const std::string & str,bool commaNeeded=true)1598 static void print_VkStructureType(const VkStructureType *obj, const std::string &str, bool commaNeeded = true)
1599 {
1600     PRINT_SPACE
1601     if (str != "")
1602         _OUT << "\"" << str << "\""
1603              << " : ";
1604     if (commaNeeded)
1605         _OUT << "\"" << VkStructureType_map[*obj] << "\"," << std::endl;
1606     else
1607         _OUT << "\"" << VkStructureType_map[*obj] << "\"" << std::endl;
1608 }
1609 
1610 static std::map<uint64_t, std::string> VkAccessFlagBits_map = {
1611     std::make_pair(1ULL << 0, "VK_ACCESS_INDIRECT_COMMAND_READ_BIT"),
1612     std::make_pair(1ULL << 1, "VK_ACCESS_INDEX_READ_BIT"),
1613     std::make_pair(1ULL << 2, "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT"),
1614     std::make_pair(1ULL << 3, "VK_ACCESS_UNIFORM_READ_BIT"),
1615     std::make_pair(1ULL << 4, "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT"),
1616     std::make_pair(1ULL << 5, "VK_ACCESS_SHADER_READ_BIT"),
1617     std::make_pair(1ULL << 6, "VK_ACCESS_SHADER_WRITE_BIT"),
1618     std::make_pair(1ULL << 7, "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT"),
1619     std::make_pair(1ULL << 8, "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT"),
1620     std::make_pair(1ULL << 9, "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT"),
1621     std::make_pair(1ULL << 10, "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT"),
1622     std::make_pair(1ULL << 11, "VK_ACCESS_TRANSFER_READ_BIT"),
1623     std::make_pair(1ULL << 12, "VK_ACCESS_TRANSFER_WRITE_BIT"),
1624     std::make_pair(1ULL << 13, "VK_ACCESS_HOST_READ_BIT"),
1625     std::make_pair(1ULL << 14, "VK_ACCESS_HOST_WRITE_BIT"),
1626     std::make_pair(1ULL << 15, "VK_ACCESS_MEMORY_READ_BIT"),
1627     std::make_pair(1ULL << 16, "VK_ACCESS_MEMORY_WRITE_BIT"),
1628     std::make_pair(1ULL << 25, "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"),
1629     std::make_pair(1ULL << 26, "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"),
1630     std::make_pair(1ULL << 27, "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"),
1631     std::make_pair(1ULL << 20, "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT"),
1632     std::make_pair(1ULL << 19, "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"),
1633     std::make_pair(1ULL << 21, "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR"),
1634     std::make_pair(1ULL << 22, "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"),
1635     std::make_pair(1ULL << 24, "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"),
1636     std::make_pair(1ULL << 23, "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"),
1637     std::make_pair(1ULL << 17, "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV"),
1638     std::make_pair(1ULL << 18, "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV"),
1639     std::make_pair(0, "VK_ACCESS_NONE_KHR"),
1640 };
print_VkAccessFlagBits(VkAccessFlagBits obj,const std::string & str,bool commaNeeded=true)1641 static void print_VkAccessFlagBits(VkAccessFlagBits obj, const std::string &str, bool commaNeeded = true)
1642 {
1643     PRINT_SPACE
1644     if (str != "")
1645         _OUT << "\"" << str << "\""
1646              << " : ";
1647     if (commaNeeded)
1648         _OUT << "\"" << VkAccessFlagBits_map[obj] << "\"," << std::endl;
1649     else
1650         _OUT << "\"" << VkAccessFlagBits_map[obj] << "\"" << std::endl;
1651 }
print_VkAccessFlagBits(const VkAccessFlagBits * obj,const std::string & str,bool commaNeeded=true)1652 static void print_VkAccessFlagBits(const VkAccessFlagBits *obj, const std::string &str, bool commaNeeded = true)
1653 {
1654     PRINT_SPACE
1655     if (str != "")
1656         _OUT << "\"" << str << "\""
1657              << " : ";
1658     if (commaNeeded)
1659         _OUT << "\"" << VkAccessFlagBits_map[*obj] << "\"," << std::endl;
1660     else
1661         _OUT << "\"" << VkAccessFlagBits_map[*obj] << "\"" << std::endl;
1662 }
1663 
1664 static std::map<uint64_t, std::string> VkImageLayout_map = {
1665     std::make_pair(0, "VK_IMAGE_LAYOUT_UNDEFINED"),
1666     std::make_pair(1, "VK_IMAGE_LAYOUT_GENERAL"),
1667     std::make_pair(2, "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL"),
1668     std::make_pair(3, "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL"),
1669     std::make_pair(4, "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL"),
1670     std::make_pair(5, "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL"),
1671     std::make_pair(6, "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL"),
1672     std::make_pair(7, "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL"),
1673     std::make_pair(8, "VK_IMAGE_LAYOUT_PREINITIALIZED"),
1674     std::make_pair(1000117000, "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"),
1675     std::make_pair(1000117001, "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"),
1676     std::make_pair(1000241000, "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL"),
1677     std::make_pair(1000241001, "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL"),
1678     std::make_pair(1000241002, "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL"),
1679     std::make_pair(1000241003, "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL"),
1680     std::make_pair(1000001002, "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR"),
1681     std::make_pair(1000024000, "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR"),
1682     std::make_pair(1000024001, "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR"),
1683     std::make_pair(1000024002, "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR"),
1684     std::make_pair(1000111000, "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR"),
1685     std::make_pair(1000218000, "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"),
1686     std::make_pair(1000164003, "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR"),
1687     std::make_pair(1000299000, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR"),
1688     std::make_pair(1000299001, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR"),
1689     std::make_pair(1000299002, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR"),
1690     std::make_pair(1000314000, "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR"),
1691     std::make_pair(1000314001, "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR"),
1692 };
print_VkImageLayout(VkImageLayout obj,const std::string & str,bool commaNeeded=true)1693 static void print_VkImageLayout(VkImageLayout obj, const std::string &str, bool commaNeeded = true)
1694 {
1695     PRINT_SPACE
1696     if (str != "")
1697         _OUT << "\"" << str << "\""
1698              << " : ";
1699     if (commaNeeded)
1700         _OUT << "\"" << VkImageLayout_map[obj] << "\"," << std::endl;
1701     else
1702         _OUT << "\"" << VkImageLayout_map[obj] << "\"" << std::endl;
1703 }
print_VkImageLayout(const VkImageLayout * obj,const std::string & str,bool commaNeeded=true)1704 static void print_VkImageLayout(const VkImageLayout *obj, const std::string &str, bool commaNeeded = true)
1705 {
1706     PRINT_SPACE
1707     if (str != "")
1708         _OUT << "\"" << str << "\""
1709              << " : ";
1710     if (commaNeeded)
1711         _OUT << "\"" << VkImageLayout_map[*obj] << "\"," << std::endl;
1712     else
1713         _OUT << "\"" << VkImageLayout_map[*obj] << "\"" << std::endl;
1714 }
1715 
1716 static std::map<uint64_t, std::string> VkImageAspectFlagBits_map = {
1717     std::make_pair(1ULL << 0, "VK_IMAGE_ASPECT_COLOR_BIT"),
1718     std::make_pair(1ULL << 1, "VK_IMAGE_ASPECT_DEPTH_BIT"),
1719     std::make_pair(1ULL << 2, "VK_IMAGE_ASPECT_STENCIL_BIT"),
1720     std::make_pair(1ULL << 3, "VK_IMAGE_ASPECT_METADATA_BIT"),
1721     std::make_pair(1ULL << 4, "VK_IMAGE_ASPECT_PLANE_0_BIT"),
1722     std::make_pair(1ULL << 5, "VK_IMAGE_ASPECT_PLANE_1_BIT"),
1723     std::make_pair(1ULL << 6, "VK_IMAGE_ASPECT_PLANE_2_BIT"),
1724     std::make_pair(1ULL << 7, "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT"),
1725     std::make_pair(1ULL << 8, "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT"),
1726     std::make_pair(1ULL << 9, "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT"),
1727     std::make_pair(1ULL << 10, "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT"),
1728     std::make_pair(0, "VK_IMAGE_ASPECT_NONE_KHR"),
1729 };
print_VkImageAspectFlagBits(VkImageAspectFlagBits obj,const std::string & str,bool commaNeeded=true)1730 static void print_VkImageAspectFlagBits(VkImageAspectFlagBits obj, const std::string &str, bool commaNeeded = true)
1731 {
1732     PRINT_SPACE
1733     if (str != "")
1734         _OUT << "\"" << str << "\""
1735              << " : ";
1736     if (commaNeeded)
1737         _OUT << "\"" << VkImageAspectFlagBits_map[obj] << "\"," << std::endl;
1738     else
1739         _OUT << "\"" << VkImageAspectFlagBits_map[obj] << "\"" << std::endl;
1740 }
print_VkImageAspectFlagBits(const VkImageAspectFlagBits * obj,const std::string & str,bool commaNeeded=true)1741 static void print_VkImageAspectFlagBits(const VkImageAspectFlagBits *obj, const std::string &str,
1742                                         bool commaNeeded = true)
1743 {
1744     PRINT_SPACE
1745     if (str != "")
1746         _OUT << "\"" << str << "\""
1747              << " : ";
1748     if (commaNeeded)
1749         _OUT << "\"" << VkImageAspectFlagBits_map[*obj] << "\"," << std::endl;
1750     else
1751         _OUT << "\"" << VkImageAspectFlagBits_map[*obj] << "\"" << std::endl;
1752 }
1753 
1754 static std::map<uint64_t, std::string> VkObjectType_map = {
1755     std::make_pair(0, "VK_OBJECT_TYPE_UNKNOWN"),
1756     std::make_pair(1, "VK_OBJECT_TYPE_INSTANCE"),
1757     std::make_pair(2, "VK_OBJECT_TYPE_PHYSICAL_DEVICE"),
1758     std::make_pair(3, "VK_OBJECT_TYPE_DEVICE"),
1759     std::make_pair(4, "VK_OBJECT_TYPE_QUEUE"),
1760     std::make_pair(5, "VK_OBJECT_TYPE_SEMAPHORE"),
1761     std::make_pair(6, "VK_OBJECT_TYPE_COMMAND_BUFFER"),
1762     std::make_pair(7, "VK_OBJECT_TYPE_FENCE"),
1763     std::make_pair(8, "VK_OBJECT_TYPE_DEVICE_MEMORY"),
1764     std::make_pair(9, "VK_OBJECT_TYPE_BUFFER"),
1765     std::make_pair(10, "VK_OBJECT_TYPE_IMAGE"),
1766     std::make_pair(11, "VK_OBJECT_TYPE_EVENT"),
1767     std::make_pair(12, "VK_OBJECT_TYPE_QUERY_POOL"),
1768     std::make_pair(13, "VK_OBJECT_TYPE_BUFFER_VIEW"),
1769     std::make_pair(14, "VK_OBJECT_TYPE_IMAGE_VIEW"),
1770     std::make_pair(15, "VK_OBJECT_TYPE_SHADER_MODULE"),
1771     std::make_pair(16, "VK_OBJECT_TYPE_PIPELINE_CACHE"),
1772     std::make_pair(17, "VK_OBJECT_TYPE_PIPELINE_LAYOUT"),
1773     std::make_pair(18, "VK_OBJECT_TYPE_RENDER_PASS"),
1774     std::make_pair(19, "VK_OBJECT_TYPE_PIPELINE"),
1775     std::make_pair(20, "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT"),
1776     std::make_pair(21, "VK_OBJECT_TYPE_SAMPLER"),
1777     std::make_pair(22, "VK_OBJECT_TYPE_DESCRIPTOR_POOL"),
1778     std::make_pair(23, "VK_OBJECT_TYPE_DESCRIPTOR_SET"),
1779     std::make_pair(24, "VK_OBJECT_TYPE_FRAMEBUFFER"),
1780     std::make_pair(25, "VK_OBJECT_TYPE_COMMAND_POOL"),
1781     std::make_pair(1000156000, "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION"),
1782     std::make_pair(1000000000, "VK_OBJECT_TYPE_SURFACE_KHR"),
1783     std::make_pair(1000001000, "VK_OBJECT_TYPE_SWAPCHAIN_KHR"),
1784     std::make_pair(1000002000, "VK_OBJECT_TYPE_DISPLAY_KHR"),
1785     std::make_pair(1000002001, "VK_OBJECT_TYPE_DISPLAY_MODE_KHR"),
1786     std::make_pair(1000011000, "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT"),
1787     std::make_pair(1000023000, "VK_OBJECT_TYPE_VIDEO_SESSION_KHR"),
1788     std::make_pair(1000023001, "VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR"),
1789     std::make_pair(1000029000, "VK_OBJECT_TYPE_CU_MODULE_NVX"),
1790     std::make_pair(1000029001, "VK_OBJECT_TYPE_CU_FUNCTION_NVX"),
1791     std::make_pair(1000128000, "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT"),
1792     std::make_pair(1000150000, "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR"),
1793     std::make_pair(1000160000, "VK_OBJECT_TYPE_VALIDATION_CACHE_EXT"),
1794     std::make_pair(1000165000, "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV"),
1795     std::make_pair(1000210000, "VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL"),
1796     std::make_pair(1000268000, "VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR"),
1797     std::make_pair(1000277000, "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV"),
1798     std::make_pair(1000295000, "VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT"),
1799     std::make_pair(1000366000, "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA"),
1800     std::make_pair(1000489000, "VK_OBJECT_TYPE_SEMAPHORE_SCI_SYNC_POOL_NV"),
1801 };
print_VkObjectType(VkObjectType obj,const std::string & str,bool commaNeeded=true)1802 static void print_VkObjectType(VkObjectType obj, const std::string &str, bool commaNeeded = true)
1803 {
1804     PRINT_SPACE
1805     if (str != "")
1806         _OUT << "\"" << str << "\""
1807              << " : ";
1808     if (commaNeeded)
1809         _OUT << "\"" << VkObjectType_map[obj] << "\"," << std::endl;
1810     else
1811         _OUT << "\"" << VkObjectType_map[obj] << "\"" << std::endl;
1812 }
print_VkObjectType(const VkObjectType * obj,const std::string & str,bool commaNeeded=true)1813 static void print_VkObjectType(const VkObjectType *obj, const std::string &str, bool commaNeeded = true)
1814 {
1815     PRINT_SPACE
1816     if (str != "")
1817         _OUT << "\"" << str << "\""
1818              << " : ";
1819     if (commaNeeded)
1820         _OUT << "\"" << VkObjectType_map[*obj] << "\"," << std::endl;
1821     else
1822         _OUT << "\"" << VkObjectType_map[*obj] << "\"" << std::endl;
1823 }
1824 
1825 static std::map<uint64_t, std::string> VkPipelineCacheHeaderVersion_map = {
1826     std::make_pair(1, "VK_PIPELINE_CACHE_HEADER_VERSION_ONE"),
1827     std::make_pair(1000298001, "VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE"),
1828 };
print_VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion obj,const std::string & str,bool commaNeeded=true)1829 static void print_VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion obj, const std::string &str,
1830                                                bool commaNeeded = true)
1831 {
1832     PRINT_SPACE
1833     if (str != "")
1834         _OUT << "\"" << str << "\""
1835              << " : ";
1836     if (commaNeeded)
1837         _OUT << "\"" << VkPipelineCacheHeaderVersion_map[obj] << "\"," << std::endl;
1838     else
1839         _OUT << "\"" << VkPipelineCacheHeaderVersion_map[obj] << "\"" << std::endl;
1840 }
print_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion * obj,const std::string & str,bool commaNeeded=true)1841 static void print_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion *obj, const std::string &str,
1842                                                bool commaNeeded = true)
1843 {
1844     PRINT_SPACE
1845     if (str != "")
1846         _OUT << "\"" << str << "\""
1847              << " : ";
1848     if (commaNeeded)
1849         _OUT << "\"" << VkPipelineCacheHeaderVersion_map[*obj] << "\"," << std::endl;
1850     else
1851         _OUT << "\"" << VkPipelineCacheHeaderVersion_map[*obj] << "\"" << std::endl;
1852 }
1853 
1854 static std::map<uint64_t, std::string> VkVendorId_map = {
1855     std::make_pair(0x10001, "VK_VENDOR_ID_VIV"),   std::make_pair(0x10002, "VK_VENDOR_ID_VSI"),
1856     std::make_pair(0x10003, "VK_VENDOR_ID_KAZAN"), std::make_pair(0x10004, "VK_VENDOR_ID_CODEPLAY"),
1857     std::make_pair(0x10005, "VK_VENDOR_ID_MESA"),  std::make_pair(0x10006, "VK_VENDOR_ID_POCL"),
1858 };
print_VkVendorId(VkVendorId obj,const std::string & str,bool commaNeeded=true)1859 static void print_VkVendorId(VkVendorId obj, const std::string &str, bool commaNeeded = true)
1860 {
1861     PRINT_SPACE
1862     if (str != "")
1863         _OUT << "\"" << str << "\""
1864              << " : ";
1865     if (commaNeeded)
1866         _OUT << "\"" << VkVendorId_map[obj] << "\"," << std::endl;
1867     else
1868         _OUT << "\"" << VkVendorId_map[obj] << "\"" << std::endl;
1869 }
print_VkVendorId(const VkVendorId * obj,const std::string & str,bool commaNeeded=true)1870 static void print_VkVendorId(const VkVendorId *obj, const std::string &str, bool commaNeeded = true)
1871 {
1872     PRINT_SPACE
1873     if (str != "")
1874         _OUT << "\"" << str << "\""
1875              << " : ";
1876     if (commaNeeded)
1877         _OUT << "\"" << VkVendorId_map[*obj] << "\"," << std::endl;
1878     else
1879         _OUT << "\"" << VkVendorId_map[*obj] << "\"" << std::endl;
1880 }
1881 
1882 static std::map<uint64_t, std::string> VkSystemAllocationScope_map = {
1883     std::make_pair(0, "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND"),  std::make_pair(1, "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT"),
1884     std::make_pair(2, "VK_SYSTEM_ALLOCATION_SCOPE_CACHE"),    std::make_pair(3, "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE"),
1885     std::make_pair(4, "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE"),
1886 };
print_VkSystemAllocationScope(VkSystemAllocationScope obj,const std::string & str,bool commaNeeded=true)1887 static void print_VkSystemAllocationScope(VkSystemAllocationScope obj, const std::string &str, bool commaNeeded = true)
1888 {
1889     PRINT_SPACE
1890     if (str != "")
1891         _OUT << "\"" << str << "\""
1892              << " : ";
1893     if (commaNeeded)
1894         _OUT << "\"" << VkSystemAllocationScope_map[obj] << "\"," << std::endl;
1895     else
1896         _OUT << "\"" << VkSystemAllocationScope_map[obj] << "\"" << std::endl;
1897 }
print_VkSystemAllocationScope(const VkSystemAllocationScope * obj,const std::string & str,bool commaNeeded=true)1898 static void print_VkSystemAllocationScope(const VkSystemAllocationScope *obj, const std::string &str,
1899                                           bool commaNeeded = true)
1900 {
1901     PRINT_SPACE
1902     if (str != "")
1903         _OUT << "\"" << str << "\""
1904              << " : ";
1905     if (commaNeeded)
1906         _OUT << "\"" << VkSystemAllocationScope_map[*obj] << "\"," << std::endl;
1907     else
1908         _OUT << "\"" << VkSystemAllocationScope_map[*obj] << "\"" << std::endl;
1909 }
1910 
1911 static std::map<uint64_t, std::string> VkInternalAllocationType_map = {
1912     std::make_pair(0, "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE"),
1913 };
print_VkInternalAllocationType(VkInternalAllocationType obj,const std::string & str,bool commaNeeded=true)1914 static void print_VkInternalAllocationType(VkInternalAllocationType obj, const std::string &str,
1915                                            bool commaNeeded = true)
1916 {
1917     PRINT_SPACE
1918     if (str != "")
1919         _OUT << "\"" << str << "\""
1920              << " : ";
1921     if (commaNeeded)
1922         _OUT << "\"" << VkInternalAllocationType_map[obj] << "\"," << std::endl;
1923     else
1924         _OUT << "\"" << VkInternalAllocationType_map[obj] << "\"" << std::endl;
1925 }
print_VkInternalAllocationType(const VkInternalAllocationType * obj,const std::string & str,bool commaNeeded=true)1926 static void print_VkInternalAllocationType(const VkInternalAllocationType *obj, const std::string &str,
1927                                            bool commaNeeded = true)
1928 {
1929     PRINT_SPACE
1930     if (str != "")
1931         _OUT << "\"" << str << "\""
1932              << " : ";
1933     if (commaNeeded)
1934         _OUT << "\"" << VkInternalAllocationType_map[*obj] << "\"," << std::endl;
1935     else
1936         _OUT << "\"" << VkInternalAllocationType_map[*obj] << "\"" << std::endl;
1937 }
1938 
1939 static std::map<uint64_t, std::string> VkFormat_map = {
1940     std::make_pair(0, "VK_FORMAT_UNDEFINED"),
1941     std::make_pair(1, "VK_FORMAT_R4G4_UNORM_PACK8"),
1942     std::make_pair(2, "VK_FORMAT_R4G4B4A4_UNORM_PACK16"),
1943     std::make_pair(3, "VK_FORMAT_B4G4R4A4_UNORM_PACK16"),
1944     std::make_pair(4, "VK_FORMAT_R5G6B5_UNORM_PACK16"),
1945     std::make_pair(5, "VK_FORMAT_B5G6R5_UNORM_PACK16"),
1946     std::make_pair(6, "VK_FORMAT_R5G5B5A1_UNORM_PACK16"),
1947     std::make_pair(7, "VK_FORMAT_B5G5R5A1_UNORM_PACK16"),
1948     std::make_pair(8, "VK_FORMAT_A1R5G5B5_UNORM_PACK16"),
1949     std::make_pair(9, "VK_FORMAT_R8_UNORM"),
1950     std::make_pair(10, "VK_FORMAT_R8_SNORM"),
1951     std::make_pair(11, "VK_FORMAT_R8_USCALED"),
1952     std::make_pair(12, "VK_FORMAT_R8_SSCALED"),
1953     std::make_pair(13, "VK_FORMAT_R8_UINT"),
1954     std::make_pair(14, "VK_FORMAT_R8_SINT"),
1955     std::make_pair(15, "VK_FORMAT_R8_SRGB"),
1956     std::make_pair(16, "VK_FORMAT_R8G8_UNORM"),
1957     std::make_pair(17, "VK_FORMAT_R8G8_SNORM"),
1958     std::make_pair(18, "VK_FORMAT_R8G8_USCALED"),
1959     std::make_pair(19, "VK_FORMAT_R8G8_SSCALED"),
1960     std::make_pair(20, "VK_FORMAT_R8G8_UINT"),
1961     std::make_pair(21, "VK_FORMAT_R8G8_SINT"),
1962     std::make_pair(22, "VK_FORMAT_R8G8_SRGB"),
1963     std::make_pair(23, "VK_FORMAT_R8G8B8_UNORM"),
1964     std::make_pair(24, "VK_FORMAT_R8G8B8_SNORM"),
1965     std::make_pair(25, "VK_FORMAT_R8G8B8_USCALED"),
1966     std::make_pair(26, "VK_FORMAT_R8G8B8_SSCALED"),
1967     std::make_pair(27, "VK_FORMAT_R8G8B8_UINT"),
1968     std::make_pair(28, "VK_FORMAT_R8G8B8_SINT"),
1969     std::make_pair(29, "VK_FORMAT_R8G8B8_SRGB"),
1970     std::make_pair(30, "VK_FORMAT_B8G8R8_UNORM"),
1971     std::make_pair(31, "VK_FORMAT_B8G8R8_SNORM"),
1972     std::make_pair(32, "VK_FORMAT_B8G8R8_USCALED"),
1973     std::make_pair(33, "VK_FORMAT_B8G8R8_SSCALED"),
1974     std::make_pair(34, "VK_FORMAT_B8G8R8_UINT"),
1975     std::make_pair(35, "VK_FORMAT_B8G8R8_SINT"),
1976     std::make_pair(36, "VK_FORMAT_B8G8R8_SRGB"),
1977     std::make_pair(37, "VK_FORMAT_R8G8B8A8_UNORM"),
1978     std::make_pair(38, "VK_FORMAT_R8G8B8A8_SNORM"),
1979     std::make_pair(39, "VK_FORMAT_R8G8B8A8_USCALED"),
1980     std::make_pair(40, "VK_FORMAT_R8G8B8A8_SSCALED"),
1981     std::make_pair(41, "VK_FORMAT_R8G8B8A8_UINT"),
1982     std::make_pair(42, "VK_FORMAT_R8G8B8A8_SINT"),
1983     std::make_pair(43, "VK_FORMAT_R8G8B8A8_SRGB"),
1984     std::make_pair(44, "VK_FORMAT_B8G8R8A8_UNORM"),
1985     std::make_pair(45, "VK_FORMAT_B8G8R8A8_SNORM"),
1986     std::make_pair(46, "VK_FORMAT_B8G8R8A8_USCALED"),
1987     std::make_pair(47, "VK_FORMAT_B8G8R8A8_SSCALED"),
1988     std::make_pair(48, "VK_FORMAT_B8G8R8A8_UINT"),
1989     std::make_pair(49, "VK_FORMAT_B8G8R8A8_SINT"),
1990     std::make_pair(50, "VK_FORMAT_B8G8R8A8_SRGB"),
1991     std::make_pair(51, "VK_FORMAT_A8B8G8R8_UNORM_PACK32"),
1992     std::make_pair(52, "VK_FORMAT_A8B8G8R8_SNORM_PACK32"),
1993     std::make_pair(53, "VK_FORMAT_A8B8G8R8_USCALED_PACK32"),
1994     std::make_pair(54, "VK_FORMAT_A8B8G8R8_SSCALED_PACK32"),
1995     std::make_pair(55, "VK_FORMAT_A8B8G8R8_UINT_PACK32"),
1996     std::make_pair(56, "VK_FORMAT_A8B8G8R8_SINT_PACK32"),
1997     std::make_pair(57, "VK_FORMAT_A8B8G8R8_SRGB_PACK32"),
1998     std::make_pair(58, "VK_FORMAT_A2R10G10B10_UNORM_PACK32"),
1999     std::make_pair(59, "VK_FORMAT_A2R10G10B10_SNORM_PACK32"),
2000     std::make_pair(60, "VK_FORMAT_A2R10G10B10_USCALED_PACK32"),
2001     std::make_pair(61, "VK_FORMAT_A2R10G10B10_SSCALED_PACK32"),
2002     std::make_pair(62, "VK_FORMAT_A2R10G10B10_UINT_PACK32"),
2003     std::make_pair(63, "VK_FORMAT_A2R10G10B10_SINT_PACK32"),
2004     std::make_pair(64, "VK_FORMAT_A2B10G10R10_UNORM_PACK32"),
2005     std::make_pair(65, "VK_FORMAT_A2B10G10R10_SNORM_PACK32"),
2006     std::make_pair(66, "VK_FORMAT_A2B10G10R10_USCALED_PACK32"),
2007     std::make_pair(67, "VK_FORMAT_A2B10G10R10_SSCALED_PACK32"),
2008     std::make_pair(68, "VK_FORMAT_A2B10G10R10_UINT_PACK32"),
2009     std::make_pair(69, "VK_FORMAT_A2B10G10R10_SINT_PACK32"),
2010     std::make_pair(70, "VK_FORMAT_R16_UNORM"),
2011     std::make_pair(71, "VK_FORMAT_R16_SNORM"),
2012     std::make_pair(72, "VK_FORMAT_R16_USCALED"),
2013     std::make_pair(73, "VK_FORMAT_R16_SSCALED"),
2014     std::make_pair(74, "VK_FORMAT_R16_UINT"),
2015     std::make_pair(75, "VK_FORMAT_R16_SINT"),
2016     std::make_pair(76, "VK_FORMAT_R16_SFLOAT"),
2017     std::make_pair(77, "VK_FORMAT_R16G16_UNORM"),
2018     std::make_pair(78, "VK_FORMAT_R16G16_SNORM"),
2019     std::make_pair(79, "VK_FORMAT_R16G16_USCALED"),
2020     std::make_pair(80, "VK_FORMAT_R16G16_SSCALED"),
2021     std::make_pair(81, "VK_FORMAT_R16G16_UINT"),
2022     std::make_pair(82, "VK_FORMAT_R16G16_SINT"),
2023     std::make_pair(83, "VK_FORMAT_R16G16_SFLOAT"),
2024     std::make_pair(84, "VK_FORMAT_R16G16B16_UNORM"),
2025     std::make_pair(85, "VK_FORMAT_R16G16B16_SNORM"),
2026     std::make_pair(86, "VK_FORMAT_R16G16B16_USCALED"),
2027     std::make_pair(87, "VK_FORMAT_R16G16B16_SSCALED"),
2028     std::make_pair(88, "VK_FORMAT_R16G16B16_UINT"),
2029     std::make_pair(89, "VK_FORMAT_R16G16B16_SINT"),
2030     std::make_pair(90, "VK_FORMAT_R16G16B16_SFLOAT"),
2031     std::make_pair(91, "VK_FORMAT_R16G16B16A16_UNORM"),
2032     std::make_pair(92, "VK_FORMAT_R16G16B16A16_SNORM"),
2033     std::make_pair(93, "VK_FORMAT_R16G16B16A16_USCALED"),
2034     std::make_pair(94, "VK_FORMAT_R16G16B16A16_SSCALED"),
2035     std::make_pair(95, "VK_FORMAT_R16G16B16A16_UINT"),
2036     std::make_pair(96, "VK_FORMAT_R16G16B16A16_SINT"),
2037     std::make_pair(97, "VK_FORMAT_R16G16B16A16_SFLOAT"),
2038     std::make_pair(98, "VK_FORMAT_R32_UINT"),
2039     std::make_pair(99, "VK_FORMAT_R32_SINT"),
2040     std::make_pair(100, "VK_FORMAT_R32_SFLOAT"),
2041     std::make_pair(101, "VK_FORMAT_R32G32_UINT"),
2042     std::make_pair(102, "VK_FORMAT_R32G32_SINT"),
2043     std::make_pair(103, "VK_FORMAT_R32G32_SFLOAT"),
2044     std::make_pair(104, "VK_FORMAT_R32G32B32_UINT"),
2045     std::make_pair(105, "VK_FORMAT_R32G32B32_SINT"),
2046     std::make_pair(106, "VK_FORMAT_R32G32B32_SFLOAT"),
2047     std::make_pair(107, "VK_FORMAT_R32G32B32A32_UINT"),
2048     std::make_pair(108, "VK_FORMAT_R32G32B32A32_SINT"),
2049     std::make_pair(109, "VK_FORMAT_R32G32B32A32_SFLOAT"),
2050     std::make_pair(110, "VK_FORMAT_R64_UINT"),
2051     std::make_pair(111, "VK_FORMAT_R64_SINT"),
2052     std::make_pair(112, "VK_FORMAT_R64_SFLOAT"),
2053     std::make_pair(113, "VK_FORMAT_R64G64_UINT"),
2054     std::make_pair(114, "VK_FORMAT_R64G64_SINT"),
2055     std::make_pair(115, "VK_FORMAT_R64G64_SFLOAT"),
2056     std::make_pair(116, "VK_FORMAT_R64G64B64_UINT"),
2057     std::make_pair(117, "VK_FORMAT_R64G64B64_SINT"),
2058     std::make_pair(118, "VK_FORMAT_R64G64B64_SFLOAT"),
2059     std::make_pair(119, "VK_FORMAT_R64G64B64A64_UINT"),
2060     std::make_pair(120, "VK_FORMAT_R64G64B64A64_SINT"),
2061     std::make_pair(121, "VK_FORMAT_R64G64B64A64_SFLOAT"),
2062     std::make_pair(122, "VK_FORMAT_B10G11R11_UFLOAT_PACK32"),
2063     std::make_pair(123, "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32"),
2064     std::make_pair(124, "VK_FORMAT_D16_UNORM"),
2065     std::make_pair(125, "VK_FORMAT_X8_D24_UNORM_PACK32"),
2066     std::make_pair(126, "VK_FORMAT_D32_SFLOAT"),
2067     std::make_pair(127, "VK_FORMAT_S8_UINT"),
2068     std::make_pair(128, "VK_FORMAT_D16_UNORM_S8_UINT"),
2069     std::make_pair(129, "VK_FORMAT_D24_UNORM_S8_UINT"),
2070     std::make_pair(130, "VK_FORMAT_D32_SFLOAT_S8_UINT"),
2071     std::make_pair(131, "VK_FORMAT_BC1_RGB_UNORM_BLOCK"),
2072     std::make_pair(132, "VK_FORMAT_BC1_RGB_SRGB_BLOCK"),
2073     std::make_pair(133, "VK_FORMAT_BC1_RGBA_UNORM_BLOCK"),
2074     std::make_pair(134, "VK_FORMAT_BC1_RGBA_SRGB_BLOCK"),
2075     std::make_pair(135, "VK_FORMAT_BC2_UNORM_BLOCK"),
2076     std::make_pair(136, "VK_FORMAT_BC2_SRGB_BLOCK"),
2077     std::make_pair(137, "VK_FORMAT_BC3_UNORM_BLOCK"),
2078     std::make_pair(138, "VK_FORMAT_BC3_SRGB_BLOCK"),
2079     std::make_pair(139, "VK_FORMAT_BC4_UNORM_BLOCK"),
2080     std::make_pair(140, "VK_FORMAT_BC4_SNORM_BLOCK"),
2081     std::make_pair(141, "VK_FORMAT_BC5_UNORM_BLOCK"),
2082     std::make_pair(142, "VK_FORMAT_BC5_SNORM_BLOCK"),
2083     std::make_pair(143, "VK_FORMAT_BC6H_UFLOAT_BLOCK"),
2084     std::make_pair(144, "VK_FORMAT_BC6H_SFLOAT_BLOCK"),
2085     std::make_pair(145, "VK_FORMAT_BC7_UNORM_BLOCK"),
2086     std::make_pair(146, "VK_FORMAT_BC7_SRGB_BLOCK"),
2087     std::make_pair(147, "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK"),
2088     std::make_pair(148, "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK"),
2089     std::make_pair(149, "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK"),
2090     std::make_pair(150, "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK"),
2091     std::make_pair(151, "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK"),
2092     std::make_pair(152, "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK"),
2093     std::make_pair(153, "VK_FORMAT_EAC_R11_UNORM_BLOCK"),
2094     std::make_pair(154, "VK_FORMAT_EAC_R11_SNORM_BLOCK"),
2095     std::make_pair(155, "VK_FORMAT_EAC_R11G11_UNORM_BLOCK"),
2096     std::make_pair(156, "VK_FORMAT_EAC_R11G11_SNORM_BLOCK"),
2097     std::make_pair(157, "VK_FORMAT_ASTC_4x4_UNORM_BLOCK"),
2098     std::make_pair(158, "VK_FORMAT_ASTC_4x4_SRGB_BLOCK"),
2099     std::make_pair(159, "VK_FORMAT_ASTC_5x4_UNORM_BLOCK"),
2100     std::make_pair(160, "VK_FORMAT_ASTC_5x4_SRGB_BLOCK"),
2101     std::make_pair(161, "VK_FORMAT_ASTC_5x5_UNORM_BLOCK"),
2102     std::make_pair(162, "VK_FORMAT_ASTC_5x5_SRGB_BLOCK"),
2103     std::make_pair(163, "VK_FORMAT_ASTC_6x5_UNORM_BLOCK"),
2104     std::make_pair(164, "VK_FORMAT_ASTC_6x5_SRGB_BLOCK"),
2105     std::make_pair(165, "VK_FORMAT_ASTC_6x6_UNORM_BLOCK"),
2106     std::make_pair(166, "VK_FORMAT_ASTC_6x6_SRGB_BLOCK"),
2107     std::make_pair(167, "VK_FORMAT_ASTC_8x5_UNORM_BLOCK"),
2108     std::make_pair(168, "VK_FORMAT_ASTC_8x5_SRGB_BLOCK"),
2109     std::make_pair(169, "VK_FORMAT_ASTC_8x6_UNORM_BLOCK"),
2110     std::make_pair(170, "VK_FORMAT_ASTC_8x6_SRGB_BLOCK"),
2111     std::make_pair(171, "VK_FORMAT_ASTC_8x8_UNORM_BLOCK"),
2112     std::make_pair(172, "VK_FORMAT_ASTC_8x8_SRGB_BLOCK"),
2113     std::make_pair(173, "VK_FORMAT_ASTC_10x5_UNORM_BLOCK"),
2114     std::make_pair(174, "VK_FORMAT_ASTC_10x5_SRGB_BLOCK"),
2115     std::make_pair(175, "VK_FORMAT_ASTC_10x6_UNORM_BLOCK"),
2116     std::make_pair(176, "VK_FORMAT_ASTC_10x6_SRGB_BLOCK"),
2117     std::make_pair(177, "VK_FORMAT_ASTC_10x8_UNORM_BLOCK"),
2118     std::make_pair(178, "VK_FORMAT_ASTC_10x8_SRGB_BLOCK"),
2119     std::make_pair(179, "VK_FORMAT_ASTC_10x10_UNORM_BLOCK"),
2120     std::make_pair(180, "VK_FORMAT_ASTC_10x10_SRGB_BLOCK"),
2121     std::make_pair(181, "VK_FORMAT_ASTC_12x10_UNORM_BLOCK"),
2122     std::make_pair(182, "VK_FORMAT_ASTC_12x10_SRGB_BLOCK"),
2123     std::make_pair(183, "VK_FORMAT_ASTC_12x12_UNORM_BLOCK"),
2124     std::make_pair(184, "VK_FORMAT_ASTC_12x12_SRGB_BLOCK"),
2125     std::make_pair(1000156000, "VK_FORMAT_G8B8G8R8_422_UNORM"),
2126     std::make_pair(1000156001, "VK_FORMAT_B8G8R8G8_422_UNORM"),
2127     std::make_pair(1000156002, "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM"),
2128     std::make_pair(1000156003, "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM"),
2129     std::make_pair(1000156004, "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM"),
2130     std::make_pair(1000156005, "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM"),
2131     std::make_pair(1000156006, "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM"),
2132     std::make_pair(1000156007, "VK_FORMAT_R10X6_UNORM_PACK16"),
2133     std::make_pair(1000156008, "VK_FORMAT_R10X6G10X6_UNORM_2PACK16"),
2134     std::make_pair(1000156009, "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16"),
2135     std::make_pair(1000156010, "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"),
2136     std::make_pair(1000156011, "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"),
2137     std::make_pair(1000156012, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"),
2138     std::make_pair(1000156013, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"),
2139     std::make_pair(1000156014, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"),
2140     std::make_pair(1000156015, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"),
2141     std::make_pair(1000156016, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"),
2142     std::make_pair(1000156017, "VK_FORMAT_R12X4_UNORM_PACK16"),
2143     std::make_pair(1000156018, "VK_FORMAT_R12X4G12X4_UNORM_2PACK16"),
2144     std::make_pair(1000156019, "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16"),
2145     std::make_pair(1000156020, "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"),
2146     std::make_pair(1000156021, "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"),
2147     std::make_pair(1000156022, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"),
2148     std::make_pair(1000156023, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"),
2149     std::make_pair(1000156024, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"),
2150     std::make_pair(1000156025, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"),
2151     std::make_pair(1000156026, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"),
2152     std::make_pair(1000156027, "VK_FORMAT_G16B16G16R16_422_UNORM"),
2153     std::make_pair(1000156028, "VK_FORMAT_B16G16R16G16_422_UNORM"),
2154     std::make_pair(1000156029, "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM"),
2155     std::make_pair(1000156030, "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM"),
2156     std::make_pair(1000156031, "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM"),
2157     std::make_pair(1000156032, "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM"),
2158     std::make_pair(1000156033, "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM"),
2159     std::make_pair(1000054000, "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG"),
2160     std::make_pair(1000054001, "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG"),
2161     std::make_pair(1000054002, "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG"),
2162     std::make_pair(1000054003, "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG"),
2163     std::make_pair(1000054004, "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG"),
2164     std::make_pair(1000054005, "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG"),
2165     std::make_pair(1000054006, "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG"),
2166     std::make_pair(1000054007, "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"),
2167     std::make_pair(1000066000, "VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT"),
2168     std::make_pair(1000066001, "VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT"),
2169     std::make_pair(1000066002, "VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT"),
2170     std::make_pair(1000066003, "VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT"),
2171     std::make_pair(1000066004, "VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT"),
2172     std::make_pair(1000066005, "VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT"),
2173     std::make_pair(1000066006, "VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT"),
2174     std::make_pair(1000066007, "VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT"),
2175     std::make_pair(1000066008, "VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT"),
2176     std::make_pair(1000066009, "VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT"),
2177     std::make_pair(1000066010, "VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT"),
2178     std::make_pair(1000066011, "VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT"),
2179     std::make_pair(1000066012, "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT"),
2180     std::make_pair(1000066013, "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT"),
2181     std::make_pair(1000288000, "VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT"),
2182     std::make_pair(1000288001, "VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT"),
2183     std::make_pair(1000288002, "VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT"),
2184     std::make_pair(1000288003, "VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT"),
2185     std::make_pair(1000288004, "VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT"),
2186     std::make_pair(1000288005, "VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT"),
2187     std::make_pair(1000288006, "VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT"),
2188     std::make_pair(1000288007, "VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT"),
2189     std::make_pair(1000288008, "VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT"),
2190     std::make_pair(1000288009, "VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT"),
2191     std::make_pair(1000288010, "VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT"),
2192     std::make_pair(1000288011, "VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT"),
2193     std::make_pair(1000288012, "VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT"),
2194     std::make_pair(1000288013, "VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT"),
2195     std::make_pair(1000288014, "VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT"),
2196     std::make_pair(1000288015, "VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT"),
2197     std::make_pair(1000288016, "VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT"),
2198     std::make_pair(1000288017, "VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT"),
2199     std::make_pair(1000288018, "VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT"),
2200     std::make_pair(1000288019, "VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT"),
2201     std::make_pair(1000288020, "VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT"),
2202     std::make_pair(1000288021, "VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT"),
2203     std::make_pair(1000288022, "VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT"),
2204     std::make_pair(1000288023, "VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT"),
2205     std::make_pair(1000288024, "VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT"),
2206     std::make_pair(1000288025, "VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT"),
2207     std::make_pair(1000288026, "VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT"),
2208     std::make_pair(1000288027, "VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT"),
2209     std::make_pair(1000288028, "VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT"),
2210     std::make_pair(1000288029, "VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT"),
2211     std::make_pair(1000330000, "VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT"),
2212     std::make_pair(1000330001, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT"),
2213     std::make_pair(1000330002, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT"),
2214     std::make_pair(1000330003, "VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT"),
2215     std::make_pair(1000340000, "VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT"),
2216     std::make_pair(1000340001, "VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT"),
2217 };
print_VkFormat(VkFormat obj,const std::string & str,bool commaNeeded=true)2218 static void print_VkFormat(VkFormat obj, const std::string &str, bool commaNeeded = true)
2219 {
2220     PRINT_SPACE
2221     if (str != "")
2222         _OUT << "\"" << str << "\""
2223              << " : ";
2224     if (commaNeeded)
2225         _OUT << "\"" << VkFormat_map[obj] << "\"," << std::endl;
2226     else
2227         _OUT << "\"" << VkFormat_map[obj] << "\"" << std::endl;
2228 }
print_VkFormat(const VkFormat * obj,const std::string & str,bool commaNeeded=true)2229 static void print_VkFormat(const VkFormat *obj, const std::string &str, bool commaNeeded = true)
2230 {
2231     PRINT_SPACE
2232     if (str != "")
2233         _OUT << "\"" << str << "\""
2234              << " : ";
2235     if (commaNeeded)
2236         _OUT << "\"" << VkFormat_map[*obj] << "\"," << std::endl;
2237     else
2238         _OUT << "\"" << VkFormat_map[*obj] << "\"" << std::endl;
2239 }
2240 
2241 static std::map<uint64_t, std::string> VkFormatFeatureFlagBits_map = {
2242     std::make_pair(1ULL << 0, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"),
2243     std::make_pair(1ULL << 1, "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"),
2244     std::make_pair(1ULL << 2, "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"),
2245     std::make_pair(1ULL << 3, "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"),
2246     std::make_pair(1ULL << 4, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"),
2247     std::make_pair(1ULL << 5, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"),
2248     std::make_pair(1ULL << 6, "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"),
2249     std::make_pair(1ULL << 7, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"),
2250     std::make_pair(1ULL << 8, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"),
2251     std::make_pair(1ULL << 9, "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"),
2252     std::make_pair(1ULL << 10, "VK_FORMAT_FEATURE_BLIT_SRC_BIT"),
2253     std::make_pair(1ULL << 11, "VK_FORMAT_FEATURE_BLIT_DST_BIT"),
2254     std::make_pair(1ULL << 12, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"),
2255     std::make_pair(1ULL << 14, "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT"),
2256     std::make_pair(1ULL << 15, "VK_FORMAT_FEATURE_TRANSFER_DST_BIT"),
2257     std::make_pair(1ULL << 17, "VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT"),
2258     std::make_pair(1ULL << 18, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"),
2259     std::make_pair(1ULL << 19, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"),
2260     std::make_pair(1ULL << 20, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"),
2261     std::make_pair(1ULL << 21,
2262                    "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"),
2263     std::make_pair(1ULL << 22, "VK_FORMAT_FEATURE_DISJOINT_BIT"),
2264     std::make_pair(1ULL << 23, "VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT"),
2265     std::make_pair(1ULL << 16, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT"),
2266     std::make_pair(1ULL << 13, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG"),
2267     std::make_pair(1ULL << 25, "VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR"),
2268     std::make_pair(1ULL << 26, "VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR"),
2269     std::make_pair(1ULL << 29, "VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"),
2270     std::make_pair(1ULL << 24, "VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT"),
2271     std::make_pair(1ULL << 30, "VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"),
2272     std::make_pair(1ULL << 27, "VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR"),
2273     std::make_pair(1ULL << 28, "VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR"),
2274 };
print_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits obj,const std::string & str,bool commaNeeded=true)2275 static void print_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits obj, const std::string &str, bool commaNeeded = true)
2276 {
2277     PRINT_SPACE
2278     if (str != "")
2279         _OUT << "\"" << str << "\""
2280              << " : ";
2281     if (commaNeeded)
2282         _OUT << "\"" << VkFormatFeatureFlagBits_map[obj] << "\"," << std::endl;
2283     else
2284         _OUT << "\"" << VkFormatFeatureFlagBits_map[obj] << "\"" << std::endl;
2285 }
print_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits * obj,const std::string & str,bool commaNeeded=true)2286 static void print_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits *obj, const std::string &str,
2287                                           bool commaNeeded = true)
2288 {
2289     PRINT_SPACE
2290     if (str != "")
2291         _OUT << "\"" << str << "\""
2292              << " : ";
2293     if (commaNeeded)
2294         _OUT << "\"" << VkFormatFeatureFlagBits_map[*obj] << "\"," << std::endl;
2295     else
2296         _OUT << "\"" << VkFormatFeatureFlagBits_map[*obj] << "\"" << std::endl;
2297 }
2298 
2299 static std::map<uint64_t, std::string> VkImageCreateFlagBits_map = {
2300     std::make_pair(1ULL << 0, "VK_IMAGE_CREATE_SPARSE_BINDING_BIT"),
2301     std::make_pair(1ULL << 1, "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"),
2302     std::make_pair(1ULL << 2, "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"),
2303     std::make_pair(1ULL << 3, "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"),
2304     std::make_pair(1ULL << 4, "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"),
2305     std::make_pair(1ULL << 10, "VK_IMAGE_CREATE_ALIAS_BIT"),
2306     std::make_pair(1ULL << 6, "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"),
2307     std::make_pair(1ULL << 5, "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT"),
2308     std::make_pair(1ULL << 7, "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT"),
2309     std::make_pair(1ULL << 8, "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT"),
2310     std::make_pair(1ULL << 11, "VK_IMAGE_CREATE_PROTECTED_BIT"),
2311     std::make_pair(1ULL << 9, "VK_IMAGE_CREATE_DISJOINT_BIT"),
2312     std::make_pair(1ULL << 13, "VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV"),
2313     std::make_pair(1ULL << 12, "VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT"),
2314     std::make_pair(1ULL << 14, "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT"),
2315     std::make_pair(1ULL << 16, "VK_IMAGE_CREATE_RESERVED_16_BIT_AMD"),
2316     std::make_pair(1ULL << 17, "VK_IMAGE_CREATE_RESERVED_394_BIT_EXT"),
2317     std::make_pair(1ULL << 15, "VK_IMAGE_CREATE_RESERVED_426_BIT_QCOM"),
2318 };
print_VkImageCreateFlagBits(VkImageCreateFlagBits obj,const std::string & str,bool commaNeeded=true)2319 static void print_VkImageCreateFlagBits(VkImageCreateFlagBits obj, const std::string &str, bool commaNeeded = true)
2320 {
2321     PRINT_SPACE
2322     if (str != "")
2323         _OUT << "\"" << str << "\""
2324              << " : ";
2325     if (commaNeeded)
2326         _OUT << "\"" << VkImageCreateFlagBits_map[obj] << "\"," << std::endl;
2327     else
2328         _OUT << "\"" << VkImageCreateFlagBits_map[obj] << "\"" << std::endl;
2329 }
print_VkImageCreateFlagBits(const VkImageCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)2330 static void print_VkImageCreateFlagBits(const VkImageCreateFlagBits *obj, const std::string &str,
2331                                         bool commaNeeded = true)
2332 {
2333     PRINT_SPACE
2334     if (str != "")
2335         _OUT << "\"" << str << "\""
2336              << " : ";
2337     if (commaNeeded)
2338         _OUT << "\"" << VkImageCreateFlagBits_map[*obj] << "\"," << std::endl;
2339     else
2340         _OUT << "\"" << VkImageCreateFlagBits_map[*obj] << "\"" << std::endl;
2341 }
2342 
2343 static std::map<uint64_t, std::string> VkSampleCountFlagBits_map = {
2344     std::make_pair(1ULL << 0, "VK_SAMPLE_COUNT_1_BIT"),  std::make_pair(1ULL << 1, "VK_SAMPLE_COUNT_2_BIT"),
2345     std::make_pair(1ULL << 2, "VK_SAMPLE_COUNT_4_BIT"),  std::make_pair(1ULL << 3, "VK_SAMPLE_COUNT_8_BIT"),
2346     std::make_pair(1ULL << 4, "VK_SAMPLE_COUNT_16_BIT"), std::make_pair(1ULL << 5, "VK_SAMPLE_COUNT_32_BIT"),
2347     std::make_pair(1ULL << 6, "VK_SAMPLE_COUNT_64_BIT"),
2348 };
print_VkSampleCountFlagBits(VkSampleCountFlagBits obj,const std::string & str,bool commaNeeded=true)2349 static void print_VkSampleCountFlagBits(VkSampleCountFlagBits obj, const std::string &str, bool commaNeeded = true)
2350 {
2351     PRINT_SPACE
2352     if (str != "")
2353         _OUT << "\"" << str << "\""
2354              << " : ";
2355     if (commaNeeded)
2356         _OUT << "\"" << VkSampleCountFlagBits_map[obj] << "\"," << std::endl;
2357     else
2358         _OUT << "\"" << VkSampleCountFlagBits_map[obj] << "\"" << std::endl;
2359 }
print_VkSampleCountFlagBits(const VkSampleCountFlagBits * obj,const std::string & str,bool commaNeeded=true)2360 static void print_VkSampleCountFlagBits(const VkSampleCountFlagBits *obj, const std::string &str,
2361                                         bool commaNeeded = true)
2362 {
2363     PRINT_SPACE
2364     if (str != "")
2365         _OUT << "\"" << str << "\""
2366              << " : ";
2367     if (commaNeeded)
2368         _OUT << "\"" << VkSampleCountFlagBits_map[*obj] << "\"," << std::endl;
2369     else
2370         _OUT << "\"" << VkSampleCountFlagBits_map[*obj] << "\"" << std::endl;
2371 }
2372 
2373 static std::map<uint64_t, std::string> VkImageTiling_map = {
2374     std::make_pair(0, "VK_IMAGE_TILING_OPTIMAL"),
2375     std::make_pair(1, "VK_IMAGE_TILING_LINEAR"),
2376     std::make_pair(1000158000, "VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT"),
2377 };
print_VkImageTiling(VkImageTiling obj,const std::string & str,bool commaNeeded=true)2378 static void print_VkImageTiling(VkImageTiling obj, const std::string &str, bool commaNeeded = true)
2379 {
2380     PRINT_SPACE
2381     if (str != "")
2382         _OUT << "\"" << str << "\""
2383              << " : ";
2384     if (commaNeeded)
2385         _OUT << "\"" << VkImageTiling_map[obj] << "\"," << std::endl;
2386     else
2387         _OUT << "\"" << VkImageTiling_map[obj] << "\"" << std::endl;
2388 }
print_VkImageTiling(const VkImageTiling * obj,const std::string & str,bool commaNeeded=true)2389 static void print_VkImageTiling(const VkImageTiling *obj, const std::string &str, bool commaNeeded = true)
2390 {
2391     PRINT_SPACE
2392     if (str != "")
2393         _OUT << "\"" << str << "\""
2394              << " : ";
2395     if (commaNeeded)
2396         _OUT << "\"" << VkImageTiling_map[*obj] << "\"," << std::endl;
2397     else
2398         _OUT << "\"" << VkImageTiling_map[*obj] << "\"" << std::endl;
2399 }
2400 
2401 static std::map<uint64_t, std::string> VkImageType_map = {
2402     std::make_pair(0, "VK_IMAGE_TYPE_1D"),
2403     std::make_pair(1, "VK_IMAGE_TYPE_2D"),
2404     std::make_pair(2, "VK_IMAGE_TYPE_3D"),
2405 };
print_VkImageType(VkImageType obj,const std::string & str,bool commaNeeded=true)2406 static void print_VkImageType(VkImageType obj, const std::string &str, bool commaNeeded = true)
2407 {
2408     PRINT_SPACE
2409     if (str != "")
2410         _OUT << "\"" << str << "\""
2411              << " : ";
2412     if (commaNeeded)
2413         _OUT << "\"" << VkImageType_map[obj] << "\"," << std::endl;
2414     else
2415         _OUT << "\"" << VkImageType_map[obj] << "\"" << std::endl;
2416 }
print_VkImageType(const VkImageType * obj,const std::string & str,bool commaNeeded=true)2417 static void print_VkImageType(const VkImageType *obj, const std::string &str, bool commaNeeded = true)
2418 {
2419     PRINT_SPACE
2420     if (str != "")
2421         _OUT << "\"" << str << "\""
2422              << " : ";
2423     if (commaNeeded)
2424         _OUT << "\"" << VkImageType_map[*obj] << "\"," << std::endl;
2425     else
2426         _OUT << "\"" << VkImageType_map[*obj] << "\"" << std::endl;
2427 }
2428 
2429 static std::map<uint64_t, std::string> VkImageUsageFlagBits_map = {
2430     std::make_pair(1ULL << 0, "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"),
2431     std::make_pair(1ULL << 1, "VK_IMAGE_USAGE_TRANSFER_DST_BIT"),
2432     std::make_pair(1ULL << 2, "VK_IMAGE_USAGE_SAMPLED_BIT"),
2433     std::make_pair(1ULL << 3, "VK_IMAGE_USAGE_STORAGE_BIT"),
2434     std::make_pair(1ULL << 4, "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"),
2435     std::make_pair(1ULL << 5, "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT"),
2436     std::make_pair(1ULL << 6, "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"),
2437     std::make_pair(1ULL << 7, "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"),
2438     std::make_pair(1ULL << 10, "VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR"),
2439     std::make_pair(1ULL << 11, "VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR"),
2440     std::make_pair(1ULL << 12, "VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR"),
2441     std::make_pair(1ULL << 16, "VK_IMAGE_USAGE_RESERVED_16_BIT_QCOM"),
2442     std::make_pair(1ULL << 17, "VK_IMAGE_USAGE_RESERVED_17_BIT_QCOM"),
2443     std::make_pair(1ULL << 9, "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT"),
2444     std::make_pair(1ULL << 8, "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"),
2445     std::make_pair(1ULL << 13, "VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR"),
2446     std::make_pair(1ULL << 14, "VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"),
2447     std::make_pair(1ULL << 15, "VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR"),
2448     std::make_pair(1ULL << 19, "VK_IMAGE_USAGE_RESERVED_19_BIT_EXT"),
2449     std::make_pair(1ULL << 18, "VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI"),
2450 };
print_VkImageUsageFlagBits(VkImageUsageFlagBits obj,const std::string & str,bool commaNeeded=true)2451 static void print_VkImageUsageFlagBits(VkImageUsageFlagBits obj, const std::string &str, bool commaNeeded = true)
2452 {
2453     PRINT_SPACE
2454     if (str != "")
2455         _OUT << "\"" << str << "\""
2456              << " : ";
2457     if (commaNeeded)
2458         _OUT << "\"" << VkImageUsageFlagBits_map[obj] << "\"," << std::endl;
2459     else
2460         _OUT << "\"" << VkImageUsageFlagBits_map[obj] << "\"" << std::endl;
2461 }
print_VkImageUsageFlagBits(const VkImageUsageFlagBits * obj,const std::string & str,bool commaNeeded=true)2462 static void print_VkImageUsageFlagBits(const VkImageUsageFlagBits *obj, const std::string &str, bool commaNeeded = true)
2463 {
2464     PRINT_SPACE
2465     if (str != "")
2466         _OUT << "\"" << str << "\""
2467              << " : ";
2468     if (commaNeeded)
2469         _OUT << "\"" << VkImageUsageFlagBits_map[*obj] << "\"," << std::endl;
2470     else
2471         _OUT << "\"" << VkImageUsageFlagBits_map[*obj] << "\"" << std::endl;
2472 }
2473 
2474 static std::map<uint64_t, std::string> VkMemoryHeapFlagBits_map = {
2475     std::make_pair(1ULL << 0, "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT"),
2476     std::make_pair(1ULL << 1, "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT"),
2477     std::make_pair(1ULL << 2, "VK_MEMORY_HEAP_SEU_SAFE_BIT"),
2478 };
print_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits obj,const std::string & str,bool commaNeeded=true)2479 static void print_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits obj, const std::string &str, bool commaNeeded = true)
2480 {
2481     PRINT_SPACE
2482     if (str != "")
2483         _OUT << "\"" << str << "\""
2484              << " : ";
2485     if (commaNeeded)
2486         _OUT << "\"" << VkMemoryHeapFlagBits_map[obj] << "\"," << std::endl;
2487     else
2488         _OUT << "\"" << VkMemoryHeapFlagBits_map[obj] << "\"" << std::endl;
2489 }
print_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits * obj,const std::string & str,bool commaNeeded=true)2490 static void print_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits *obj, const std::string &str, bool commaNeeded = true)
2491 {
2492     PRINT_SPACE
2493     if (str != "")
2494         _OUT << "\"" << str << "\""
2495              << " : ";
2496     if (commaNeeded)
2497         _OUT << "\"" << VkMemoryHeapFlagBits_map[*obj] << "\"," << std::endl;
2498     else
2499         _OUT << "\"" << VkMemoryHeapFlagBits_map[*obj] << "\"" << std::endl;
2500 }
2501 
2502 static std::map<uint64_t, std::string> VkMemoryPropertyFlagBits_map = {
2503     std::make_pair(1ULL << 0, "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT"),
2504     std::make_pair(1ULL << 1, "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT"),
2505     std::make_pair(1ULL << 2, "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT"),
2506     std::make_pair(1ULL << 3, "VK_MEMORY_PROPERTY_HOST_CACHED_BIT"),
2507     std::make_pair(1ULL << 4, "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT"),
2508     std::make_pair(1ULL << 5, "VK_MEMORY_PROPERTY_PROTECTED_BIT"),
2509     std::make_pair(1ULL << 6, "VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD"),
2510     std::make_pair(1ULL << 7, "VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD"),
2511     std::make_pair(1ULL << 8, "VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV"),
2512 };
print_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBits obj,const std::string & str,bool commaNeeded=true)2513 static void print_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBits obj, const std::string &str,
2514                                            bool commaNeeded = true)
2515 {
2516     PRINT_SPACE
2517     if (str != "")
2518         _OUT << "\"" << str << "\""
2519              << " : ";
2520     if (commaNeeded)
2521         _OUT << "\"" << VkMemoryPropertyFlagBits_map[obj] << "\"," << std::endl;
2522     else
2523         _OUT << "\"" << VkMemoryPropertyFlagBits_map[obj] << "\"" << std::endl;
2524 }
print_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits * obj,const std::string & str,bool commaNeeded=true)2525 static void print_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits *obj, const std::string &str,
2526                                            bool commaNeeded = true)
2527 {
2528     PRINT_SPACE
2529     if (str != "")
2530         _OUT << "\"" << str << "\""
2531              << " : ";
2532     if (commaNeeded)
2533         _OUT << "\"" << VkMemoryPropertyFlagBits_map[*obj] << "\"," << std::endl;
2534     else
2535         _OUT << "\"" << VkMemoryPropertyFlagBits_map[*obj] << "\"" << std::endl;
2536 }
2537 
2538 static std::map<uint64_t, std::string> VkPhysicalDeviceType_map = {
2539     std::make_pair(0, "VK_PHYSICAL_DEVICE_TYPE_OTHER"),
2540     std::make_pair(1, "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU"),
2541     std::make_pair(2, "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU"),
2542     std::make_pair(3, "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU"),
2543     std::make_pair(4, "VK_PHYSICAL_DEVICE_TYPE_CPU"),
2544 };
print_VkPhysicalDeviceType(VkPhysicalDeviceType obj,const std::string & str,bool commaNeeded=true)2545 static void print_VkPhysicalDeviceType(VkPhysicalDeviceType obj, const std::string &str, bool commaNeeded = true)
2546 {
2547     PRINT_SPACE
2548     if (str != "")
2549         _OUT << "\"" << str << "\""
2550              << " : ";
2551     if (commaNeeded)
2552         _OUT << "\"" << VkPhysicalDeviceType_map[obj] << "\"," << std::endl;
2553     else
2554         _OUT << "\"" << VkPhysicalDeviceType_map[obj] << "\"" << std::endl;
2555 }
print_VkPhysicalDeviceType(const VkPhysicalDeviceType * obj,const std::string & str,bool commaNeeded=true)2556 static void print_VkPhysicalDeviceType(const VkPhysicalDeviceType *obj, const std::string &str, bool commaNeeded = true)
2557 {
2558     PRINT_SPACE
2559     if (str != "")
2560         _OUT << "\"" << str << "\""
2561              << " : ";
2562     if (commaNeeded)
2563         _OUT << "\"" << VkPhysicalDeviceType_map[*obj] << "\"," << std::endl;
2564     else
2565         _OUT << "\"" << VkPhysicalDeviceType_map[*obj] << "\"" << std::endl;
2566 }
2567 
2568 static std::map<uint64_t, std::string> VkQueueFlagBits_map = {
2569     std::make_pair(1ULL << 0, "VK_QUEUE_GRAPHICS_BIT"),
2570     std::make_pair(1ULL << 1, "VK_QUEUE_COMPUTE_BIT"),
2571     std::make_pair(1ULL << 2, "VK_QUEUE_TRANSFER_BIT"),
2572     std::make_pair(1ULL << 4, "VK_QUEUE_PROTECTED_BIT"),
2573     std::make_pair(1ULL << 5, "VK_QUEUE_VIDEO_DECODE_BIT_KHR"),
2574     std::make_pair(1ULL << 6, "VK_QUEUE_VIDEO_ENCODE_BIT_KHR"),
2575 };
print_VkQueueFlagBits(VkQueueFlagBits obj,const std::string & str,bool commaNeeded=true)2576 static void print_VkQueueFlagBits(VkQueueFlagBits obj, const std::string &str, bool commaNeeded = true)
2577 {
2578     PRINT_SPACE
2579     if (str != "")
2580         _OUT << "\"" << str << "\""
2581              << " : ";
2582     if (commaNeeded)
2583         _OUT << "\"" << VkQueueFlagBits_map[obj] << "\"," << std::endl;
2584     else
2585         _OUT << "\"" << VkQueueFlagBits_map[obj] << "\"" << std::endl;
2586 }
print_VkQueueFlagBits(const VkQueueFlagBits * obj,const std::string & str,bool commaNeeded=true)2587 static void print_VkQueueFlagBits(const VkQueueFlagBits *obj, const std::string &str, bool commaNeeded = true)
2588 {
2589     PRINT_SPACE
2590     if (str != "")
2591         _OUT << "\"" << str << "\""
2592              << " : ";
2593     if (commaNeeded)
2594         _OUT << "\"" << VkQueueFlagBits_map[*obj] << "\"," << std::endl;
2595     else
2596         _OUT << "\"" << VkQueueFlagBits_map[*obj] << "\"" << std::endl;
2597 }
2598 
2599 static std::map<uint64_t, std::string> VkDeviceQueueCreateFlagBits_map = {
2600     std::make_pair(1ULL << 0, "VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT"),
2601 };
print_VkDeviceQueueCreateFlagBits(VkDeviceQueueCreateFlagBits obj,const std::string & str,bool commaNeeded=true)2602 static void print_VkDeviceQueueCreateFlagBits(VkDeviceQueueCreateFlagBits obj, const std::string &str,
2603                                               bool commaNeeded = true)
2604 {
2605     PRINT_SPACE
2606     if (str != "")
2607         _OUT << "\"" << str << "\""
2608              << " : ";
2609     if (commaNeeded)
2610         _OUT << "\"" << VkDeviceQueueCreateFlagBits_map[obj] << "\"," << std::endl;
2611     else
2612         _OUT << "\"" << VkDeviceQueueCreateFlagBits_map[obj] << "\"" << std::endl;
2613 }
print_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)2614 static void print_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits *obj, const std::string &str,
2615                                               bool commaNeeded = true)
2616 {
2617     PRINT_SPACE
2618     if (str != "")
2619         _OUT << "\"" << str << "\""
2620              << " : ";
2621     if (commaNeeded)
2622         _OUT << "\"" << VkDeviceQueueCreateFlagBits_map[*obj] << "\"," << std::endl;
2623     else
2624         _OUT << "\"" << VkDeviceQueueCreateFlagBits_map[*obj] << "\"" << std::endl;
2625 }
2626 
2627 static std::map<uint64_t, std::string> VkPipelineStageFlagBits_map = {
2628     std::make_pair(1ULL << 0, "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT"),
2629     std::make_pair(1ULL << 1, "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT"),
2630     std::make_pair(1ULL << 2, "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT"),
2631     std::make_pair(1ULL << 3, "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT"),
2632     std::make_pair(1ULL << 4, "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT"),
2633     std::make_pair(1ULL << 5, "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT"),
2634     std::make_pair(1ULL << 6, "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT"),
2635     std::make_pair(1ULL << 7, "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT"),
2636     std::make_pair(1ULL << 8, "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT"),
2637     std::make_pair(1ULL << 9, "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT"),
2638     std::make_pair(1ULL << 10, "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT"),
2639     std::make_pair(1ULL << 11, "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT"),
2640     std::make_pair(1ULL << 12, "VK_PIPELINE_STAGE_TRANSFER_BIT"),
2641     std::make_pair(1ULL << 13, "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT"),
2642     std::make_pair(1ULL << 14, "VK_PIPELINE_STAGE_HOST_BIT"),
2643     std::make_pair(1ULL << 15, "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT"),
2644     std::make_pair(1ULL << 16, "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT"),
2645     std::make_pair(1ULL << 24, "VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT"),
2646     std::make_pair(1ULL << 18, "VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT"),
2647     std::make_pair(1ULL << 25, "VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"),
2648     std::make_pair(1ULL << 21, "VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR"),
2649     std::make_pair(1ULL << 19, "VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV"),
2650     std::make_pair(1ULL << 20, "VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV"),
2651     std::make_pair(1ULL << 23, "VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT"),
2652     std::make_pair(1ULL << 22, "VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"),
2653     std::make_pair(1ULL << 17, "VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV"),
2654     std::make_pair(0, "VK_PIPELINE_STAGE_NONE_KHR"),
2655 };
print_VkPipelineStageFlagBits(VkPipelineStageFlagBits obj,const std::string & str,bool commaNeeded=true)2656 static void print_VkPipelineStageFlagBits(VkPipelineStageFlagBits obj, const std::string &str, bool commaNeeded = true)
2657 {
2658     PRINT_SPACE
2659     if (str != "")
2660         _OUT << "\"" << str << "\""
2661              << " : ";
2662     if (commaNeeded)
2663         _OUT << "\"" << VkPipelineStageFlagBits_map[obj] << "\"," << std::endl;
2664     else
2665         _OUT << "\"" << VkPipelineStageFlagBits_map[obj] << "\"" << std::endl;
2666 }
print_VkPipelineStageFlagBits(const VkPipelineStageFlagBits * obj,const std::string & str,bool commaNeeded=true)2667 static void print_VkPipelineStageFlagBits(const VkPipelineStageFlagBits *obj, const std::string &str,
2668                                           bool commaNeeded = true)
2669 {
2670     PRINT_SPACE
2671     if (str != "")
2672         _OUT << "\"" << str << "\""
2673              << " : ";
2674     if (commaNeeded)
2675         _OUT << "\"" << VkPipelineStageFlagBits_map[*obj] << "\"," << std::endl;
2676     else
2677         _OUT << "\"" << VkPipelineStageFlagBits_map[*obj] << "\"" << std::endl;
2678 }
2679 
2680 static std::map<uint64_t, std::string> VkFenceCreateFlagBits_map = {
2681     std::make_pair(1ULL << 0, "VK_FENCE_CREATE_SIGNALED_BIT"),
2682 };
print_VkFenceCreateFlagBits(VkFenceCreateFlagBits obj,const std::string & str,bool commaNeeded=true)2683 static void print_VkFenceCreateFlagBits(VkFenceCreateFlagBits obj, const std::string &str, bool commaNeeded = true)
2684 {
2685     PRINT_SPACE
2686     if (str != "")
2687         _OUT << "\"" << str << "\""
2688              << " : ";
2689     if (commaNeeded)
2690         _OUT << "\"" << VkFenceCreateFlagBits_map[obj] << "\"," << std::endl;
2691     else
2692         _OUT << "\"" << VkFenceCreateFlagBits_map[obj] << "\"" << std::endl;
2693 }
print_VkFenceCreateFlagBits(const VkFenceCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)2694 static void print_VkFenceCreateFlagBits(const VkFenceCreateFlagBits *obj, const std::string &str,
2695                                         bool commaNeeded = true)
2696 {
2697     PRINT_SPACE
2698     if (str != "")
2699         _OUT << "\"" << str << "\""
2700              << " : ";
2701     if (commaNeeded)
2702         _OUT << "\"" << VkFenceCreateFlagBits_map[*obj] << "\"," << std::endl;
2703     else
2704         _OUT << "\"" << VkFenceCreateFlagBits_map[*obj] << "\"" << std::endl;
2705 }
2706 
2707 static std::map<uint64_t, std::string> VkEventCreateFlagBits_map = {
2708     std::make_pair(1ULL << 0, "VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR"),
2709 };
print_VkEventCreateFlagBits(VkEventCreateFlagBits obj,const std::string & str,bool commaNeeded=true)2710 static void print_VkEventCreateFlagBits(VkEventCreateFlagBits obj, const std::string &str, bool commaNeeded = true)
2711 {
2712     PRINT_SPACE
2713     if (str != "")
2714         _OUT << "\"" << str << "\""
2715              << " : ";
2716     if (commaNeeded)
2717         _OUT << "\"" << VkEventCreateFlagBits_map[obj] << "\"," << std::endl;
2718     else
2719         _OUT << "\"" << VkEventCreateFlagBits_map[obj] << "\"" << std::endl;
2720 }
print_VkEventCreateFlagBits(const VkEventCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)2721 static void print_VkEventCreateFlagBits(const VkEventCreateFlagBits *obj, const std::string &str,
2722                                         bool commaNeeded = true)
2723 {
2724     PRINT_SPACE
2725     if (str != "")
2726         _OUT << "\"" << str << "\""
2727              << " : ";
2728     if (commaNeeded)
2729         _OUT << "\"" << VkEventCreateFlagBits_map[*obj] << "\"," << std::endl;
2730     else
2731         _OUT << "\"" << VkEventCreateFlagBits_map[*obj] << "\"" << std::endl;
2732 }
2733 
2734 static std::map<uint64_t, std::string> VkQueryPipelineStatisticFlagBits_map = {
2735     std::make_pair(1ULL << 0, "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT"),
2736     std::make_pair(1ULL << 1, "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT"),
2737     std::make_pair(1ULL << 2, "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT"),
2738     std::make_pair(1ULL << 3, "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT"),
2739     std::make_pair(1ULL << 4, "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT"),
2740     std::make_pair(1ULL << 5, "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT"),
2741     std::make_pair(1ULL << 6, "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT"),
2742     std::make_pair(1ULL << 7, "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT"),
2743     std::make_pair(1ULL << 8, "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT"),
2744     std::make_pair(1ULL << 9, "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT"),
2745     std::make_pair(1ULL << 10, "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT"),
2746 };
print_VkQueryPipelineStatisticFlagBits(VkQueryPipelineStatisticFlagBits obj,const std::string & str,bool commaNeeded=true)2747 static void print_VkQueryPipelineStatisticFlagBits(VkQueryPipelineStatisticFlagBits obj, const std::string &str,
2748                                                    bool commaNeeded = true)
2749 {
2750     PRINT_SPACE
2751     if (str != "")
2752         _OUT << "\"" << str << "\""
2753              << " : ";
2754     if (commaNeeded)
2755         _OUT << "\"" << VkQueryPipelineStatisticFlagBits_map[obj] << "\"," << std::endl;
2756     else
2757         _OUT << "\"" << VkQueryPipelineStatisticFlagBits_map[obj] << "\"" << std::endl;
2758 }
print_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits * obj,const std::string & str,bool commaNeeded=true)2759 static void print_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits *obj, const std::string &str,
2760                                                    bool commaNeeded = true)
2761 {
2762     PRINT_SPACE
2763     if (str != "")
2764         _OUT << "\"" << str << "\""
2765              << " : ";
2766     if (commaNeeded)
2767         _OUT << "\"" << VkQueryPipelineStatisticFlagBits_map[*obj] << "\"," << std::endl;
2768     else
2769         _OUT << "\"" << VkQueryPipelineStatisticFlagBits_map[*obj] << "\"" << std::endl;
2770 }
2771 
2772 static std::map<uint64_t, std::string> VkQueryType_map = {
2773     std::make_pair(0, "VK_QUERY_TYPE_OCCLUSION"),
2774     std::make_pair(1, "VK_QUERY_TYPE_PIPELINE_STATISTICS"),
2775     std::make_pair(2, "VK_QUERY_TYPE_TIMESTAMP"),
2776     std::make_pair(1000023000, "VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR"),
2777     std::make_pair(1000028004, "VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT"),
2778     std::make_pair(1000116000, "VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR"),
2779     std::make_pair(1000150000, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR"),
2780     std::make_pair(1000150001, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR"),
2781     std::make_pair(1000165000, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV"),
2782     std::make_pair(1000210000, "VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL"),
2783     std::make_pair(1000299000, "VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR"),
2784 };
print_VkQueryType(VkQueryType obj,const std::string & str,bool commaNeeded=true)2785 static void print_VkQueryType(VkQueryType obj, const std::string &str, bool commaNeeded = true)
2786 {
2787     PRINT_SPACE
2788     if (str != "")
2789         _OUT << "\"" << str << "\""
2790              << " : ";
2791     if (commaNeeded)
2792         _OUT << "\"" << VkQueryType_map[obj] << "\"," << std::endl;
2793     else
2794         _OUT << "\"" << VkQueryType_map[obj] << "\"" << std::endl;
2795 }
print_VkQueryType(const VkQueryType * obj,const std::string & str,bool commaNeeded=true)2796 static void print_VkQueryType(const VkQueryType *obj, const std::string &str, bool commaNeeded = true)
2797 {
2798     PRINT_SPACE
2799     if (str != "")
2800         _OUT << "\"" << str << "\""
2801              << " : ";
2802     if (commaNeeded)
2803         _OUT << "\"" << VkQueryType_map[*obj] << "\"," << std::endl;
2804     else
2805         _OUT << "\"" << VkQueryType_map[*obj] << "\"" << std::endl;
2806 }
2807 
2808 static std::map<uint64_t, std::string> VkQueryResultFlagBits_map = {
2809     std::make_pair(1ULL << 0, "VK_QUERY_RESULT_64_BIT"),
2810     std::make_pair(1ULL << 1, "VK_QUERY_RESULT_WAIT_BIT"),
2811     std::make_pair(1ULL << 2, "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT"),
2812     std::make_pair(1ULL << 3, "VK_QUERY_RESULT_PARTIAL_BIT"),
2813     std::make_pair(1ULL << 4, "VK_QUERY_RESULT_WITH_STATUS_BIT_KHR"),
2814 };
print_VkQueryResultFlagBits(VkQueryResultFlagBits obj,const std::string & str,bool commaNeeded=true)2815 static void print_VkQueryResultFlagBits(VkQueryResultFlagBits obj, const std::string &str, bool commaNeeded = true)
2816 {
2817     PRINT_SPACE
2818     if (str != "")
2819         _OUT << "\"" << str << "\""
2820              << " : ";
2821     if (commaNeeded)
2822         _OUT << "\"" << VkQueryResultFlagBits_map[obj] << "\"," << std::endl;
2823     else
2824         _OUT << "\"" << VkQueryResultFlagBits_map[obj] << "\"" << std::endl;
2825 }
print_VkQueryResultFlagBits(const VkQueryResultFlagBits * obj,const std::string & str,bool commaNeeded=true)2826 static void print_VkQueryResultFlagBits(const VkQueryResultFlagBits *obj, const std::string &str,
2827                                         bool commaNeeded = true)
2828 {
2829     PRINT_SPACE
2830     if (str != "")
2831         _OUT << "\"" << str << "\""
2832              << " : ";
2833     if (commaNeeded)
2834         _OUT << "\"" << VkQueryResultFlagBits_map[*obj] << "\"," << std::endl;
2835     else
2836         _OUT << "\"" << VkQueryResultFlagBits_map[*obj] << "\"" << std::endl;
2837 }
2838 
2839 static std::map<uint64_t, std::string> VkBufferCreateFlagBits_map = {
2840     std::make_pair(1ULL << 0, "VK_BUFFER_CREATE_SPARSE_BINDING_BIT"),
2841     std::make_pair(1ULL << 1, "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT"),
2842     std::make_pair(1ULL << 2, "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT"),
2843     std::make_pair(1ULL << 3, "VK_BUFFER_CREATE_PROTECTED_BIT"),
2844     std::make_pair(1ULL << 4, "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"),
2845     std::make_pair(1ULL << 5, "VK_BUFFER_CREATE_RESERVED_5_BIT_AMD"),
2846 };
print_VkBufferCreateFlagBits(VkBufferCreateFlagBits obj,const std::string & str,bool commaNeeded=true)2847 static void print_VkBufferCreateFlagBits(VkBufferCreateFlagBits obj, const std::string &str, bool commaNeeded = true)
2848 {
2849     PRINT_SPACE
2850     if (str != "")
2851         _OUT << "\"" << str << "\""
2852              << " : ";
2853     if (commaNeeded)
2854         _OUT << "\"" << VkBufferCreateFlagBits_map[obj] << "\"," << std::endl;
2855     else
2856         _OUT << "\"" << VkBufferCreateFlagBits_map[obj] << "\"" << std::endl;
2857 }
print_VkBufferCreateFlagBits(const VkBufferCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)2858 static void print_VkBufferCreateFlagBits(const VkBufferCreateFlagBits *obj, const std::string &str,
2859                                          bool commaNeeded = true)
2860 {
2861     PRINT_SPACE
2862     if (str != "")
2863         _OUT << "\"" << str << "\""
2864              << " : ";
2865     if (commaNeeded)
2866         _OUT << "\"" << VkBufferCreateFlagBits_map[*obj] << "\"," << std::endl;
2867     else
2868         _OUT << "\"" << VkBufferCreateFlagBits_map[*obj] << "\"" << std::endl;
2869 }
2870 
2871 static std::map<uint64_t, std::string> VkBufferUsageFlagBits_map = {
2872     std::make_pair(1ULL << 0, "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"),
2873     std::make_pair(1ULL << 1, "VK_BUFFER_USAGE_TRANSFER_DST_BIT"),
2874     std::make_pair(1ULL << 2, "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"),
2875     std::make_pair(1ULL << 3, "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"),
2876     std::make_pair(1ULL << 4, "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"),
2877     std::make_pair(1ULL << 5, "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"),
2878     std::make_pair(1ULL << 6, "VK_BUFFER_USAGE_INDEX_BUFFER_BIT"),
2879     std::make_pair(1ULL << 7, "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"),
2880     std::make_pair(1ULL << 8, "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT"),
2881     std::make_pair(1ULL << 17, "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT"),
2882     std::make_pair(1ULL << 13, "VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR"),
2883     std::make_pair(1ULL << 14, "VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR"),
2884     std::make_pair(1ULL << 11, "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"),
2885     std::make_pair(1ULL << 12, "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"),
2886     std::make_pair(1ULL << 9, "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"),
2887     std::make_pair(1ULL << 19, "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"),
2888     std::make_pair(1ULL << 20, "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"),
2889     std::make_pair(1ULL << 10, "VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR"),
2890     std::make_pair(1ULL << 18, "VK_BUFFER_USAGE_RESERVED_18_BIT_QCOM"),
2891     std::make_pair(1ULL << 15, "VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR"),
2892     std::make_pair(1ULL << 16, "VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"),
2893     std::make_pair(1ULL << 21, "VK_BUFFER_USAGE_RESERVED_21_BIT_AMD"),
2894     std::make_pair(1ULL << 22, "VK_BUFFER_USAGE_RESERVED_22_BIT_AMD"),
2895 };
print_VkBufferUsageFlagBits(VkBufferUsageFlagBits obj,const std::string & str,bool commaNeeded=true)2896 static void print_VkBufferUsageFlagBits(VkBufferUsageFlagBits obj, const std::string &str, bool commaNeeded = true)
2897 {
2898     PRINT_SPACE
2899     if (str != "")
2900         _OUT << "\"" << str << "\""
2901              << " : ";
2902     if (commaNeeded)
2903         _OUT << "\"" << VkBufferUsageFlagBits_map[obj] << "\"," << std::endl;
2904     else
2905         _OUT << "\"" << VkBufferUsageFlagBits_map[obj] << "\"" << std::endl;
2906 }
print_VkBufferUsageFlagBits(const VkBufferUsageFlagBits * obj,const std::string & str,bool commaNeeded=true)2907 static void print_VkBufferUsageFlagBits(const VkBufferUsageFlagBits *obj, const std::string &str,
2908                                         bool commaNeeded = true)
2909 {
2910     PRINT_SPACE
2911     if (str != "")
2912         _OUT << "\"" << str << "\""
2913              << " : ";
2914     if (commaNeeded)
2915         _OUT << "\"" << VkBufferUsageFlagBits_map[*obj] << "\"," << std::endl;
2916     else
2917         _OUT << "\"" << VkBufferUsageFlagBits_map[*obj] << "\"" << std::endl;
2918 }
2919 
2920 static std::map<uint64_t, std::string> VkSharingMode_map = {
2921     std::make_pair(0, "VK_SHARING_MODE_EXCLUSIVE"),
2922     std::make_pair(1, "VK_SHARING_MODE_CONCURRENT"),
2923 };
print_VkSharingMode(VkSharingMode obj,const std::string & str,bool commaNeeded=true)2924 static void print_VkSharingMode(VkSharingMode obj, const std::string &str, bool commaNeeded = true)
2925 {
2926     PRINT_SPACE
2927     if (str != "")
2928         _OUT << "\"" << str << "\""
2929              << " : ";
2930     if (commaNeeded)
2931         _OUT << "\"" << VkSharingMode_map[obj] << "\"," << std::endl;
2932     else
2933         _OUT << "\"" << VkSharingMode_map[obj] << "\"" << std::endl;
2934 }
print_VkSharingMode(const VkSharingMode * obj,const std::string & str,bool commaNeeded=true)2935 static void print_VkSharingMode(const VkSharingMode *obj, const std::string &str, bool commaNeeded = true)
2936 {
2937     PRINT_SPACE
2938     if (str != "")
2939         _OUT << "\"" << str << "\""
2940              << " : ";
2941     if (commaNeeded)
2942         _OUT << "\"" << VkSharingMode_map[*obj] << "\"," << std::endl;
2943     else
2944         _OUT << "\"" << VkSharingMode_map[*obj] << "\"" << std::endl;
2945 }
2946 
2947 static std::map<uint64_t, std::string> VkComponentSwizzle_map = {
2948     std::make_pair(0, "VK_COMPONENT_SWIZZLE_IDENTITY"), std::make_pair(1, "VK_COMPONENT_SWIZZLE_ZERO"),
2949     std::make_pair(2, "VK_COMPONENT_SWIZZLE_ONE"),      std::make_pair(3, "VK_COMPONENT_SWIZZLE_R"),
2950     std::make_pair(4, "VK_COMPONENT_SWIZZLE_G"),        std::make_pair(5, "VK_COMPONENT_SWIZZLE_B"),
2951     std::make_pair(6, "VK_COMPONENT_SWIZZLE_A"),
2952 };
print_VkComponentSwizzle(VkComponentSwizzle obj,const std::string & str,bool commaNeeded=true)2953 static void print_VkComponentSwizzle(VkComponentSwizzle obj, const std::string &str, bool commaNeeded = true)
2954 {
2955     PRINT_SPACE
2956     if (str != "")
2957         _OUT << "\"" << str << "\""
2958              << " : ";
2959     if (commaNeeded)
2960         _OUT << "\"" << VkComponentSwizzle_map[obj] << "\"," << std::endl;
2961     else
2962         _OUT << "\"" << VkComponentSwizzle_map[obj] << "\"" << std::endl;
2963 }
print_VkComponentSwizzle(const VkComponentSwizzle * obj,const std::string & str,bool commaNeeded=true)2964 static void print_VkComponentSwizzle(const VkComponentSwizzle *obj, const std::string &str, bool commaNeeded = true)
2965 {
2966     PRINT_SPACE
2967     if (str != "")
2968         _OUT << "\"" << str << "\""
2969              << " : ";
2970     if (commaNeeded)
2971         _OUT << "\"" << VkComponentSwizzle_map[*obj] << "\"," << std::endl;
2972     else
2973         _OUT << "\"" << VkComponentSwizzle_map[*obj] << "\"" << std::endl;
2974 }
2975 
2976 static std::map<uint64_t, std::string> VkImageViewCreateFlagBits_map = {
2977     std::make_pair(1ULL << 0, "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT"),
2978     std::make_pair(1ULL << 1, "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT"),
2979 };
print_VkImageViewCreateFlagBits(VkImageViewCreateFlagBits obj,const std::string & str,bool commaNeeded=true)2980 static void print_VkImageViewCreateFlagBits(VkImageViewCreateFlagBits obj, const std::string &str,
2981                                             bool commaNeeded = true)
2982 {
2983     PRINT_SPACE
2984     if (str != "")
2985         _OUT << "\"" << str << "\""
2986              << " : ";
2987     if (commaNeeded)
2988         _OUT << "\"" << VkImageViewCreateFlagBits_map[obj] << "\"," << std::endl;
2989     else
2990         _OUT << "\"" << VkImageViewCreateFlagBits_map[obj] << "\"" << std::endl;
2991 }
print_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)2992 static void print_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits *obj, const std::string &str,
2993                                             bool commaNeeded = true)
2994 {
2995     PRINT_SPACE
2996     if (str != "")
2997         _OUT << "\"" << str << "\""
2998              << " : ";
2999     if (commaNeeded)
3000         _OUT << "\"" << VkImageViewCreateFlagBits_map[*obj] << "\"," << std::endl;
3001     else
3002         _OUT << "\"" << VkImageViewCreateFlagBits_map[*obj] << "\"" << std::endl;
3003 }
3004 
3005 static std::map<uint64_t, std::string> VkImageViewType_map = {
3006     std::make_pair(0, "VK_IMAGE_VIEW_TYPE_1D"),         std::make_pair(1, "VK_IMAGE_VIEW_TYPE_2D"),
3007     std::make_pair(2, "VK_IMAGE_VIEW_TYPE_3D"),         std::make_pair(3, "VK_IMAGE_VIEW_TYPE_CUBE"),
3008     std::make_pair(4, "VK_IMAGE_VIEW_TYPE_1D_ARRAY"),   std::make_pair(5, "VK_IMAGE_VIEW_TYPE_2D_ARRAY"),
3009     std::make_pair(6, "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY"),
3010 };
print_VkImageViewType(VkImageViewType obj,const std::string & str,bool commaNeeded=true)3011 static void print_VkImageViewType(VkImageViewType obj, const std::string &str, bool commaNeeded = true)
3012 {
3013     PRINT_SPACE
3014     if (str != "")
3015         _OUT << "\"" << str << "\""
3016              << " : ";
3017     if (commaNeeded)
3018         _OUT << "\"" << VkImageViewType_map[obj] << "\"," << std::endl;
3019     else
3020         _OUT << "\"" << VkImageViewType_map[obj] << "\"" << std::endl;
3021 }
print_VkImageViewType(const VkImageViewType * obj,const std::string & str,bool commaNeeded=true)3022 static void print_VkImageViewType(const VkImageViewType *obj, const std::string &str, bool commaNeeded = true)
3023 {
3024     PRINT_SPACE
3025     if (str != "")
3026         _OUT << "\"" << str << "\""
3027              << " : ";
3028     if (commaNeeded)
3029         _OUT << "\"" << VkImageViewType_map[*obj] << "\"," << std::endl;
3030     else
3031         _OUT << "\"" << VkImageViewType_map[*obj] << "\"" << std::endl;
3032 }
3033 
3034 static std::map<uint64_t, std::string> VkPipelineCacheCreateFlagBits_map = {
3035     std::make_pair(1ULL << 2, "VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT"),
3036     std::make_pair(1ULL << 1, "VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT"),
3037     std::make_pair(1ULL << 0, "VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT"),
3038 };
print_VkPipelineCacheCreateFlagBits(VkPipelineCacheCreateFlagBits obj,const std::string & str,bool commaNeeded=true)3039 static void print_VkPipelineCacheCreateFlagBits(VkPipelineCacheCreateFlagBits obj, const std::string &str,
3040                                                 bool commaNeeded = true)
3041 {
3042     PRINT_SPACE
3043     if (str != "")
3044         _OUT << "\"" << str << "\""
3045              << " : ";
3046     if (commaNeeded)
3047         _OUT << "\"" << VkPipelineCacheCreateFlagBits_map[obj] << "\"," << std::endl;
3048     else
3049         _OUT << "\"" << VkPipelineCacheCreateFlagBits_map[obj] << "\"" << std::endl;
3050 }
print_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)3051 static void print_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits *obj, const std::string &str,
3052                                                 bool commaNeeded = true)
3053 {
3054     PRINT_SPACE
3055     if (str != "")
3056         _OUT << "\"" << str << "\""
3057              << " : ";
3058     if (commaNeeded)
3059         _OUT << "\"" << VkPipelineCacheCreateFlagBits_map[*obj] << "\"," << std::endl;
3060     else
3061         _OUT << "\"" << VkPipelineCacheCreateFlagBits_map[*obj] << "\"" << std::endl;
3062 }
3063 
3064 static std::map<uint64_t, std::string> VkBlendFactor_map = {
3065     std::make_pair(0, "VK_BLEND_FACTOR_ZERO"),
3066     std::make_pair(1, "VK_BLEND_FACTOR_ONE"),
3067     std::make_pair(2, "VK_BLEND_FACTOR_SRC_COLOR"),
3068     std::make_pair(3, "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR"),
3069     std::make_pair(4, "VK_BLEND_FACTOR_DST_COLOR"),
3070     std::make_pair(5, "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR"),
3071     std::make_pair(6, "VK_BLEND_FACTOR_SRC_ALPHA"),
3072     std::make_pair(7, "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA"),
3073     std::make_pair(8, "VK_BLEND_FACTOR_DST_ALPHA"),
3074     std::make_pair(9, "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA"),
3075     std::make_pair(10, "VK_BLEND_FACTOR_CONSTANT_COLOR"),
3076     std::make_pair(11, "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR"),
3077     std::make_pair(12, "VK_BLEND_FACTOR_CONSTANT_ALPHA"),
3078     std::make_pair(13, "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA"),
3079     std::make_pair(14, "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE"),
3080     std::make_pair(15, "VK_BLEND_FACTOR_SRC1_COLOR"),
3081     std::make_pair(16, "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR"),
3082     std::make_pair(17, "VK_BLEND_FACTOR_SRC1_ALPHA"),
3083     std::make_pair(18, "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA"),
3084 };
print_VkBlendFactor(VkBlendFactor obj,const std::string & str,bool commaNeeded=true)3085 static void print_VkBlendFactor(VkBlendFactor obj, const std::string &str, bool commaNeeded = true)
3086 {
3087     PRINT_SPACE
3088     if (str != "")
3089         _OUT << "\"" << str << "\""
3090              << " : ";
3091     if (commaNeeded)
3092         _OUT << "\"" << VkBlendFactor_map[obj] << "\"," << std::endl;
3093     else
3094         _OUT << "\"" << VkBlendFactor_map[obj] << "\"" << std::endl;
3095 }
print_VkBlendFactor(const VkBlendFactor * obj,const std::string & str,bool commaNeeded=true)3096 static void print_VkBlendFactor(const VkBlendFactor *obj, const std::string &str, bool commaNeeded = true)
3097 {
3098     PRINT_SPACE
3099     if (str != "")
3100         _OUT << "\"" << str << "\""
3101              << " : ";
3102     if (commaNeeded)
3103         _OUT << "\"" << VkBlendFactor_map[*obj] << "\"," << std::endl;
3104     else
3105         _OUT << "\"" << VkBlendFactor_map[*obj] << "\"" << std::endl;
3106 }
3107 
3108 static std::map<uint64_t, std::string> VkBlendOp_map = {
3109     std::make_pair(0, "VK_BLEND_OP_ADD"),
3110     std::make_pair(1, "VK_BLEND_OP_SUBTRACT"),
3111     std::make_pair(2, "VK_BLEND_OP_REVERSE_SUBTRACT"),
3112     std::make_pair(3, "VK_BLEND_OP_MIN"),
3113     std::make_pair(4, "VK_BLEND_OP_MAX"),
3114     std::make_pair(1000148000, "VK_BLEND_OP_ZERO_EXT"),
3115     std::make_pair(1000148001, "VK_BLEND_OP_SRC_EXT"),
3116     std::make_pair(1000148002, "VK_BLEND_OP_DST_EXT"),
3117     std::make_pair(1000148003, "VK_BLEND_OP_SRC_OVER_EXT"),
3118     std::make_pair(1000148004, "VK_BLEND_OP_DST_OVER_EXT"),
3119     std::make_pair(1000148005, "VK_BLEND_OP_SRC_IN_EXT"),
3120     std::make_pair(1000148006, "VK_BLEND_OP_DST_IN_EXT"),
3121     std::make_pair(1000148007, "VK_BLEND_OP_SRC_OUT_EXT"),
3122     std::make_pair(1000148008, "VK_BLEND_OP_DST_OUT_EXT"),
3123     std::make_pair(1000148009, "VK_BLEND_OP_SRC_ATOP_EXT"),
3124     std::make_pair(1000148010, "VK_BLEND_OP_DST_ATOP_EXT"),
3125     std::make_pair(1000148011, "VK_BLEND_OP_XOR_EXT"),
3126     std::make_pair(1000148012, "VK_BLEND_OP_MULTIPLY_EXT"),
3127     std::make_pair(1000148013, "VK_BLEND_OP_SCREEN_EXT"),
3128     std::make_pair(1000148014, "VK_BLEND_OP_OVERLAY_EXT"),
3129     std::make_pair(1000148015, "VK_BLEND_OP_DARKEN_EXT"),
3130     std::make_pair(1000148016, "VK_BLEND_OP_LIGHTEN_EXT"),
3131     std::make_pair(1000148017, "VK_BLEND_OP_COLORDODGE_EXT"),
3132     std::make_pair(1000148018, "VK_BLEND_OP_COLORBURN_EXT"),
3133     std::make_pair(1000148019, "VK_BLEND_OP_HARDLIGHT_EXT"),
3134     std::make_pair(1000148020, "VK_BLEND_OP_SOFTLIGHT_EXT"),
3135     std::make_pair(1000148021, "VK_BLEND_OP_DIFFERENCE_EXT"),
3136     std::make_pair(1000148022, "VK_BLEND_OP_EXCLUSION_EXT"),
3137     std::make_pair(1000148023, "VK_BLEND_OP_INVERT_EXT"),
3138     std::make_pair(1000148024, "VK_BLEND_OP_INVERT_RGB_EXT"),
3139     std::make_pair(1000148025, "VK_BLEND_OP_LINEARDODGE_EXT"),
3140     std::make_pair(1000148026, "VK_BLEND_OP_LINEARBURN_EXT"),
3141     std::make_pair(1000148027, "VK_BLEND_OP_VIVIDLIGHT_EXT"),
3142     std::make_pair(1000148028, "VK_BLEND_OP_LINEARLIGHT_EXT"),
3143     std::make_pair(1000148029, "VK_BLEND_OP_PINLIGHT_EXT"),
3144     std::make_pair(1000148030, "VK_BLEND_OP_HARDMIX_EXT"),
3145     std::make_pair(1000148031, "VK_BLEND_OP_HSL_HUE_EXT"),
3146     std::make_pair(1000148032, "VK_BLEND_OP_HSL_SATURATION_EXT"),
3147     std::make_pair(1000148033, "VK_BLEND_OP_HSL_COLOR_EXT"),
3148     std::make_pair(1000148034, "VK_BLEND_OP_HSL_LUMINOSITY_EXT"),
3149     std::make_pair(1000148035, "VK_BLEND_OP_PLUS_EXT"),
3150     std::make_pair(1000148036, "VK_BLEND_OP_PLUS_CLAMPED_EXT"),
3151     std::make_pair(1000148037, "VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT"),
3152     std::make_pair(1000148038, "VK_BLEND_OP_PLUS_DARKER_EXT"),
3153     std::make_pair(1000148039, "VK_BLEND_OP_MINUS_EXT"),
3154     std::make_pair(1000148040, "VK_BLEND_OP_MINUS_CLAMPED_EXT"),
3155     std::make_pair(1000148041, "VK_BLEND_OP_CONTRAST_EXT"),
3156     std::make_pair(1000148042, "VK_BLEND_OP_INVERT_OVG_EXT"),
3157     std::make_pair(1000148043, "VK_BLEND_OP_RED_EXT"),
3158     std::make_pair(1000148044, "VK_BLEND_OP_GREEN_EXT"),
3159     std::make_pair(1000148045, "VK_BLEND_OP_BLUE_EXT"),
3160 };
print_VkBlendOp(VkBlendOp obj,const std::string & str,bool commaNeeded=true)3161 static void print_VkBlendOp(VkBlendOp obj, const std::string &str, bool commaNeeded = true)
3162 {
3163     PRINT_SPACE
3164     if (str != "")
3165         _OUT << "\"" << str << "\""
3166              << " : ";
3167     if (commaNeeded)
3168         _OUT << "\"" << VkBlendOp_map[obj] << "\"," << std::endl;
3169     else
3170         _OUT << "\"" << VkBlendOp_map[obj] << "\"" << std::endl;
3171 }
print_VkBlendOp(const VkBlendOp * obj,const std::string & str,bool commaNeeded=true)3172 static void print_VkBlendOp(const VkBlendOp *obj, const std::string &str, bool commaNeeded = true)
3173 {
3174     PRINT_SPACE
3175     if (str != "")
3176         _OUT << "\"" << str << "\""
3177              << " : ";
3178     if (commaNeeded)
3179         _OUT << "\"" << VkBlendOp_map[*obj] << "\"," << std::endl;
3180     else
3181         _OUT << "\"" << VkBlendOp_map[*obj] << "\"" << std::endl;
3182 }
3183 
3184 static std::map<uint64_t, std::string> VkColorComponentFlagBits_map = {
3185     std::make_pair(1ULL << 0, "VK_COLOR_COMPONENT_R_BIT"),
3186     std::make_pair(1ULL << 1, "VK_COLOR_COMPONENT_G_BIT"),
3187     std::make_pair(1ULL << 2, "VK_COLOR_COMPONENT_B_BIT"),
3188     std::make_pair(1ULL << 3, "VK_COLOR_COMPONENT_A_BIT"),
3189 };
print_VkColorComponentFlagBits(VkColorComponentFlagBits obj,const std::string & str,bool commaNeeded=true)3190 static void print_VkColorComponentFlagBits(VkColorComponentFlagBits obj, const std::string &str,
3191                                            bool commaNeeded = true)
3192 {
3193     PRINT_SPACE
3194     if (str != "")
3195         _OUT << "\"" << str << "\""
3196              << " : ";
3197     if (commaNeeded)
3198         _OUT << "\"" << VkColorComponentFlagBits_map[obj] << "\"," << std::endl;
3199     else
3200         _OUT << "\"" << VkColorComponentFlagBits_map[obj] << "\"" << std::endl;
3201 }
print_VkColorComponentFlagBits(const VkColorComponentFlagBits * obj,const std::string & str,bool commaNeeded=true)3202 static void print_VkColorComponentFlagBits(const VkColorComponentFlagBits *obj, const std::string &str,
3203                                            bool commaNeeded = true)
3204 {
3205     PRINT_SPACE
3206     if (str != "")
3207         _OUT << "\"" << str << "\""
3208              << " : ";
3209     if (commaNeeded)
3210         _OUT << "\"" << VkColorComponentFlagBits_map[*obj] << "\"," << std::endl;
3211     else
3212         _OUT << "\"" << VkColorComponentFlagBits_map[*obj] << "\"" << std::endl;
3213 }
3214 
3215 static std::map<uint64_t, std::string> VkCompareOp_map = {
3216     std::make_pair(0, "VK_COMPARE_OP_NEVER"),
3217     std::make_pair(1, "VK_COMPARE_OP_LESS"),
3218     std::make_pair(2, "VK_COMPARE_OP_EQUAL"),
3219     std::make_pair(3, "VK_COMPARE_OP_LESS_OR_EQUAL"),
3220     std::make_pair(4, "VK_COMPARE_OP_GREATER"),
3221     std::make_pair(5, "VK_COMPARE_OP_NOT_EQUAL"),
3222     std::make_pair(6, "VK_COMPARE_OP_GREATER_OR_EQUAL"),
3223     std::make_pair(7, "VK_COMPARE_OP_ALWAYS"),
3224 };
print_VkCompareOp(VkCompareOp obj,const std::string & str,bool commaNeeded=true)3225 static void print_VkCompareOp(VkCompareOp obj, const std::string &str, bool commaNeeded = true)
3226 {
3227     PRINT_SPACE
3228     if (str != "")
3229         _OUT << "\"" << str << "\""
3230              << " : ";
3231     if (commaNeeded)
3232         _OUT << "\"" << VkCompareOp_map[obj] << "\"," << std::endl;
3233     else
3234         _OUT << "\"" << VkCompareOp_map[obj] << "\"" << std::endl;
3235 }
print_VkCompareOp(const VkCompareOp * obj,const std::string & str,bool commaNeeded=true)3236 static void print_VkCompareOp(const VkCompareOp *obj, const std::string &str, bool commaNeeded = true)
3237 {
3238     PRINT_SPACE
3239     if (str != "")
3240         _OUT << "\"" << str << "\""
3241              << " : ";
3242     if (commaNeeded)
3243         _OUT << "\"" << VkCompareOp_map[*obj] << "\"," << std::endl;
3244     else
3245         _OUT << "\"" << VkCompareOp_map[*obj] << "\"" << std::endl;
3246 }
3247 
3248 static std::map<uint64_t, std::string> VkPipelineCreateFlagBits_map = {
3249     std::make_pair(1ULL << 0, "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"),
3250     std::make_pair(1ULL << 3, "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"),
3251     std::make_pair(1ULL << 4, "VK_PIPELINE_CREATE_DISPATCH_BASE_BIT"),
3252     std::make_pair(1ULL << 21, "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"),
3253     std::make_pair(1ULL << 22, "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"),
3254     std::make_pair(1ULL << 14, "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"),
3255     std::make_pair(1ULL << 15, "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"),
3256     std::make_pair(1ULL << 16, "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"),
3257     std::make_pair(1ULL << 17, "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"),
3258     std::make_pair(1ULL << 12, "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"),
3259     std::make_pair(1ULL << 13, "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR"),
3260     std::make_pair(1ULL << 19, "VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"),
3261     std::make_pair(1ULL << 5, "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV"),
3262     std::make_pair(1ULL << 6, "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR"),
3263     std::make_pair(1ULL << 7, "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"),
3264     std::make_pair(1ULL << 18, "VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV"),
3265     std::make_pair(1ULL << 11, "VK_PIPELINE_CREATE_LIBRARY_BIT_KHR"),
3266     std::make_pair(1ULL << 8, "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT"),
3267     std::make_pair(1ULL << 9, "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT"),
3268     std::make_pair(1ULL << 23, "VK_PIPELINE_CREATE_RESERVED_23_BIT_AMD"),
3269     std::make_pair(1ULL << 10, "VK_PIPELINE_CREATE_RESERVED_10_BIT_AMD"),
3270     std::make_pair(1ULL << 20, "VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV"),
3271 };
print_VkPipelineCreateFlagBits(VkPipelineCreateFlagBits obj,const std::string & str,bool commaNeeded=true)3272 static void print_VkPipelineCreateFlagBits(VkPipelineCreateFlagBits obj, const std::string &str,
3273                                            bool commaNeeded = true)
3274 {
3275     PRINT_SPACE
3276     if (str != "")
3277         _OUT << "\"" << str << "\""
3278              << " : ";
3279     if (commaNeeded)
3280         _OUT << "\"" << VkPipelineCreateFlagBits_map[obj] << "\"," << std::endl;
3281     else
3282         _OUT << "\"" << VkPipelineCreateFlagBits_map[obj] << "\"" << std::endl;
3283 }
print_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)3284 static void print_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits *obj, const std::string &str,
3285                                            bool commaNeeded = true)
3286 {
3287     PRINT_SPACE
3288     if (str != "")
3289         _OUT << "\"" << str << "\""
3290              << " : ";
3291     if (commaNeeded)
3292         _OUT << "\"" << VkPipelineCreateFlagBits_map[*obj] << "\"," << std::endl;
3293     else
3294         _OUT << "\"" << VkPipelineCreateFlagBits_map[*obj] << "\"" << std::endl;
3295 }
3296 
3297 static std::map<uint64_t, std::string> VkPipelineShaderStageCreateFlagBits_map = {
3298     std::make_pair(1ULL << 0, "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT"),
3299     std::make_pair(1ULL << 1, "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT"),
3300     std::make_pair(1ULL << 3, "VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_3_BIT_KHR"),
3301 };
print_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits obj,const std::string & str,bool commaNeeded=true)3302 static void print_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits obj, const std::string &str,
3303                                                       bool commaNeeded = true)
3304 {
3305     PRINT_SPACE
3306     if (str != "")
3307         _OUT << "\"" << str << "\""
3308              << " : ";
3309     if (commaNeeded)
3310         _OUT << "\"" << VkPipelineShaderStageCreateFlagBits_map[obj] << "\"," << std::endl;
3311     else
3312         _OUT << "\"" << VkPipelineShaderStageCreateFlagBits_map[obj] << "\"" << std::endl;
3313 }
print_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)3314 static void print_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits *obj,
3315                                                       const std::string &str, bool commaNeeded = true)
3316 {
3317     PRINT_SPACE
3318     if (str != "")
3319         _OUT << "\"" << str << "\""
3320              << " : ";
3321     if (commaNeeded)
3322         _OUT << "\"" << VkPipelineShaderStageCreateFlagBits_map[*obj] << "\"," << std::endl;
3323     else
3324         _OUT << "\"" << VkPipelineShaderStageCreateFlagBits_map[*obj] << "\"" << std::endl;
3325 }
3326 
3327 static std::map<uint64_t, std::string> VkShaderStageFlagBits_map = {
3328     std::make_pair(1ULL << 0, "VK_SHADER_STAGE_VERTEX_BIT"),
3329     std::make_pair(1ULL << 1, "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT"),
3330     std::make_pair(1ULL << 2, "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT"),
3331     std::make_pair(1ULL << 3, "VK_SHADER_STAGE_GEOMETRY_BIT"),
3332     std::make_pair(1ULL << 4, "VK_SHADER_STAGE_FRAGMENT_BIT"),
3333     std::make_pair(1ULL << 5, "VK_SHADER_STAGE_COMPUTE_BIT"),
3334     std::make_pair(0x0000001F, "VK_SHADER_STAGE_ALL_GRAPHICS"),
3335     std::make_pair(0x7FFFFFFF, "VK_SHADER_STAGE_ALL"),
3336     std::make_pair(1ULL << 8, "VK_SHADER_STAGE_RAYGEN_BIT_KHR"),
3337     std::make_pair(1ULL << 9, "VK_SHADER_STAGE_ANY_HIT_BIT_KHR"),
3338     std::make_pair(1ULL << 10, "VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR"),
3339     std::make_pair(1ULL << 11, "VK_SHADER_STAGE_MISS_BIT_KHR"),
3340     std::make_pair(1ULL << 12, "VK_SHADER_STAGE_INTERSECTION_BIT_KHR"),
3341     std::make_pair(1ULL << 13, "VK_SHADER_STAGE_CALLABLE_BIT_KHR"),
3342     std::make_pair(1ULL << 6, "VK_SHADER_STAGE_TASK_BIT_NV"),
3343     std::make_pair(1ULL << 7, "VK_SHADER_STAGE_MESH_BIT_NV"),
3344     std::make_pair(1ULL << 14, "VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI"),
3345 };
print_VkShaderStageFlagBits(VkShaderStageFlagBits obj,const std::string & str,bool commaNeeded=true)3346 static void print_VkShaderStageFlagBits(VkShaderStageFlagBits obj, const std::string &str, bool commaNeeded = true)
3347 {
3348     PRINT_SPACE
3349     if (str != "")
3350         _OUT << "\"" << str << "\""
3351              << " : ";
3352     if (commaNeeded)
3353         _OUT << "\"" << VkShaderStageFlagBits_map[obj] << "\"," << std::endl;
3354     else
3355         _OUT << "\"" << VkShaderStageFlagBits_map[obj] << "\"" << std::endl;
3356 }
print_VkShaderStageFlagBits(const VkShaderStageFlagBits * obj,const std::string & str,bool commaNeeded=true)3357 static void print_VkShaderStageFlagBits(const VkShaderStageFlagBits *obj, const std::string &str,
3358                                         bool commaNeeded = true)
3359 {
3360     PRINT_SPACE
3361     if (str != "")
3362         _OUT << "\"" << str << "\""
3363              << " : ";
3364     if (commaNeeded)
3365         _OUT << "\"" << VkShaderStageFlagBits_map[*obj] << "\"," << std::endl;
3366     else
3367         _OUT << "\"" << VkShaderStageFlagBits_map[*obj] << "\"" << std::endl;
3368 }
3369 
3370 static std::map<uint64_t, std::string> VkCullModeFlagBits_map = {
3371     std::make_pair(0, "VK_CULL_MODE_NONE"),
3372     std::make_pair(1ULL << 0, "VK_CULL_MODE_FRONT_BIT"),
3373     std::make_pair(1ULL << 1, "VK_CULL_MODE_BACK_BIT"),
3374     std::make_pair(0x00000003, "VK_CULL_MODE_FRONT_AND_BACK"),
3375 };
print_VkCullModeFlagBits(VkCullModeFlagBits obj,const std::string & str,bool commaNeeded=true)3376 static void print_VkCullModeFlagBits(VkCullModeFlagBits obj, const std::string &str, bool commaNeeded = true)
3377 {
3378     PRINT_SPACE
3379     if (str != "")
3380         _OUT << "\"" << str << "\""
3381              << " : ";
3382     if (commaNeeded)
3383         _OUT << "\"" << VkCullModeFlagBits_map[obj] << "\"," << std::endl;
3384     else
3385         _OUT << "\"" << VkCullModeFlagBits_map[obj] << "\"" << std::endl;
3386 }
print_VkCullModeFlagBits(const VkCullModeFlagBits * obj,const std::string & str,bool commaNeeded=true)3387 static void print_VkCullModeFlagBits(const VkCullModeFlagBits *obj, const std::string &str, bool commaNeeded = true)
3388 {
3389     PRINT_SPACE
3390     if (str != "")
3391         _OUT << "\"" << str << "\""
3392              << " : ";
3393     if (commaNeeded)
3394         _OUT << "\"" << VkCullModeFlagBits_map[*obj] << "\"," << std::endl;
3395     else
3396         _OUT << "\"" << VkCullModeFlagBits_map[*obj] << "\"" << std::endl;
3397 }
3398 
3399 static std::map<uint64_t, std::string> VkDynamicState_map = {
3400     std::make_pair(0, "VK_DYNAMIC_STATE_VIEWPORT"),
3401     std::make_pair(1, "VK_DYNAMIC_STATE_SCISSOR"),
3402     std::make_pair(2, "VK_DYNAMIC_STATE_LINE_WIDTH"),
3403     std::make_pair(3, "VK_DYNAMIC_STATE_DEPTH_BIAS"),
3404     std::make_pair(4, "VK_DYNAMIC_STATE_BLEND_CONSTANTS"),
3405     std::make_pair(5, "VK_DYNAMIC_STATE_DEPTH_BOUNDS"),
3406     std::make_pair(6, "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK"),
3407     std::make_pair(7, "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK"),
3408     std::make_pair(8, "VK_DYNAMIC_STATE_STENCIL_REFERENCE"),
3409     std::make_pair(1000087000, "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV"),
3410     std::make_pair(1000099000, "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT"),
3411     std::make_pair(1000143000, "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT"),
3412     std::make_pair(1000347000, "VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR"),
3413     std::make_pair(1000164004, "VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV"),
3414     std::make_pair(1000164006, "VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV"),
3415     std::make_pair(1000205001, "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV"),
3416     std::make_pair(1000226000, "VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR"),
3417     std::make_pair(1000259000, "VK_DYNAMIC_STATE_LINE_STIPPLE_EXT"),
3418     std::make_pair(1000267000, "VK_DYNAMIC_STATE_CULL_MODE_EXT"),
3419     std::make_pair(1000267001, "VK_DYNAMIC_STATE_FRONT_FACE_EXT"),
3420     std::make_pair(1000267002, "VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT"),
3421     std::make_pair(1000267003, "VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT"),
3422     std::make_pair(1000267004, "VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT"),
3423     std::make_pair(1000267005, "VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT"),
3424     std::make_pair(1000267006, "VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT"),
3425     std::make_pair(1000267007, "VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT"),
3426     std::make_pair(1000267008, "VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT"),
3427     std::make_pair(1000267009, "VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT"),
3428     std::make_pair(1000267010, "VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT"),
3429     std::make_pair(1000267011, "VK_DYNAMIC_STATE_STENCIL_OP_EXT"),
3430     std::make_pair(1000352000, "VK_DYNAMIC_STATE_VERTEX_INPUT_EXT"),
3431     std::make_pair(1000377000, "VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT"),
3432     std::make_pair(1000377001, "VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT"),
3433     std::make_pair(1000377002, "VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT"),
3434     std::make_pair(1000377003, "VK_DYNAMIC_STATE_LOGIC_OP_EXT"),
3435     std::make_pair(1000377004, "VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT"),
3436     std::make_pair(1000381000, "VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT"),
3437 };
print_VkDynamicState(VkDynamicState obj,const std::string & str,bool commaNeeded=true)3438 static void print_VkDynamicState(VkDynamicState obj, const std::string &str, bool commaNeeded = true)
3439 {
3440     PRINT_SPACE
3441     if (str != "")
3442         _OUT << "\"" << str << "\""
3443              << " : ";
3444     if (commaNeeded)
3445         _OUT << "\"" << VkDynamicState_map[obj] << "\"," << std::endl;
3446     else
3447         _OUT << "\"" << VkDynamicState_map[obj] << "\"" << std::endl;
3448 }
print_VkDynamicState(const VkDynamicState * obj,const std::string & str,bool commaNeeded=true)3449 static void print_VkDynamicState(const VkDynamicState *obj, const std::string &str, bool commaNeeded = true)
3450 {
3451     PRINT_SPACE
3452     if (str != "")
3453         _OUT << "\"" << str << "\""
3454              << " : ";
3455     if (commaNeeded)
3456         _OUT << "\"" << VkDynamicState_map[*obj] << "\"," << std::endl;
3457     else
3458         _OUT << "\"" << VkDynamicState_map[*obj] << "\"" << std::endl;
3459 }
3460 
3461 static std::map<uint64_t, std::string> VkFrontFace_map = {
3462     std::make_pair(0, "VK_FRONT_FACE_COUNTER_CLOCKWISE"),
3463     std::make_pair(1, "VK_FRONT_FACE_CLOCKWISE"),
3464 };
print_VkFrontFace(VkFrontFace obj,const std::string & str,bool commaNeeded=true)3465 static void print_VkFrontFace(VkFrontFace obj, const std::string &str, bool commaNeeded = true)
3466 {
3467     PRINT_SPACE
3468     if (str != "")
3469         _OUT << "\"" << str << "\""
3470              << " : ";
3471     if (commaNeeded)
3472         _OUT << "\"" << VkFrontFace_map[obj] << "\"," << std::endl;
3473     else
3474         _OUT << "\"" << VkFrontFace_map[obj] << "\"" << std::endl;
3475 }
print_VkFrontFace(const VkFrontFace * obj,const std::string & str,bool commaNeeded=true)3476 static void print_VkFrontFace(const VkFrontFace *obj, const std::string &str, bool commaNeeded = true)
3477 {
3478     PRINT_SPACE
3479     if (str != "")
3480         _OUT << "\"" << str << "\""
3481              << " : ";
3482     if (commaNeeded)
3483         _OUT << "\"" << VkFrontFace_map[*obj] << "\"," << std::endl;
3484     else
3485         _OUT << "\"" << VkFrontFace_map[*obj] << "\"" << std::endl;
3486 }
3487 
3488 static std::map<uint64_t, std::string> VkVertexInputRate_map = {
3489     std::make_pair(0, "VK_VERTEX_INPUT_RATE_VERTEX"),
3490     std::make_pair(1, "VK_VERTEX_INPUT_RATE_INSTANCE"),
3491 };
print_VkVertexInputRate(VkVertexInputRate obj,const std::string & str,bool commaNeeded=true)3492 static void print_VkVertexInputRate(VkVertexInputRate obj, const std::string &str, bool commaNeeded = true)
3493 {
3494     PRINT_SPACE
3495     if (str != "")
3496         _OUT << "\"" << str << "\""
3497              << " : ";
3498     if (commaNeeded)
3499         _OUT << "\"" << VkVertexInputRate_map[obj] << "\"," << std::endl;
3500     else
3501         _OUT << "\"" << VkVertexInputRate_map[obj] << "\"" << std::endl;
3502 }
print_VkVertexInputRate(const VkVertexInputRate * obj,const std::string & str,bool commaNeeded=true)3503 static void print_VkVertexInputRate(const VkVertexInputRate *obj, const std::string &str, bool commaNeeded = true)
3504 {
3505     PRINT_SPACE
3506     if (str != "")
3507         _OUT << "\"" << str << "\""
3508              << " : ";
3509     if (commaNeeded)
3510         _OUT << "\"" << VkVertexInputRate_map[*obj] << "\"," << std::endl;
3511     else
3512         _OUT << "\"" << VkVertexInputRate_map[*obj] << "\"" << std::endl;
3513 }
3514 
3515 static std::map<uint64_t, std::string> VkPrimitiveTopology_map = {
3516     std::make_pair(0, "VK_PRIMITIVE_TOPOLOGY_POINT_LIST"),
3517     std::make_pair(1, "VK_PRIMITIVE_TOPOLOGY_LINE_LIST"),
3518     std::make_pair(2, "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP"),
3519     std::make_pair(3, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST"),
3520     std::make_pair(4, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP"),
3521     std::make_pair(5, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN"),
3522     std::make_pair(6, "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY"),
3523     std::make_pair(7, "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY"),
3524     std::make_pair(8, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY"),
3525     std::make_pair(9, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY"),
3526     std::make_pair(10, "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST"),
3527 };
print_VkPrimitiveTopology(VkPrimitiveTopology obj,const std::string & str,bool commaNeeded=true)3528 static void print_VkPrimitiveTopology(VkPrimitiveTopology obj, const std::string &str, bool commaNeeded = true)
3529 {
3530     PRINT_SPACE
3531     if (str != "")
3532         _OUT << "\"" << str << "\""
3533              << " : ";
3534     if (commaNeeded)
3535         _OUT << "\"" << VkPrimitiveTopology_map[obj] << "\"," << std::endl;
3536     else
3537         _OUT << "\"" << VkPrimitiveTopology_map[obj] << "\"" << std::endl;
3538 }
print_VkPrimitiveTopology(const VkPrimitiveTopology * obj,const std::string & str,bool commaNeeded=true)3539 static void print_VkPrimitiveTopology(const VkPrimitiveTopology *obj, const std::string &str, bool commaNeeded = true)
3540 {
3541     PRINT_SPACE
3542     if (str != "")
3543         _OUT << "\"" << str << "\""
3544              << " : ";
3545     if (commaNeeded)
3546         _OUT << "\"" << VkPrimitiveTopology_map[*obj] << "\"," << std::endl;
3547     else
3548         _OUT << "\"" << VkPrimitiveTopology_map[*obj] << "\"" << std::endl;
3549 }
3550 
3551 static std::map<uint64_t, std::string> VkPolygonMode_map = {
3552     std::make_pair(0, "VK_POLYGON_MODE_FILL"),
3553     std::make_pair(1, "VK_POLYGON_MODE_LINE"),
3554     std::make_pair(2, "VK_POLYGON_MODE_POINT"),
3555     std::make_pair(1000153000, "VK_POLYGON_MODE_FILL_RECTANGLE_NV"),
3556 };
print_VkPolygonMode(VkPolygonMode obj,const std::string & str,bool commaNeeded=true)3557 static void print_VkPolygonMode(VkPolygonMode obj, const std::string &str, bool commaNeeded = true)
3558 {
3559     PRINT_SPACE
3560     if (str != "")
3561         _OUT << "\"" << str << "\""
3562              << " : ";
3563     if (commaNeeded)
3564         _OUT << "\"" << VkPolygonMode_map[obj] << "\"," << std::endl;
3565     else
3566         _OUT << "\"" << VkPolygonMode_map[obj] << "\"" << std::endl;
3567 }
print_VkPolygonMode(const VkPolygonMode * obj,const std::string & str,bool commaNeeded=true)3568 static void print_VkPolygonMode(const VkPolygonMode *obj, const std::string &str, bool commaNeeded = true)
3569 {
3570     PRINT_SPACE
3571     if (str != "")
3572         _OUT << "\"" << str << "\""
3573              << " : ";
3574     if (commaNeeded)
3575         _OUT << "\"" << VkPolygonMode_map[*obj] << "\"," << std::endl;
3576     else
3577         _OUT << "\"" << VkPolygonMode_map[*obj] << "\"" << std::endl;
3578 }
3579 
3580 static std::map<uint64_t, std::string> VkStencilOp_map = {
3581     std::make_pair(0, "VK_STENCIL_OP_KEEP"),
3582     std::make_pair(1, "VK_STENCIL_OP_ZERO"),
3583     std::make_pair(2, "VK_STENCIL_OP_REPLACE"),
3584     std::make_pair(3, "VK_STENCIL_OP_INCREMENT_AND_CLAMP"),
3585     std::make_pair(4, "VK_STENCIL_OP_DECREMENT_AND_CLAMP"),
3586     std::make_pair(5, "VK_STENCIL_OP_INVERT"),
3587     std::make_pair(6, "VK_STENCIL_OP_INCREMENT_AND_WRAP"),
3588     std::make_pair(7, "VK_STENCIL_OP_DECREMENT_AND_WRAP"),
3589 };
print_VkStencilOp(VkStencilOp obj,const std::string & str,bool commaNeeded=true)3590 static void print_VkStencilOp(VkStencilOp obj, const std::string &str, bool commaNeeded = true)
3591 {
3592     PRINT_SPACE
3593     if (str != "")
3594         _OUT << "\"" << str << "\""
3595              << " : ";
3596     if (commaNeeded)
3597         _OUT << "\"" << VkStencilOp_map[obj] << "\"," << std::endl;
3598     else
3599         _OUT << "\"" << VkStencilOp_map[obj] << "\"" << std::endl;
3600 }
print_VkStencilOp(const VkStencilOp * obj,const std::string & str,bool commaNeeded=true)3601 static void print_VkStencilOp(const VkStencilOp *obj, const std::string &str, bool commaNeeded = true)
3602 {
3603     PRINT_SPACE
3604     if (str != "")
3605         _OUT << "\"" << str << "\""
3606              << " : ";
3607     if (commaNeeded)
3608         _OUT << "\"" << VkStencilOp_map[*obj] << "\"," << std::endl;
3609     else
3610         _OUT << "\"" << VkStencilOp_map[*obj] << "\"" << std::endl;
3611 }
3612 
3613 static std::map<uint64_t, std::string> VkLogicOp_map = {
3614     std::make_pair(0, "VK_LOGIC_OP_CLEAR"),
3615     std::make_pair(1, "VK_LOGIC_OP_AND"),
3616     std::make_pair(2, "VK_LOGIC_OP_AND_REVERSE"),
3617     std::make_pair(3, "VK_LOGIC_OP_COPY"),
3618     std::make_pair(4, "VK_LOGIC_OP_AND_INVERTED"),
3619     std::make_pair(5, "VK_LOGIC_OP_NO_OP"),
3620     std::make_pair(6, "VK_LOGIC_OP_XOR"),
3621     std::make_pair(7, "VK_LOGIC_OP_OR"),
3622     std::make_pair(8, "VK_LOGIC_OP_NOR"),
3623     std::make_pair(9, "VK_LOGIC_OP_EQUIVALENT"),
3624     std::make_pair(10, "VK_LOGIC_OP_INVERT"),
3625     std::make_pair(11, "VK_LOGIC_OP_OR_REVERSE"),
3626     std::make_pair(12, "VK_LOGIC_OP_COPY_INVERTED"),
3627     std::make_pair(13, "VK_LOGIC_OP_OR_INVERTED"),
3628     std::make_pair(14, "VK_LOGIC_OP_NAND"),
3629     std::make_pair(15, "VK_LOGIC_OP_SET"),
3630 };
print_VkLogicOp(VkLogicOp obj,const std::string & str,bool commaNeeded=true)3631 static void print_VkLogicOp(VkLogicOp obj, const std::string &str, bool commaNeeded = true)
3632 {
3633     PRINT_SPACE
3634     if (str != "")
3635         _OUT << "\"" << str << "\""
3636              << " : ";
3637     if (commaNeeded)
3638         _OUT << "\"" << VkLogicOp_map[obj] << "\"," << std::endl;
3639     else
3640         _OUT << "\"" << VkLogicOp_map[obj] << "\"" << std::endl;
3641 }
print_VkLogicOp(const VkLogicOp * obj,const std::string & str,bool commaNeeded=true)3642 static void print_VkLogicOp(const VkLogicOp *obj, const std::string &str, bool commaNeeded = true)
3643 {
3644     PRINT_SPACE
3645     if (str != "")
3646         _OUT << "\"" << str << "\""
3647              << " : ";
3648     if (commaNeeded)
3649         _OUT << "\"" << VkLogicOp_map[*obj] << "\"," << std::endl;
3650     else
3651         _OUT << "\"" << VkLogicOp_map[*obj] << "\"" << std::endl;
3652 }
3653 
3654 static std::map<uint64_t, std::string> VkBorderColor_map = {
3655     std::make_pair(0, "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK"),
3656     std::make_pair(1, "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK"),
3657     std::make_pair(2, "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK"),
3658     std::make_pair(3, "VK_BORDER_COLOR_INT_OPAQUE_BLACK"),
3659     std::make_pair(4, "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE"),
3660     std::make_pair(5, "VK_BORDER_COLOR_INT_OPAQUE_WHITE"),
3661     std::make_pair(1000287003, "VK_BORDER_COLOR_FLOAT_CUSTOM_EXT"),
3662     std::make_pair(1000287004, "VK_BORDER_COLOR_INT_CUSTOM_EXT"),
3663 };
print_VkBorderColor(VkBorderColor obj,const std::string & str,bool commaNeeded=true)3664 static void print_VkBorderColor(VkBorderColor obj, const std::string &str, bool commaNeeded = true)
3665 {
3666     PRINT_SPACE
3667     if (str != "")
3668         _OUT << "\"" << str << "\""
3669              << " : ";
3670     if (commaNeeded)
3671         _OUT << "\"" << VkBorderColor_map[obj] << "\"," << std::endl;
3672     else
3673         _OUT << "\"" << VkBorderColor_map[obj] << "\"" << std::endl;
3674 }
print_VkBorderColor(const VkBorderColor * obj,const std::string & str,bool commaNeeded=true)3675 static void print_VkBorderColor(const VkBorderColor *obj, const std::string &str, bool commaNeeded = true)
3676 {
3677     PRINT_SPACE
3678     if (str != "")
3679         _OUT << "\"" << str << "\""
3680              << " : ";
3681     if (commaNeeded)
3682         _OUT << "\"" << VkBorderColor_map[*obj] << "\"," << std::endl;
3683     else
3684         _OUT << "\"" << VkBorderColor_map[*obj] << "\"" << std::endl;
3685 }
3686 
3687 static std::map<uint64_t, std::string> VkFilter_map = {
3688     std::make_pair(0, "VK_FILTER_NEAREST"),
3689     std::make_pair(1, "VK_FILTER_LINEAR"),
3690     std::make_pair(1000015000, "VK_FILTER_CUBIC_IMG"),
3691 };
print_VkFilter(VkFilter obj,const std::string & str,bool commaNeeded=true)3692 static void print_VkFilter(VkFilter obj, const std::string &str, bool commaNeeded = true)
3693 {
3694     PRINT_SPACE
3695     if (str != "")
3696         _OUT << "\"" << str << "\""
3697              << " : ";
3698     if (commaNeeded)
3699         _OUT << "\"" << VkFilter_map[obj] << "\"," << std::endl;
3700     else
3701         _OUT << "\"" << VkFilter_map[obj] << "\"" << std::endl;
3702 }
print_VkFilter(const VkFilter * obj,const std::string & str,bool commaNeeded=true)3703 static void print_VkFilter(const VkFilter *obj, const std::string &str, bool commaNeeded = true)
3704 {
3705     PRINT_SPACE
3706     if (str != "")
3707         _OUT << "\"" << str << "\""
3708              << " : ";
3709     if (commaNeeded)
3710         _OUT << "\"" << VkFilter_map[*obj] << "\"," << std::endl;
3711     else
3712         _OUT << "\"" << VkFilter_map[*obj] << "\"" << std::endl;
3713 }
3714 
3715 static std::map<uint64_t, std::string> VkSamplerAddressMode_map = {
3716     std::make_pair(0, "VK_SAMPLER_ADDRESS_MODE_REPEAT"),
3717     std::make_pair(1, "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT"),
3718     std::make_pair(2, "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE"),
3719     std::make_pair(3, "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER"),
3720     std::make_pair(4, "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE"),
3721     std::make_pair(4, "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE"),
3722 };
print_VkSamplerAddressMode(VkSamplerAddressMode obj,const std::string & str,bool commaNeeded=true)3723 static void print_VkSamplerAddressMode(VkSamplerAddressMode obj, const std::string &str, bool commaNeeded = true)
3724 {
3725     PRINT_SPACE
3726     if (str != "")
3727         _OUT << "\"" << str << "\""
3728              << " : ";
3729     if (commaNeeded)
3730         _OUT << "\"" << VkSamplerAddressMode_map[obj] << "\"," << std::endl;
3731     else
3732         _OUT << "\"" << VkSamplerAddressMode_map[obj] << "\"" << std::endl;
3733 }
print_VkSamplerAddressMode(const VkSamplerAddressMode * obj,const std::string & str,bool commaNeeded=true)3734 static void print_VkSamplerAddressMode(const VkSamplerAddressMode *obj, const std::string &str, bool commaNeeded = true)
3735 {
3736     PRINT_SPACE
3737     if (str != "")
3738         _OUT << "\"" << str << "\""
3739              << " : ";
3740     if (commaNeeded)
3741         _OUT << "\"" << VkSamplerAddressMode_map[*obj] << "\"," << std::endl;
3742     else
3743         _OUT << "\"" << VkSamplerAddressMode_map[*obj] << "\"" << std::endl;
3744 }
3745 
3746 static std::map<uint64_t, std::string> VkSamplerCreateFlagBits_map = {
3747     std::make_pair(1ULL << 0, "VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT"),
3748     std::make_pair(1ULL << 1, "VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT"),
3749     std::make_pair(1ULL << 3, "VK_SAMPLER_CREATE_RESERVED_3_BIT_AMD"),
3750     std::make_pair(1ULL << 2, "VK_SAMPLER_CREATE_RESERVED_2_BIT_EXT"),
3751 };
print_VkSamplerCreateFlagBits(VkSamplerCreateFlagBits obj,const std::string & str,bool commaNeeded=true)3752 static void print_VkSamplerCreateFlagBits(VkSamplerCreateFlagBits obj, const std::string &str, bool commaNeeded = true)
3753 {
3754     PRINT_SPACE
3755     if (str != "")
3756         _OUT << "\"" << str << "\""
3757              << " : ";
3758     if (commaNeeded)
3759         _OUT << "\"" << VkSamplerCreateFlagBits_map[obj] << "\"," << std::endl;
3760     else
3761         _OUT << "\"" << VkSamplerCreateFlagBits_map[obj] << "\"" << std::endl;
3762 }
print_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)3763 static void print_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits *obj, const std::string &str,
3764                                           bool commaNeeded = true)
3765 {
3766     PRINT_SPACE
3767     if (str != "")
3768         _OUT << "\"" << str << "\""
3769              << " : ";
3770     if (commaNeeded)
3771         _OUT << "\"" << VkSamplerCreateFlagBits_map[*obj] << "\"," << std::endl;
3772     else
3773         _OUT << "\"" << VkSamplerCreateFlagBits_map[*obj] << "\"" << std::endl;
3774 }
3775 
3776 static std::map<uint64_t, std::string> VkSamplerMipmapMode_map = {
3777     std::make_pair(0, "VK_SAMPLER_MIPMAP_MODE_NEAREST"),
3778     std::make_pair(1, "VK_SAMPLER_MIPMAP_MODE_LINEAR"),
3779 };
print_VkSamplerMipmapMode(VkSamplerMipmapMode obj,const std::string & str,bool commaNeeded=true)3780 static void print_VkSamplerMipmapMode(VkSamplerMipmapMode obj, const std::string &str, bool commaNeeded = true)
3781 {
3782     PRINT_SPACE
3783     if (str != "")
3784         _OUT << "\"" << str << "\""
3785              << " : ";
3786     if (commaNeeded)
3787         _OUT << "\"" << VkSamplerMipmapMode_map[obj] << "\"," << std::endl;
3788     else
3789         _OUT << "\"" << VkSamplerMipmapMode_map[obj] << "\"" << std::endl;
3790 }
print_VkSamplerMipmapMode(const VkSamplerMipmapMode * obj,const std::string & str,bool commaNeeded=true)3791 static void print_VkSamplerMipmapMode(const VkSamplerMipmapMode *obj, const std::string &str, bool commaNeeded = true)
3792 {
3793     PRINT_SPACE
3794     if (str != "")
3795         _OUT << "\"" << str << "\""
3796              << " : ";
3797     if (commaNeeded)
3798         _OUT << "\"" << VkSamplerMipmapMode_map[*obj] << "\"," << std::endl;
3799     else
3800         _OUT << "\"" << VkSamplerMipmapMode_map[*obj] << "\"" << std::endl;
3801 }
3802 
3803 static std::map<uint64_t, std::string> VkDescriptorPoolCreateFlagBits_map = {
3804     std::make_pair(1ULL << 0, "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT"),
3805     std::make_pair(1ULL << 1, "VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT"),
3806     std::make_pair(1ULL << 2, "VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE"),
3807 };
print_VkDescriptorPoolCreateFlagBits(VkDescriptorPoolCreateFlagBits obj,const std::string & str,bool commaNeeded=true)3808 static void print_VkDescriptorPoolCreateFlagBits(VkDescriptorPoolCreateFlagBits obj, const std::string &str,
3809                                                  bool commaNeeded = true)
3810 {
3811     PRINT_SPACE
3812     if (str != "")
3813         _OUT << "\"" << str << "\""
3814              << " : ";
3815     if (commaNeeded)
3816         _OUT << "\"" << VkDescriptorPoolCreateFlagBits_map[obj] << "\"," << std::endl;
3817     else
3818         _OUT << "\"" << VkDescriptorPoolCreateFlagBits_map[obj] << "\"" << std::endl;
3819 }
print_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)3820 static void print_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits *obj, const std::string &str,
3821                                                  bool commaNeeded = true)
3822 {
3823     PRINT_SPACE
3824     if (str != "")
3825         _OUT << "\"" << str << "\""
3826              << " : ";
3827     if (commaNeeded)
3828         _OUT << "\"" << VkDescriptorPoolCreateFlagBits_map[*obj] << "\"," << std::endl;
3829     else
3830         _OUT << "\"" << VkDescriptorPoolCreateFlagBits_map[*obj] << "\"" << std::endl;
3831 }
3832 
3833 static std::map<uint64_t, std::string> VkDescriptorType_map = {
3834     std::make_pair(0, "VK_DESCRIPTOR_TYPE_SAMPLER"),
3835     std::make_pair(1, "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER"),
3836     std::make_pair(2, "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE"),
3837     std::make_pair(3, "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"),
3838     std::make_pair(4, "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER"),
3839     std::make_pair(5, "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER"),
3840     std::make_pair(6, "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER"),
3841     std::make_pair(7, "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER"),
3842     std::make_pair(8, "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC"),
3843     std::make_pair(9, "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC"),
3844     std::make_pair(10, "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT"),
3845     std::make_pair(1000138000, "VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT"),
3846     std::make_pair(1000150000, "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR"),
3847     std::make_pair(1000165000, "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV"),
3848     std::make_pair(1000351000, "VK_DESCRIPTOR_TYPE_MUTABLE_VALVE"),
3849 };
print_VkDescriptorType(VkDescriptorType obj,const std::string & str,bool commaNeeded=true)3850 static void print_VkDescriptorType(VkDescriptorType obj, const std::string &str, bool commaNeeded = true)
3851 {
3852     PRINT_SPACE
3853     if (str != "")
3854         _OUT << "\"" << str << "\""
3855              << " : ";
3856     if (commaNeeded)
3857         _OUT << "\"" << VkDescriptorType_map[obj] << "\"," << std::endl;
3858     else
3859         _OUT << "\"" << VkDescriptorType_map[obj] << "\"" << std::endl;
3860 }
print_VkDescriptorType(const VkDescriptorType * obj,const std::string & str,bool commaNeeded=true)3861 static void print_VkDescriptorType(const VkDescriptorType *obj, const std::string &str, bool commaNeeded = true)
3862 {
3863     PRINT_SPACE
3864     if (str != "")
3865         _OUT << "\"" << str << "\""
3866              << " : ";
3867     if (commaNeeded)
3868         _OUT << "\"" << VkDescriptorType_map[*obj] << "\"," << std::endl;
3869     else
3870         _OUT << "\"" << VkDescriptorType_map[*obj] << "\"" << std::endl;
3871 }
3872 
3873 static std::map<uint64_t, std::string> VkDescriptorSetLayoutCreateFlagBits_map = {
3874     std::make_pair(1ULL << 1, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT"),
3875     std::make_pair(1ULL << 0, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR"),
3876     std::make_pair(1ULL << 4, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_4_BIT_AMD"),
3877     std::make_pair(1ULL << 3, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_3_BIT_AMD"),
3878     std::make_pair(1ULL << 2, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE"),
3879 };
print_VkDescriptorSetLayoutCreateFlagBits(VkDescriptorSetLayoutCreateFlagBits obj,const std::string & str,bool commaNeeded=true)3880 static void print_VkDescriptorSetLayoutCreateFlagBits(VkDescriptorSetLayoutCreateFlagBits obj, const std::string &str,
3881                                                       bool commaNeeded = true)
3882 {
3883     PRINT_SPACE
3884     if (str != "")
3885         _OUT << "\"" << str << "\""
3886              << " : ";
3887     if (commaNeeded)
3888         _OUT << "\"" << VkDescriptorSetLayoutCreateFlagBits_map[obj] << "\"," << std::endl;
3889     else
3890         _OUT << "\"" << VkDescriptorSetLayoutCreateFlagBits_map[obj] << "\"" << std::endl;
3891 }
print_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)3892 static void print_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits *obj,
3893                                                       const std::string &str, bool commaNeeded = true)
3894 {
3895     PRINT_SPACE
3896     if (str != "")
3897         _OUT << "\"" << str << "\""
3898              << " : ";
3899     if (commaNeeded)
3900         _OUT << "\"" << VkDescriptorSetLayoutCreateFlagBits_map[*obj] << "\"," << std::endl;
3901     else
3902         _OUT << "\"" << VkDescriptorSetLayoutCreateFlagBits_map[*obj] << "\"" << std::endl;
3903 }
3904 
3905 static std::map<uint64_t, std::string> VkAttachmentDescriptionFlagBits_map = {
3906     std::make_pair(1ULL << 0, "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT"),
3907 };
print_VkAttachmentDescriptionFlagBits(VkAttachmentDescriptionFlagBits obj,const std::string & str,bool commaNeeded=true)3908 static void print_VkAttachmentDescriptionFlagBits(VkAttachmentDescriptionFlagBits obj, const std::string &str,
3909                                                   bool commaNeeded = true)
3910 {
3911     PRINT_SPACE
3912     if (str != "")
3913         _OUT << "\"" << str << "\""
3914              << " : ";
3915     if (commaNeeded)
3916         _OUT << "\"" << VkAttachmentDescriptionFlagBits_map[obj] << "\"," << std::endl;
3917     else
3918         _OUT << "\"" << VkAttachmentDescriptionFlagBits_map[obj] << "\"" << std::endl;
3919 }
print_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits * obj,const std::string & str,bool commaNeeded=true)3920 static void print_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits *obj, const std::string &str,
3921                                                   bool commaNeeded = true)
3922 {
3923     PRINT_SPACE
3924     if (str != "")
3925         _OUT << "\"" << str << "\""
3926              << " : ";
3927     if (commaNeeded)
3928         _OUT << "\"" << VkAttachmentDescriptionFlagBits_map[*obj] << "\"," << std::endl;
3929     else
3930         _OUT << "\"" << VkAttachmentDescriptionFlagBits_map[*obj] << "\"" << std::endl;
3931 }
3932 
3933 static std::map<uint64_t, std::string> VkAttachmentLoadOp_map = {
3934     std::make_pair(0, "VK_ATTACHMENT_LOAD_OP_LOAD"),
3935     std::make_pair(1, "VK_ATTACHMENT_LOAD_OP_CLEAR"),
3936     std::make_pair(2, "VK_ATTACHMENT_LOAD_OP_DONT_CARE"),
3937     std::make_pair(1000400000, "VK_ATTACHMENT_LOAD_OP_NONE_EXT"),
3938 };
print_VkAttachmentLoadOp(VkAttachmentLoadOp obj,const std::string & str,bool commaNeeded=true)3939 static void print_VkAttachmentLoadOp(VkAttachmentLoadOp obj, const std::string &str, bool commaNeeded = true)
3940 {
3941     PRINT_SPACE
3942     if (str != "")
3943         _OUT << "\"" << str << "\""
3944              << " : ";
3945     if (commaNeeded)
3946         _OUT << "\"" << VkAttachmentLoadOp_map[obj] << "\"," << std::endl;
3947     else
3948         _OUT << "\"" << VkAttachmentLoadOp_map[obj] << "\"" << std::endl;
3949 }
print_VkAttachmentLoadOp(const VkAttachmentLoadOp * obj,const std::string & str,bool commaNeeded=true)3950 static void print_VkAttachmentLoadOp(const VkAttachmentLoadOp *obj, const std::string &str, bool commaNeeded = true)
3951 {
3952     PRINT_SPACE
3953     if (str != "")
3954         _OUT << "\"" << str << "\""
3955              << " : ";
3956     if (commaNeeded)
3957         _OUT << "\"" << VkAttachmentLoadOp_map[*obj] << "\"," << std::endl;
3958     else
3959         _OUT << "\"" << VkAttachmentLoadOp_map[*obj] << "\"" << std::endl;
3960 }
3961 
3962 static std::map<uint64_t, std::string> VkAttachmentStoreOp_map = {
3963     std::make_pair(0, "VK_ATTACHMENT_STORE_OP_STORE"),
3964     std::make_pair(1, "VK_ATTACHMENT_STORE_OP_DONT_CARE"),
3965     std::make_pair(1000301000, "VK_ATTACHMENT_STORE_OP_NONE_KHR"),
3966 };
print_VkAttachmentStoreOp(VkAttachmentStoreOp obj,const std::string & str,bool commaNeeded=true)3967 static void print_VkAttachmentStoreOp(VkAttachmentStoreOp obj, const std::string &str, bool commaNeeded = true)
3968 {
3969     PRINT_SPACE
3970     if (str != "")
3971         _OUT << "\"" << str << "\""
3972              << " : ";
3973     if (commaNeeded)
3974         _OUT << "\"" << VkAttachmentStoreOp_map[obj] << "\"," << std::endl;
3975     else
3976         _OUT << "\"" << VkAttachmentStoreOp_map[obj] << "\"" << std::endl;
3977 }
print_VkAttachmentStoreOp(const VkAttachmentStoreOp * obj,const std::string & str,bool commaNeeded=true)3978 static void print_VkAttachmentStoreOp(const VkAttachmentStoreOp *obj, const std::string &str, bool commaNeeded = true)
3979 {
3980     PRINT_SPACE
3981     if (str != "")
3982         _OUT << "\"" << str << "\""
3983              << " : ";
3984     if (commaNeeded)
3985         _OUT << "\"" << VkAttachmentStoreOp_map[*obj] << "\"," << std::endl;
3986     else
3987         _OUT << "\"" << VkAttachmentStoreOp_map[*obj] << "\"" << std::endl;
3988 }
3989 
3990 static std::map<uint64_t, std::string> VkDependencyFlagBits_map = {
3991     std::make_pair(1ULL << 0, "VK_DEPENDENCY_BY_REGION_BIT"),
3992     std::make_pair(1ULL << 2, "VK_DEPENDENCY_DEVICE_GROUP_BIT"),
3993     std::make_pair(1ULL << 1, "VK_DEPENDENCY_VIEW_LOCAL_BIT"),
3994 };
print_VkDependencyFlagBits(VkDependencyFlagBits obj,const std::string & str,bool commaNeeded=true)3995 static void print_VkDependencyFlagBits(VkDependencyFlagBits obj, const std::string &str, bool commaNeeded = true)
3996 {
3997     PRINT_SPACE
3998     if (str != "")
3999         _OUT << "\"" << str << "\""
4000              << " : ";
4001     if (commaNeeded)
4002         _OUT << "\"" << VkDependencyFlagBits_map[obj] << "\"," << std::endl;
4003     else
4004         _OUT << "\"" << VkDependencyFlagBits_map[obj] << "\"" << std::endl;
4005 }
print_VkDependencyFlagBits(const VkDependencyFlagBits * obj,const std::string & str,bool commaNeeded=true)4006 static void print_VkDependencyFlagBits(const VkDependencyFlagBits *obj, const std::string &str, bool commaNeeded = true)
4007 {
4008     PRINT_SPACE
4009     if (str != "")
4010         _OUT << "\"" << str << "\""
4011              << " : ";
4012     if (commaNeeded)
4013         _OUT << "\"" << VkDependencyFlagBits_map[*obj] << "\"," << std::endl;
4014     else
4015         _OUT << "\"" << VkDependencyFlagBits_map[*obj] << "\"" << std::endl;
4016 }
4017 
4018 static std::map<uint64_t, std::string> VkFramebufferCreateFlagBits_map = {
4019     std::make_pair(1ULL << 0, "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT"),
4020 };
print_VkFramebufferCreateFlagBits(VkFramebufferCreateFlagBits obj,const std::string & str,bool commaNeeded=true)4021 static void print_VkFramebufferCreateFlagBits(VkFramebufferCreateFlagBits obj, const std::string &str,
4022                                               bool commaNeeded = true)
4023 {
4024     PRINT_SPACE
4025     if (str != "")
4026         _OUT << "\"" << str << "\""
4027              << " : ";
4028     if (commaNeeded)
4029         _OUT << "\"" << VkFramebufferCreateFlagBits_map[obj] << "\"," << std::endl;
4030     else
4031         _OUT << "\"" << VkFramebufferCreateFlagBits_map[obj] << "\"" << std::endl;
4032 }
print_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)4033 static void print_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits *obj, const std::string &str,
4034                                               bool commaNeeded = true)
4035 {
4036     PRINT_SPACE
4037     if (str != "")
4038         _OUT << "\"" << str << "\""
4039              << " : ";
4040     if (commaNeeded)
4041         _OUT << "\"" << VkFramebufferCreateFlagBits_map[*obj] << "\"," << std::endl;
4042     else
4043         _OUT << "\"" << VkFramebufferCreateFlagBits_map[*obj] << "\"" << std::endl;
4044 }
4045 
4046 static std::map<uint64_t, std::string> VkPipelineBindPoint_map = {
4047     std::make_pair(0, "VK_PIPELINE_BIND_POINT_GRAPHICS"),
4048     std::make_pair(1, "VK_PIPELINE_BIND_POINT_COMPUTE"),
4049     std::make_pair(1000165000, "VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR"),
4050     std::make_pair(1000369003, "VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI"),
4051 };
print_VkPipelineBindPoint(VkPipelineBindPoint obj,const std::string & str,bool commaNeeded=true)4052 static void print_VkPipelineBindPoint(VkPipelineBindPoint obj, const std::string &str, bool commaNeeded = true)
4053 {
4054     PRINT_SPACE
4055     if (str != "")
4056         _OUT << "\"" << str << "\""
4057              << " : ";
4058     if (commaNeeded)
4059         _OUT << "\"" << VkPipelineBindPoint_map[obj] << "\"," << std::endl;
4060     else
4061         _OUT << "\"" << VkPipelineBindPoint_map[obj] << "\"" << std::endl;
4062 }
print_VkPipelineBindPoint(const VkPipelineBindPoint * obj,const std::string & str,bool commaNeeded=true)4063 static void print_VkPipelineBindPoint(const VkPipelineBindPoint *obj, const std::string &str, bool commaNeeded = true)
4064 {
4065     PRINT_SPACE
4066     if (str != "")
4067         _OUT << "\"" << str << "\""
4068              << " : ";
4069     if (commaNeeded)
4070         _OUT << "\"" << VkPipelineBindPoint_map[*obj] << "\"," << std::endl;
4071     else
4072         _OUT << "\"" << VkPipelineBindPoint_map[*obj] << "\"" << std::endl;
4073 }
4074 
4075 static std::map<uint64_t, std::string> VkRenderPassCreateFlagBits_map = {
4076     std::make_pair(1ULL << 0, "VK_RENDER_PASS_CREATE_RESERVED_0_BIT_KHR"),
4077     std::make_pair(1ULL << 1, "VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM"),
4078 };
print_VkRenderPassCreateFlagBits(VkRenderPassCreateFlagBits obj,const std::string & str,bool commaNeeded=true)4079 static void print_VkRenderPassCreateFlagBits(VkRenderPassCreateFlagBits obj, const std::string &str,
4080                                              bool commaNeeded = true)
4081 {
4082     PRINT_SPACE
4083     if (str != "")
4084         _OUT << "\"" << str << "\""
4085              << " : ";
4086     if (commaNeeded)
4087         _OUT << "\"" << VkRenderPassCreateFlagBits_map[obj] << "\"," << std::endl;
4088     else
4089         _OUT << "\"" << VkRenderPassCreateFlagBits_map[obj] << "\"" << std::endl;
4090 }
print_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)4091 static void print_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits *obj, const std::string &str,
4092                                              bool commaNeeded = true)
4093 {
4094     PRINT_SPACE
4095     if (str != "")
4096         _OUT << "\"" << str << "\""
4097              << " : ";
4098     if (commaNeeded)
4099         _OUT << "\"" << VkRenderPassCreateFlagBits_map[*obj] << "\"," << std::endl;
4100     else
4101         _OUT << "\"" << VkRenderPassCreateFlagBits_map[*obj] << "\"" << std::endl;
4102 }
4103 
4104 static std::map<uint64_t, std::string> VkSubpassDescriptionFlagBits_map = {
4105     std::make_pair(1ULL << 0, "VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX"),
4106     std::make_pair(1ULL << 1, "VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX"),
4107     std::make_pair(1ULL << 2, "VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM"),
4108     std::make_pair(1ULL << 3, "VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM"),
4109     std::make_pair(1ULL << 4, "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM"),
4110     std::make_pair(1ULL << 5, "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM"),
4111     std::make_pair(1ULL << 6, "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM"),
4112 };
print_VkSubpassDescriptionFlagBits(VkSubpassDescriptionFlagBits obj,const std::string & str,bool commaNeeded=true)4113 static void print_VkSubpassDescriptionFlagBits(VkSubpassDescriptionFlagBits obj, const std::string &str,
4114                                                bool commaNeeded = true)
4115 {
4116     PRINT_SPACE
4117     if (str != "")
4118         _OUT << "\"" << str << "\""
4119              << " : ";
4120     if (commaNeeded)
4121         _OUT << "\"" << VkSubpassDescriptionFlagBits_map[obj] << "\"," << std::endl;
4122     else
4123         _OUT << "\"" << VkSubpassDescriptionFlagBits_map[obj] << "\"" << std::endl;
4124 }
print_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits * obj,const std::string & str,bool commaNeeded=true)4125 static void print_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits *obj, const std::string &str,
4126                                                bool commaNeeded = true)
4127 {
4128     PRINT_SPACE
4129     if (str != "")
4130         _OUT << "\"" << str << "\""
4131              << " : ";
4132     if (commaNeeded)
4133         _OUT << "\"" << VkSubpassDescriptionFlagBits_map[*obj] << "\"," << std::endl;
4134     else
4135         _OUT << "\"" << VkSubpassDescriptionFlagBits_map[*obj] << "\"" << std::endl;
4136 }
4137 
4138 static std::map<uint64_t, std::string> VkCommandPoolCreateFlagBits_map = {
4139     std::make_pair(1ULL << 0, "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT"),
4140     std::make_pair(1ULL << 1, "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT"),
4141     std::make_pair(1ULL << 2, "VK_COMMAND_POOL_CREATE_PROTECTED_BIT"),
4142 };
print_VkCommandPoolCreateFlagBits(VkCommandPoolCreateFlagBits obj,const std::string & str,bool commaNeeded=true)4143 static void print_VkCommandPoolCreateFlagBits(VkCommandPoolCreateFlagBits obj, const std::string &str,
4144                                               bool commaNeeded = true)
4145 {
4146     PRINT_SPACE
4147     if (str != "")
4148         _OUT << "\"" << str << "\""
4149              << " : ";
4150     if (commaNeeded)
4151         _OUT << "\"" << VkCommandPoolCreateFlagBits_map[obj] << "\"," << std::endl;
4152     else
4153         _OUT << "\"" << VkCommandPoolCreateFlagBits_map[obj] << "\"" << std::endl;
4154 }
print_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits * obj,const std::string & str,bool commaNeeded=true)4155 static void print_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits *obj, const std::string &str,
4156                                               bool commaNeeded = true)
4157 {
4158     PRINT_SPACE
4159     if (str != "")
4160         _OUT << "\"" << str << "\""
4161              << " : ";
4162     if (commaNeeded)
4163         _OUT << "\"" << VkCommandPoolCreateFlagBits_map[*obj] << "\"," << std::endl;
4164     else
4165         _OUT << "\"" << VkCommandPoolCreateFlagBits_map[*obj] << "\"" << std::endl;
4166 }
4167 
4168 static std::map<uint64_t, std::string> VkCommandPoolResetFlagBits_map = {
4169     std::make_pair(1ULL << 1, "VK_COMMAND_POOL_RESET_RESERVED_1_BIT_COREAVI"),
4170 };
print_VkCommandPoolResetFlagBits(VkCommandPoolResetFlagBits obj,const std::string & str,bool commaNeeded=true)4171 static void print_VkCommandPoolResetFlagBits(VkCommandPoolResetFlagBits obj, const std::string &str,
4172                                              bool commaNeeded = true)
4173 {
4174     PRINT_SPACE
4175     if (str != "")
4176         _OUT << "\"" << str << "\""
4177              << " : ";
4178     if (commaNeeded)
4179         _OUT << "\"" << VkCommandPoolResetFlagBits_map[obj] << "\"," << std::endl;
4180     else
4181         _OUT << "\"" << VkCommandPoolResetFlagBits_map[obj] << "\"" << std::endl;
4182 }
print_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits * obj,const std::string & str,bool commaNeeded=true)4183 static void print_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits *obj, const std::string &str,
4184                                              bool commaNeeded = true)
4185 {
4186     PRINT_SPACE
4187     if (str != "")
4188         _OUT << "\"" << str << "\""
4189              << " : ";
4190     if (commaNeeded)
4191         _OUT << "\"" << VkCommandPoolResetFlagBits_map[*obj] << "\"," << std::endl;
4192     else
4193         _OUT << "\"" << VkCommandPoolResetFlagBits_map[*obj] << "\"" << std::endl;
4194 }
4195 
4196 static std::map<uint64_t, std::string> VkCommandBufferLevel_map = {
4197     std::make_pair(0, "VK_COMMAND_BUFFER_LEVEL_PRIMARY"),
4198     std::make_pair(1, "VK_COMMAND_BUFFER_LEVEL_SECONDARY"),
4199 };
print_VkCommandBufferLevel(VkCommandBufferLevel obj,const std::string & str,bool commaNeeded=true)4200 static void print_VkCommandBufferLevel(VkCommandBufferLevel obj, const std::string &str, bool commaNeeded = true)
4201 {
4202     PRINT_SPACE
4203     if (str != "")
4204         _OUT << "\"" << str << "\""
4205              << " : ";
4206     if (commaNeeded)
4207         _OUT << "\"" << VkCommandBufferLevel_map[obj] << "\"," << std::endl;
4208     else
4209         _OUT << "\"" << VkCommandBufferLevel_map[obj] << "\"" << std::endl;
4210 }
print_VkCommandBufferLevel(const VkCommandBufferLevel * obj,const std::string & str,bool commaNeeded=true)4211 static void print_VkCommandBufferLevel(const VkCommandBufferLevel *obj, const std::string &str, bool commaNeeded = true)
4212 {
4213     PRINT_SPACE
4214     if (str != "")
4215         _OUT << "\"" << str << "\""
4216              << " : ";
4217     if (commaNeeded)
4218         _OUT << "\"" << VkCommandBufferLevel_map[*obj] << "\"," << std::endl;
4219     else
4220         _OUT << "\"" << VkCommandBufferLevel_map[*obj] << "\"" << std::endl;
4221 }
4222 
4223 static std::map<uint64_t, std::string> VkCommandBufferUsageFlagBits_map = {
4224     std::make_pair(1ULL << 0, "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT"),
4225     std::make_pair(1ULL << 1, "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT"),
4226     std::make_pair(1ULL << 2, "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT"),
4227 };
print_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits obj,const std::string & str,bool commaNeeded=true)4228 static void print_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits obj, const std::string &str,
4229                                                bool commaNeeded = true)
4230 {
4231     PRINT_SPACE
4232     if (str != "")
4233         _OUT << "\"" << str << "\""
4234              << " : ";
4235     if (commaNeeded)
4236         _OUT << "\"" << VkCommandBufferUsageFlagBits_map[obj] << "\"," << std::endl;
4237     else
4238         _OUT << "\"" << VkCommandBufferUsageFlagBits_map[obj] << "\"" << std::endl;
4239 }
print_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits * obj,const std::string & str,bool commaNeeded=true)4240 static void print_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits *obj, const std::string &str,
4241                                                bool commaNeeded = true)
4242 {
4243     PRINT_SPACE
4244     if (str != "")
4245         _OUT << "\"" << str << "\""
4246              << " : ";
4247     if (commaNeeded)
4248         _OUT << "\"" << VkCommandBufferUsageFlagBits_map[*obj] << "\"," << std::endl;
4249     else
4250         _OUT << "\"" << VkCommandBufferUsageFlagBits_map[*obj] << "\"" << std::endl;
4251 }
4252 
4253 static std::map<uint64_t, std::string> VkQueryControlFlagBits_map = {
4254     std::make_pair(1ULL << 0, "VK_QUERY_CONTROL_PRECISE_BIT"),
4255 };
print_VkQueryControlFlagBits(VkQueryControlFlagBits obj,const std::string & str,bool commaNeeded=true)4256 static void print_VkQueryControlFlagBits(VkQueryControlFlagBits obj, const std::string &str, bool commaNeeded = true)
4257 {
4258     PRINT_SPACE
4259     if (str != "")
4260         _OUT << "\"" << str << "\""
4261              << " : ";
4262     if (commaNeeded)
4263         _OUT << "\"" << VkQueryControlFlagBits_map[obj] << "\"," << std::endl;
4264     else
4265         _OUT << "\"" << VkQueryControlFlagBits_map[obj] << "\"" << std::endl;
4266 }
print_VkQueryControlFlagBits(const VkQueryControlFlagBits * obj,const std::string & str,bool commaNeeded=true)4267 static void print_VkQueryControlFlagBits(const VkQueryControlFlagBits *obj, const std::string &str,
4268                                          bool commaNeeded = true)
4269 {
4270     PRINT_SPACE
4271     if (str != "")
4272         _OUT << "\"" << str << "\""
4273              << " : ";
4274     if (commaNeeded)
4275         _OUT << "\"" << VkQueryControlFlagBits_map[*obj] << "\"," << std::endl;
4276     else
4277         _OUT << "\"" << VkQueryControlFlagBits_map[*obj] << "\"" << std::endl;
4278 }
4279 
4280 static std::map<uint64_t, std::string> VkCommandBufferResetFlagBits_map = {
4281     std::make_pair(1ULL << 0, "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT"),
4282 };
print_VkCommandBufferResetFlagBits(VkCommandBufferResetFlagBits obj,const std::string & str,bool commaNeeded=true)4283 static void print_VkCommandBufferResetFlagBits(VkCommandBufferResetFlagBits obj, const std::string &str,
4284                                                bool commaNeeded = true)
4285 {
4286     PRINT_SPACE
4287     if (str != "")
4288         _OUT << "\"" << str << "\""
4289              << " : ";
4290     if (commaNeeded)
4291         _OUT << "\"" << VkCommandBufferResetFlagBits_map[obj] << "\"," << std::endl;
4292     else
4293         _OUT << "\"" << VkCommandBufferResetFlagBits_map[obj] << "\"" << std::endl;
4294 }
print_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits * obj,const std::string & str,bool commaNeeded=true)4295 static void print_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits *obj, const std::string &str,
4296                                                bool commaNeeded = true)
4297 {
4298     PRINT_SPACE
4299     if (str != "")
4300         _OUT << "\"" << str << "\""
4301              << " : ";
4302     if (commaNeeded)
4303         _OUT << "\"" << VkCommandBufferResetFlagBits_map[*obj] << "\"," << std::endl;
4304     else
4305         _OUT << "\"" << VkCommandBufferResetFlagBits_map[*obj] << "\"" << std::endl;
4306 }
4307 
4308 static std::map<uint64_t, std::string> VkIndexType_map = {
4309     std::make_pair(0, "VK_INDEX_TYPE_UINT16"),
4310     std::make_pair(1, "VK_INDEX_TYPE_UINT32"),
4311     std::make_pair(1000165000, "VK_INDEX_TYPE_NONE_KHR"),
4312     std::make_pair(1000265000, "VK_INDEX_TYPE_UINT8_EXT"),
4313 };
print_VkIndexType(VkIndexType obj,const std::string & str,bool commaNeeded=true)4314 static void print_VkIndexType(VkIndexType obj, const std::string &str, bool commaNeeded = true)
4315 {
4316     PRINT_SPACE
4317     if (str != "")
4318         _OUT << "\"" << str << "\""
4319              << " : ";
4320     if (commaNeeded)
4321         _OUT << "\"" << VkIndexType_map[obj] << "\"," << std::endl;
4322     else
4323         _OUT << "\"" << VkIndexType_map[obj] << "\"" << std::endl;
4324 }
print_VkIndexType(const VkIndexType * obj,const std::string & str,bool commaNeeded=true)4325 static void print_VkIndexType(const VkIndexType *obj, const std::string &str, bool commaNeeded = true)
4326 {
4327     PRINT_SPACE
4328     if (str != "")
4329         _OUT << "\"" << str << "\""
4330              << " : ";
4331     if (commaNeeded)
4332         _OUT << "\"" << VkIndexType_map[*obj] << "\"," << std::endl;
4333     else
4334         _OUT << "\"" << VkIndexType_map[*obj] << "\"" << std::endl;
4335 }
4336 
4337 static std::map<uint64_t, std::string> VkStencilFaceFlagBits_map = {
4338     std::make_pair(1ULL << 0, "VK_STENCIL_FACE_FRONT_BIT"),
4339     std::make_pair(1ULL << 1, "VK_STENCIL_FACE_BACK_BIT"),
4340     std::make_pair(0x00000003, "VK_STENCIL_FACE_FRONT_AND_BACK"),
4341 };
print_VkStencilFaceFlagBits(VkStencilFaceFlagBits obj,const std::string & str,bool commaNeeded=true)4342 static void print_VkStencilFaceFlagBits(VkStencilFaceFlagBits obj, const std::string &str, bool commaNeeded = true)
4343 {
4344     PRINT_SPACE
4345     if (str != "")
4346         _OUT << "\"" << str << "\""
4347              << " : ";
4348     if (commaNeeded)
4349         _OUT << "\"" << VkStencilFaceFlagBits_map[obj] << "\"," << std::endl;
4350     else
4351         _OUT << "\"" << VkStencilFaceFlagBits_map[obj] << "\"" << std::endl;
4352 }
print_VkStencilFaceFlagBits(const VkStencilFaceFlagBits * obj,const std::string & str,bool commaNeeded=true)4353 static void print_VkStencilFaceFlagBits(const VkStencilFaceFlagBits *obj, const std::string &str,
4354                                         bool commaNeeded = true)
4355 {
4356     PRINT_SPACE
4357     if (str != "")
4358         _OUT << "\"" << str << "\""
4359              << " : ";
4360     if (commaNeeded)
4361         _OUT << "\"" << VkStencilFaceFlagBits_map[*obj] << "\"," << std::endl;
4362     else
4363         _OUT << "\"" << VkStencilFaceFlagBits_map[*obj] << "\"" << std::endl;
4364 }
4365 
4366 static std::map<uint64_t, std::string> VkSubpassContents_map = {
4367     std::make_pair(0, "VK_SUBPASS_CONTENTS_INLINE"),
4368     std::make_pair(1, "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS"),
4369 };
print_VkSubpassContents(VkSubpassContents obj,const std::string & str,bool commaNeeded=true)4370 static void print_VkSubpassContents(VkSubpassContents obj, const std::string &str, bool commaNeeded = true)
4371 {
4372     PRINT_SPACE
4373     if (str != "")
4374         _OUT << "\"" << str << "\""
4375              << " : ";
4376     if (commaNeeded)
4377         _OUT << "\"" << VkSubpassContents_map[obj] << "\"," << std::endl;
4378     else
4379         _OUT << "\"" << VkSubpassContents_map[obj] << "\"" << std::endl;
4380 }
print_VkSubpassContents(const VkSubpassContents * obj,const std::string & str,bool commaNeeded=true)4381 static void print_VkSubpassContents(const VkSubpassContents *obj, const std::string &str, bool commaNeeded = true)
4382 {
4383     PRINT_SPACE
4384     if (str != "")
4385         _OUT << "\"" << str << "\""
4386              << " : ";
4387     if (commaNeeded)
4388         _OUT << "\"" << VkSubpassContents_map[*obj] << "\"," << std::endl;
4389     else
4390         _OUT << "\"" << VkSubpassContents_map[*obj] << "\"" << std::endl;
4391 }
4392 
print_VkAccessFlags(VkAccessFlags obj,const std::string & str,bool commaNeeded=true)4393 static void print_VkAccessFlags(VkAccessFlags obj, const std::string &str, bool commaNeeded = true)
4394 {
4395     PRINT_SPACE
4396     if (str != "")
4397         _OUT << "\"" << str << "\""
4398              << " : ";
4399     const int max_bits = 64; // We don't expect the number to be larger.
4400     std::bitset<max_bits> b(obj);
4401     _OUT << "\"";
4402     if (obj == 0)
4403         _OUT << "0";
4404     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4405     {
4406         if (b[i] == 1)
4407         {
4408             bitCount++;
4409             if (bitCount < b.count())
4410                 _OUT << VkAccessFlagBits_map[1ULL << i] << " | ";
4411             else
4412                 _OUT << VkAccessFlagBits_map[1ULL << i];
4413         }
4414     }
4415     if (commaNeeded)
4416         _OUT << "\""
4417              << ",";
4418     else
4419         _OUT << "\""
4420              << "";
4421     _OUT << std::endl;
4422 }
print_VkAccessFlags(const VkAccessFlags * obj,const std::string & str,bool commaNeeded=true)4423 static void print_VkAccessFlags(const VkAccessFlags *obj, const std::string &str, bool commaNeeded = true)
4424 {
4425     PRINT_SPACE
4426     if (str != "")
4427         _OUT << "\"" << str << "\""
4428              << " : ";
4429     const int max_bits = 64; // We don't expect the number to be larger.
4430     std::bitset<max_bits> b(obj);
4431     _OUT << "\"";
4432     if (obj == 0)
4433         _OUT << "0";
4434     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4435     {
4436         if (b[i] == 1)
4437         {
4438             bitCount++;
4439             if (bitCount < b.count())
4440                 _OUT << VkAccessFlagBits_map[1ULL << i] << " | ";
4441             else
4442                 _OUT << VkAccessFlagBits_map[1ULL << i];
4443         }
4444     }
4445     if (commaNeeded)
4446         _OUT << "\""
4447              << ",";
4448     else
4449         _OUT << "\""
4450              << "";
4451     _OUT << std::endl;
4452 }
4453 
print_VkImageAspectFlags(VkImageAspectFlags obj,const std::string & str,bool commaNeeded=true)4454 static void print_VkImageAspectFlags(VkImageAspectFlags obj, const std::string &str, bool commaNeeded = true)
4455 {
4456     PRINT_SPACE
4457     if (str != "")
4458         _OUT << "\"" << str << "\""
4459              << " : ";
4460     const int max_bits = 64; // We don't expect the number to be larger.
4461     std::bitset<max_bits> b(obj);
4462     _OUT << "\"";
4463     if (obj == 0)
4464         _OUT << "0";
4465     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4466     {
4467         if (b[i] == 1)
4468         {
4469             bitCount++;
4470             if (bitCount < b.count())
4471                 _OUT << VkImageAspectFlagBits_map[1ULL << i] << " | ";
4472             else
4473                 _OUT << VkImageAspectFlagBits_map[1ULL << i];
4474         }
4475     }
4476     if (commaNeeded)
4477         _OUT << "\""
4478              << ",";
4479     else
4480         _OUT << "\""
4481              << "";
4482     _OUT << std::endl;
4483 }
print_VkImageAspectFlags(const VkImageAspectFlags * obj,const std::string & str,bool commaNeeded=true)4484 static void print_VkImageAspectFlags(const VkImageAspectFlags *obj, const std::string &str, bool commaNeeded = true)
4485 {
4486     PRINT_SPACE
4487     if (str != "")
4488         _OUT << "\"" << str << "\""
4489              << " : ";
4490     const int max_bits = 64; // We don't expect the number to be larger.
4491     std::bitset<max_bits> b(obj);
4492     _OUT << "\"";
4493     if (obj == 0)
4494         _OUT << "0";
4495     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4496     {
4497         if (b[i] == 1)
4498         {
4499             bitCount++;
4500             if (bitCount < b.count())
4501                 _OUT << VkImageAspectFlagBits_map[1ULL << i] << " | ";
4502             else
4503                 _OUT << VkImageAspectFlagBits_map[1ULL << i];
4504         }
4505     }
4506     if (commaNeeded)
4507         _OUT << "\""
4508              << ",";
4509     else
4510         _OUT << "\""
4511              << "";
4512     _OUT << std::endl;
4513 }
4514 
print_VkFormatFeatureFlags(VkFormatFeatureFlags obj,const std::string & str,bool commaNeeded=true)4515 static void print_VkFormatFeatureFlags(VkFormatFeatureFlags obj, const std::string &str, bool commaNeeded = true)
4516 {
4517     PRINT_SPACE
4518     if (str != "")
4519         _OUT << "\"" << str << "\""
4520              << " : ";
4521     const int max_bits = 64; // We don't expect the number to be larger.
4522     std::bitset<max_bits> b(obj);
4523     _OUT << "\"";
4524     if (obj == 0)
4525         _OUT << "0";
4526     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4527     {
4528         if (b[i] == 1)
4529         {
4530             bitCount++;
4531             if (bitCount < b.count())
4532                 _OUT << VkFormatFeatureFlagBits_map[1ULL << i] << " | ";
4533             else
4534                 _OUT << VkFormatFeatureFlagBits_map[1ULL << i];
4535         }
4536     }
4537     if (commaNeeded)
4538         _OUT << "\""
4539              << ",";
4540     else
4541         _OUT << "\""
4542              << "";
4543     _OUT << std::endl;
4544 }
print_VkFormatFeatureFlags(const VkFormatFeatureFlags * obj,const std::string & str,bool commaNeeded=true)4545 static void print_VkFormatFeatureFlags(const VkFormatFeatureFlags *obj, const std::string &str, bool commaNeeded = true)
4546 {
4547     PRINT_SPACE
4548     if (str != "")
4549         _OUT << "\"" << str << "\""
4550              << " : ";
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)
4555         _OUT << "0";
4556     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4557     {
4558         if (b[i] == 1)
4559         {
4560             bitCount++;
4561             if (bitCount < b.count())
4562                 _OUT << VkFormatFeatureFlagBits_map[1ULL << i] << " | ";
4563             else
4564                 _OUT << VkFormatFeatureFlagBits_map[1ULL << i];
4565         }
4566     }
4567     if (commaNeeded)
4568         _OUT << "\""
4569              << ",";
4570     else
4571         _OUT << "\""
4572              << "";
4573     _OUT << std::endl;
4574 }
4575 
print_VkImageCreateFlags(VkImageCreateFlags obj,const std::string & str,bool commaNeeded=true)4576 static void print_VkImageCreateFlags(VkImageCreateFlags obj, const std::string &str, bool commaNeeded = true)
4577 {
4578     PRINT_SPACE
4579     if (str != "")
4580         _OUT << "\"" << str << "\""
4581              << " : ";
4582     const int max_bits = 64; // We don't expect the number to be larger.
4583     std::bitset<max_bits> b(obj);
4584     _OUT << "\"";
4585     if (obj == 0)
4586         _OUT << "0";
4587     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4588     {
4589         if (b[i] == 1)
4590         {
4591             bitCount++;
4592             if (bitCount < b.count())
4593                 _OUT << VkImageCreateFlagBits_map[1ULL << i] << " | ";
4594             else
4595                 _OUT << VkImageCreateFlagBits_map[1ULL << i];
4596         }
4597     }
4598     if (commaNeeded)
4599         _OUT << "\""
4600              << ",";
4601     else
4602         _OUT << "\""
4603              << "";
4604     _OUT << std::endl;
4605 }
print_VkImageCreateFlags(const VkImageCreateFlags * obj,const std::string & str,bool commaNeeded=true)4606 static void print_VkImageCreateFlags(const VkImageCreateFlags *obj, const std::string &str, bool commaNeeded = true)
4607 {
4608     PRINT_SPACE
4609     if (str != "")
4610         _OUT << "\"" << str << "\""
4611              << " : ";
4612     const int max_bits = 64; // We don't expect the number to be larger.
4613     std::bitset<max_bits> b(obj);
4614     _OUT << "\"";
4615     if (obj == 0)
4616         _OUT << "0";
4617     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4618     {
4619         if (b[i] == 1)
4620         {
4621             bitCount++;
4622             if (bitCount < b.count())
4623                 _OUT << VkImageCreateFlagBits_map[1ULL << i] << " | ";
4624             else
4625                 _OUT << VkImageCreateFlagBits_map[1ULL << i];
4626         }
4627     }
4628     if (commaNeeded)
4629         _OUT << "\""
4630              << ",";
4631     else
4632         _OUT << "\""
4633              << "";
4634     _OUT << std::endl;
4635 }
4636 
print_VkSampleCountFlags(VkSampleCountFlags obj,const std::string & str,bool commaNeeded=true)4637 static void print_VkSampleCountFlags(VkSampleCountFlags obj, const std::string &str, bool commaNeeded = true)
4638 {
4639     PRINT_SPACE
4640     if (str != "")
4641         _OUT << "\"" << str << "\""
4642              << " : ";
4643     const int max_bits = 64; // We don't expect the number to be larger.
4644     std::bitset<max_bits> b(obj);
4645     _OUT << "\"";
4646     if (obj == 0)
4647         _OUT << "0";
4648     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4649     {
4650         if (b[i] == 1)
4651         {
4652             bitCount++;
4653             if (bitCount < b.count())
4654                 _OUT << VkSampleCountFlagBits_map[1ULL << i] << " | ";
4655             else
4656                 _OUT << VkSampleCountFlagBits_map[1ULL << i];
4657         }
4658     }
4659     if (commaNeeded)
4660         _OUT << "\""
4661              << ",";
4662     else
4663         _OUT << "\""
4664              << "";
4665     _OUT << std::endl;
4666 }
print_VkSampleCountFlags(const VkSampleCountFlags * obj,const std::string & str,bool commaNeeded=true)4667 static void print_VkSampleCountFlags(const VkSampleCountFlags *obj, const std::string &str, bool commaNeeded = true)
4668 {
4669     PRINT_SPACE
4670     if (str != "")
4671         _OUT << "\"" << str << "\""
4672              << " : ";
4673     const int max_bits = 64; // We don't expect the number to be larger.
4674     std::bitset<max_bits> b(obj);
4675     _OUT << "\"";
4676     if (obj == 0)
4677         _OUT << "0";
4678     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4679     {
4680         if (b[i] == 1)
4681         {
4682             bitCount++;
4683             if (bitCount < b.count())
4684                 _OUT << VkSampleCountFlagBits_map[1ULL << i] << " | ";
4685             else
4686                 _OUT << VkSampleCountFlagBits_map[1ULL << i];
4687         }
4688     }
4689     if (commaNeeded)
4690         _OUT << "\""
4691              << ",";
4692     else
4693         _OUT << "\""
4694              << "";
4695     _OUT << std::endl;
4696 }
4697 
print_VkImageUsageFlags(VkImageUsageFlags obj,const std::string & str,bool commaNeeded=true)4698 static void print_VkImageUsageFlags(VkImageUsageFlags obj, const std::string &str, bool commaNeeded = true)
4699 {
4700     PRINT_SPACE
4701     if (str != "")
4702         _OUT << "\"" << str << "\""
4703              << " : ";
4704     const int max_bits = 64; // We don't expect the number to be larger.
4705     std::bitset<max_bits> b(obj);
4706     _OUT << "\"";
4707     if (obj == 0)
4708         _OUT << "0";
4709     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4710     {
4711         if (b[i] == 1)
4712         {
4713             bitCount++;
4714             if (bitCount < b.count())
4715                 _OUT << VkImageUsageFlagBits_map[1ULL << i] << " | ";
4716             else
4717                 _OUT << VkImageUsageFlagBits_map[1ULL << i];
4718         }
4719     }
4720     if (commaNeeded)
4721         _OUT << "\""
4722              << ",";
4723     else
4724         _OUT << "\""
4725              << "";
4726     _OUT << std::endl;
4727 }
print_VkImageUsageFlags(const VkImageUsageFlags * obj,const std::string & str,bool commaNeeded=true)4728 static void print_VkImageUsageFlags(const VkImageUsageFlags *obj, const std::string &str, bool commaNeeded = true)
4729 {
4730     PRINT_SPACE
4731     if (str != "")
4732         _OUT << "\"" << str << "\""
4733              << " : ";
4734     const int max_bits = 64; // We don't expect the number to be larger.
4735     std::bitset<max_bits> b(obj);
4736     _OUT << "\"";
4737     if (obj == 0)
4738         _OUT << "0";
4739     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4740     {
4741         if (b[i] == 1)
4742         {
4743             bitCount++;
4744             if (bitCount < b.count())
4745                 _OUT << VkImageUsageFlagBits_map[1ULL << i] << " | ";
4746             else
4747                 _OUT << VkImageUsageFlagBits_map[1ULL << i];
4748         }
4749     }
4750     if (commaNeeded)
4751         _OUT << "\""
4752              << ",";
4753     else
4754         _OUT << "\""
4755              << "";
4756     _OUT << std::endl;
4757 }
4758 
print_VkInstanceCreateFlags(VkInstanceCreateFlags obj,const std::string & str,bool commaNeeded=true)4759 static void print_VkInstanceCreateFlags(VkInstanceCreateFlags obj, const std::string &str, bool commaNeeded = true)
4760 {
4761     PRINT_SPACE
4762     if (commaNeeded)
4763         _OUT << "\"" << str << "\""
4764              << " : " << obj << "," << std::endl;
4765     else
4766         _OUT << "\"" << str << "\""
4767              << " : " << obj << std::endl;
4768 }
print_VkInstanceCreateFlags(const VkInstanceCreateFlags * obj,const std::string & str,bool commaNeeded=true)4769 static void print_VkInstanceCreateFlags(const VkInstanceCreateFlags *obj, const std::string &str,
4770                                         bool commaNeeded = true)
4771 {
4772     PRINT_SPACE
4773     if (commaNeeded)
4774         _OUT << "\"" << str << "\""
4775              << " : " << obj << "," << std::endl;
4776     else
4777         _OUT << "\"" << str << "\""
4778              << " : " << obj << std::endl;
4779 }
4780 
print_VkMemoryHeapFlags(VkMemoryHeapFlags obj,const std::string & str,bool commaNeeded=true)4781 static void print_VkMemoryHeapFlags(VkMemoryHeapFlags obj, const std::string &str, bool commaNeeded = true)
4782 {
4783     PRINT_SPACE
4784     if (str != "")
4785         _OUT << "\"" << str << "\""
4786              << " : ";
4787     const int max_bits = 64; // We don't expect the number to be larger.
4788     std::bitset<max_bits> b(obj);
4789     _OUT << "\"";
4790     if (obj == 0)
4791         _OUT << "0";
4792     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4793     {
4794         if (b[i] == 1)
4795         {
4796             bitCount++;
4797             if (bitCount < b.count())
4798                 _OUT << VkMemoryHeapFlagBits_map[1ULL << i] << " | ";
4799             else
4800                 _OUT << VkMemoryHeapFlagBits_map[1ULL << i];
4801         }
4802     }
4803     if (commaNeeded)
4804         _OUT << "\""
4805              << ",";
4806     else
4807         _OUT << "\""
4808              << "";
4809     _OUT << std::endl;
4810 }
print_VkMemoryHeapFlags(const VkMemoryHeapFlags * obj,const std::string & str,bool commaNeeded=true)4811 static void print_VkMemoryHeapFlags(const VkMemoryHeapFlags *obj, const std::string &str, bool commaNeeded = true)
4812 {
4813     PRINT_SPACE
4814     if (str != "")
4815         _OUT << "\"" << str << "\""
4816              << " : ";
4817     const int max_bits = 64; // We don't expect the number to be larger.
4818     std::bitset<max_bits> b(obj);
4819     _OUT << "\"";
4820     if (obj == 0)
4821         _OUT << "0";
4822     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4823     {
4824         if (b[i] == 1)
4825         {
4826             bitCount++;
4827             if (bitCount < b.count())
4828                 _OUT << VkMemoryHeapFlagBits_map[1ULL << i] << " | ";
4829             else
4830                 _OUT << VkMemoryHeapFlagBits_map[1ULL << i];
4831         }
4832     }
4833     if (commaNeeded)
4834         _OUT << "\""
4835              << ",";
4836     else
4837         _OUT << "\""
4838              << "";
4839     _OUT << std::endl;
4840 }
4841 
print_VkMemoryPropertyFlags(VkMemoryPropertyFlags obj,const std::string & str,bool commaNeeded=true)4842 static void print_VkMemoryPropertyFlags(VkMemoryPropertyFlags obj, const std::string &str, bool commaNeeded = true)
4843 {
4844     PRINT_SPACE
4845     if (str != "")
4846         _OUT << "\"" << str << "\""
4847              << " : ";
4848     const int max_bits = 64; // We don't expect the number to be larger.
4849     std::bitset<max_bits> b(obj);
4850     _OUT << "\"";
4851     if (obj == 0)
4852         _OUT << "0";
4853     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4854     {
4855         if (b[i] == 1)
4856         {
4857             bitCount++;
4858             if (bitCount < b.count())
4859                 _OUT << VkMemoryPropertyFlagBits_map[1ULL << i] << " | ";
4860             else
4861                 _OUT << VkMemoryPropertyFlagBits_map[1ULL << i];
4862         }
4863     }
4864     if (commaNeeded)
4865         _OUT << "\""
4866              << ",";
4867     else
4868         _OUT << "\""
4869              << "";
4870     _OUT << std::endl;
4871 }
print_VkMemoryPropertyFlags(const VkMemoryPropertyFlags * obj,const std::string & str,bool commaNeeded=true)4872 static void print_VkMemoryPropertyFlags(const VkMemoryPropertyFlags *obj, const std::string &str,
4873                                         bool commaNeeded = true)
4874 {
4875     PRINT_SPACE
4876     if (str != "")
4877         _OUT << "\"" << str << "\""
4878              << " : ";
4879     const int max_bits = 64; // We don't expect the number to be larger.
4880     std::bitset<max_bits> b(obj);
4881     _OUT << "\"";
4882     if (obj == 0)
4883         _OUT << "0";
4884     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4885     {
4886         if (b[i] == 1)
4887         {
4888             bitCount++;
4889             if (bitCount < b.count())
4890                 _OUT << VkMemoryPropertyFlagBits_map[1ULL << i] << " | ";
4891             else
4892                 _OUT << VkMemoryPropertyFlagBits_map[1ULL << i];
4893         }
4894     }
4895     if (commaNeeded)
4896         _OUT << "\""
4897              << ",";
4898     else
4899         _OUT << "\""
4900              << "";
4901     _OUT << std::endl;
4902 }
4903 
print_VkQueueFlags(VkQueueFlags obj,const std::string & str,bool commaNeeded=true)4904 static void print_VkQueueFlags(VkQueueFlags obj, const std::string &str, bool commaNeeded = true)
4905 {
4906     PRINT_SPACE
4907     if (str != "")
4908         _OUT << "\"" << str << "\""
4909              << " : ";
4910     const int max_bits = 64; // We don't expect the number to be larger.
4911     std::bitset<max_bits> b(obj);
4912     _OUT << "\"";
4913     if (obj == 0)
4914         _OUT << "0";
4915     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4916     {
4917         if (b[i] == 1)
4918         {
4919             bitCount++;
4920             if (bitCount < b.count())
4921                 _OUT << VkQueueFlagBits_map[1ULL << i] << " | ";
4922             else
4923                 _OUT << VkQueueFlagBits_map[1ULL << i];
4924         }
4925     }
4926     if (commaNeeded)
4927         _OUT << "\""
4928              << ",";
4929     else
4930         _OUT << "\""
4931              << "";
4932     _OUT << std::endl;
4933 }
print_VkQueueFlags(const VkQueueFlags * obj,const std::string & str,bool commaNeeded=true)4934 static void print_VkQueueFlags(const VkQueueFlags *obj, const std::string &str, bool commaNeeded = true)
4935 {
4936     PRINT_SPACE
4937     if (str != "")
4938         _OUT << "\"" << str << "\""
4939              << " : ";
4940     const int max_bits = 64; // We don't expect the number to be larger.
4941     std::bitset<max_bits> b(obj);
4942     _OUT << "\"";
4943     if (obj == 0)
4944         _OUT << "0";
4945     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4946     {
4947         if (b[i] == 1)
4948         {
4949             bitCount++;
4950             if (bitCount < b.count())
4951                 _OUT << VkQueueFlagBits_map[1ULL << i] << " | ";
4952             else
4953                 _OUT << VkQueueFlagBits_map[1ULL << i];
4954         }
4955     }
4956     if (commaNeeded)
4957         _OUT << "\""
4958              << ",";
4959     else
4960         _OUT << "\""
4961              << "";
4962     _OUT << std::endl;
4963 }
4964 
print_VkDeviceCreateFlags(VkDeviceCreateFlags obj,const std::string & str,bool commaNeeded=true)4965 static void print_VkDeviceCreateFlags(VkDeviceCreateFlags obj, const std::string &str, bool commaNeeded = true)
4966 {
4967     PRINT_SPACE
4968     if (commaNeeded)
4969         _OUT << "\"" << str << "\""
4970              << " : " << obj << "," << std::endl;
4971     else
4972         _OUT << "\"" << str << "\""
4973              << " : " << obj << std::endl;
4974 }
print_VkDeviceCreateFlags(const VkDeviceCreateFlags * obj,const std::string & str,bool commaNeeded=true)4975 static void print_VkDeviceCreateFlags(const VkDeviceCreateFlags *obj, const std::string &str, bool commaNeeded = true)
4976 {
4977     PRINT_SPACE
4978     if (commaNeeded)
4979         _OUT << "\"" << str << "\""
4980              << " : " << obj << "," << std::endl;
4981     else
4982         _OUT << "\"" << str << "\""
4983              << " : " << obj << std::endl;
4984 }
4985 
print_VkDeviceQueueCreateFlags(VkDeviceQueueCreateFlags obj,const std::string & str,bool commaNeeded=true)4986 static void print_VkDeviceQueueCreateFlags(VkDeviceQueueCreateFlags obj, const std::string &str,
4987                                            bool commaNeeded = true)
4988 {
4989     PRINT_SPACE
4990     if (str != "")
4991         _OUT << "\"" << str << "\""
4992              << " : ";
4993     const int max_bits = 64; // We don't expect the number to be larger.
4994     std::bitset<max_bits> b(obj);
4995     _OUT << "\"";
4996     if (obj == 0)
4997         _OUT << "0";
4998     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
4999     {
5000         if (b[i] == 1)
5001         {
5002             bitCount++;
5003             if (bitCount < b.count())
5004                 _OUT << VkDeviceQueueCreateFlagBits_map[1ULL << i] << " | ";
5005             else
5006                 _OUT << VkDeviceQueueCreateFlagBits_map[1ULL << i];
5007         }
5008     }
5009     if (commaNeeded)
5010         _OUT << "\""
5011              << ",";
5012     else
5013         _OUT << "\""
5014              << "";
5015     _OUT << std::endl;
5016 }
print_VkDeviceQueueCreateFlags(const VkDeviceQueueCreateFlags * obj,const std::string & str,bool commaNeeded=true)5017 static void print_VkDeviceQueueCreateFlags(const VkDeviceQueueCreateFlags *obj, const std::string &str,
5018                                            bool commaNeeded = true)
5019 {
5020     PRINT_SPACE
5021     if (str != "")
5022         _OUT << "\"" << str << "\""
5023              << " : ";
5024     const int max_bits = 64; // We don't expect the number to be larger.
5025     std::bitset<max_bits> b(obj);
5026     _OUT << "\"";
5027     if (obj == 0)
5028         _OUT << "0";
5029     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5030     {
5031         if (b[i] == 1)
5032         {
5033             bitCount++;
5034             if (bitCount < b.count())
5035                 _OUT << VkDeviceQueueCreateFlagBits_map[1ULL << i] << " | ";
5036             else
5037                 _OUT << VkDeviceQueueCreateFlagBits_map[1ULL << i];
5038         }
5039     }
5040     if (commaNeeded)
5041         _OUT << "\""
5042              << ",";
5043     else
5044         _OUT << "\""
5045              << "";
5046     _OUT << std::endl;
5047 }
5048 
print_VkPipelineStageFlags(VkPipelineStageFlags obj,const std::string & str,bool commaNeeded=true)5049 static void print_VkPipelineStageFlags(VkPipelineStageFlags obj, const std::string &str, bool commaNeeded = true)
5050 {
5051     PRINT_SPACE
5052     if (str != "")
5053         _OUT << "\"" << str << "\""
5054              << " : ";
5055     const int max_bits = 64; // We don't expect the number to be larger.
5056     std::bitset<max_bits> b(obj);
5057     _OUT << "\"";
5058     if (obj == 0)
5059         _OUT << "0";
5060     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5061     {
5062         if (b[i] == 1)
5063         {
5064             bitCount++;
5065             if (bitCount < b.count())
5066                 _OUT << VkPipelineStageFlagBits_map[1ULL << i] << " | ";
5067             else
5068                 _OUT << VkPipelineStageFlagBits_map[1ULL << i];
5069         }
5070     }
5071     if (commaNeeded)
5072         _OUT << "\""
5073              << ",";
5074     else
5075         _OUT << "\""
5076              << "";
5077     _OUT << std::endl;
5078 }
print_VkPipelineStageFlags(const VkPipelineStageFlags * obj,const std::string & str,bool commaNeeded=true)5079 static void print_VkPipelineStageFlags(const VkPipelineStageFlags *obj, const std::string &str, bool commaNeeded = true)
5080 {
5081     PRINT_SPACE
5082     if (str != "")
5083         _OUT << "\"" << str << "\""
5084              << " : ";
5085     const int max_bits = 64; // We don't expect the number to be larger.
5086     std::bitset<max_bits> b(obj);
5087     _OUT << "\"";
5088     if (obj == 0)
5089         _OUT << "0";
5090     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5091     {
5092         if (b[i] == 1)
5093         {
5094             bitCount++;
5095             if (bitCount < b.count())
5096                 _OUT << VkPipelineStageFlagBits_map[1ULL << i] << " | ";
5097             else
5098                 _OUT << VkPipelineStageFlagBits_map[1ULL << i];
5099         }
5100     }
5101     if (commaNeeded)
5102         _OUT << "\""
5103              << ",";
5104     else
5105         _OUT << "\""
5106              << "";
5107     _OUT << std::endl;
5108 }
5109 
print_VkMemoryMapFlags(VkMemoryMapFlags obj,const std::string & str,bool commaNeeded=true)5110 static void print_VkMemoryMapFlags(VkMemoryMapFlags obj, const std::string &str, bool commaNeeded = true)
5111 {
5112     PRINT_SPACE
5113     if (commaNeeded)
5114         _OUT << "\"" << str << "\""
5115              << " : " << obj << "," << std::endl;
5116     else
5117         _OUT << "\"" << str << "\""
5118              << " : " << obj << std::endl;
5119 }
print_VkMemoryMapFlags(const VkMemoryMapFlags * obj,const std::string & str,bool commaNeeded=true)5120 static void print_VkMemoryMapFlags(const VkMemoryMapFlags *obj, const std::string &str, bool commaNeeded = true)
5121 {
5122     PRINT_SPACE
5123     if (commaNeeded)
5124         _OUT << "\"" << str << "\""
5125              << " : " << obj << "," << std::endl;
5126     else
5127         _OUT << "\"" << str << "\""
5128              << " : " << obj << std::endl;
5129 }
5130 
print_VkFenceCreateFlags(VkFenceCreateFlags obj,const std::string & str,bool commaNeeded=true)5131 static void print_VkFenceCreateFlags(VkFenceCreateFlags obj, const std::string &str, bool commaNeeded = true)
5132 {
5133     PRINT_SPACE
5134     if (str != "")
5135         _OUT << "\"" << str << "\""
5136              << " : ";
5137     const int max_bits = 64; // We don't expect the number to be larger.
5138     std::bitset<max_bits> b(obj);
5139     _OUT << "\"";
5140     if (obj == 0)
5141         _OUT << "0";
5142     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5143     {
5144         if (b[i] == 1)
5145         {
5146             bitCount++;
5147             if (bitCount < b.count())
5148                 _OUT << VkFenceCreateFlagBits_map[1ULL << i] << " | ";
5149             else
5150                 _OUT << VkFenceCreateFlagBits_map[1ULL << i];
5151         }
5152     }
5153     if (commaNeeded)
5154         _OUT << "\""
5155              << ",";
5156     else
5157         _OUT << "\""
5158              << "";
5159     _OUT << std::endl;
5160 }
print_VkFenceCreateFlags(const VkFenceCreateFlags * obj,const std::string & str,bool commaNeeded=true)5161 static void print_VkFenceCreateFlags(const VkFenceCreateFlags *obj, const std::string &str, bool commaNeeded = true)
5162 {
5163     PRINT_SPACE
5164     if (str != "")
5165         _OUT << "\"" << str << "\""
5166              << " : ";
5167     const int max_bits = 64; // We don't expect the number to be larger.
5168     std::bitset<max_bits> b(obj);
5169     _OUT << "\"";
5170     if (obj == 0)
5171         _OUT << "0";
5172     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5173     {
5174         if (b[i] == 1)
5175         {
5176             bitCount++;
5177             if (bitCount < b.count())
5178                 _OUT << VkFenceCreateFlagBits_map[1ULL << i] << " | ";
5179             else
5180                 _OUT << VkFenceCreateFlagBits_map[1ULL << i];
5181         }
5182     }
5183     if (commaNeeded)
5184         _OUT << "\""
5185              << ",";
5186     else
5187         _OUT << "\""
5188              << "";
5189     _OUT << std::endl;
5190 }
5191 
print_VkSemaphoreCreateFlags(VkSemaphoreCreateFlags obj,const std::string & str,bool commaNeeded=true)5192 static void print_VkSemaphoreCreateFlags(VkSemaphoreCreateFlags obj, const std::string &str, bool commaNeeded = true)
5193 {
5194     PRINT_SPACE
5195     if (commaNeeded)
5196         _OUT << "\"" << str << "\""
5197              << " : " << obj << "," << std::endl;
5198     else
5199         _OUT << "\"" << str << "\""
5200              << " : " << obj << std::endl;
5201 }
print_VkSemaphoreCreateFlags(const VkSemaphoreCreateFlags * obj,const std::string & str,bool commaNeeded=true)5202 static void print_VkSemaphoreCreateFlags(const VkSemaphoreCreateFlags *obj, const std::string &str,
5203                                          bool commaNeeded = true)
5204 {
5205     PRINT_SPACE
5206     if (commaNeeded)
5207         _OUT << "\"" << str << "\""
5208              << " : " << obj << "," << std::endl;
5209     else
5210         _OUT << "\"" << str << "\""
5211              << " : " << obj << std::endl;
5212 }
5213 
print_VkEventCreateFlags(VkEventCreateFlags obj,const std::string & str,bool commaNeeded=true)5214 static void print_VkEventCreateFlags(VkEventCreateFlags obj, const std::string &str, bool commaNeeded = true)
5215 {
5216     PRINT_SPACE
5217     if (str != "")
5218         _OUT << "\"" << str << "\""
5219              << " : ";
5220     const int max_bits = 64; // We don't expect the number to be larger.
5221     std::bitset<max_bits> b(obj);
5222     _OUT << "\"";
5223     if (obj == 0)
5224         _OUT << "0";
5225     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5226     {
5227         if (b[i] == 1)
5228         {
5229             bitCount++;
5230             if (bitCount < b.count())
5231                 _OUT << VkEventCreateFlagBits_map[1ULL << i] << " | ";
5232             else
5233                 _OUT << VkEventCreateFlagBits_map[1ULL << i];
5234         }
5235     }
5236     if (commaNeeded)
5237         _OUT << "\""
5238              << ",";
5239     else
5240         _OUT << "\""
5241              << "";
5242     _OUT << std::endl;
5243 }
print_VkEventCreateFlags(const VkEventCreateFlags * obj,const std::string & str,bool commaNeeded=true)5244 static void print_VkEventCreateFlags(const VkEventCreateFlags *obj, const std::string &str, bool commaNeeded = true)
5245 {
5246     PRINT_SPACE
5247     if (str != "")
5248         _OUT << "\"" << str << "\""
5249              << " : ";
5250     const int max_bits = 64; // We don't expect the number to be larger.
5251     std::bitset<max_bits> b(obj);
5252     _OUT << "\"";
5253     if (obj == 0)
5254         _OUT << "0";
5255     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5256     {
5257         if (b[i] == 1)
5258         {
5259             bitCount++;
5260             if (bitCount < b.count())
5261                 _OUT << VkEventCreateFlagBits_map[1ULL << i] << " | ";
5262             else
5263                 _OUT << VkEventCreateFlagBits_map[1ULL << i];
5264         }
5265     }
5266     if (commaNeeded)
5267         _OUT << "\""
5268              << ",";
5269     else
5270         _OUT << "\""
5271              << "";
5272     _OUT << std::endl;
5273 }
5274 
print_VkQueryPipelineStatisticFlags(VkQueryPipelineStatisticFlags obj,const std::string & str,bool commaNeeded=true)5275 static void print_VkQueryPipelineStatisticFlags(VkQueryPipelineStatisticFlags obj, const std::string &str,
5276                                                 bool commaNeeded = true)
5277 {
5278     PRINT_SPACE
5279     if (str != "")
5280         _OUT << "\"" << str << "\""
5281              << " : ";
5282     const int max_bits = 64; // We don't expect the number to be larger.
5283     std::bitset<max_bits> b(obj);
5284     _OUT << "\"";
5285     if (obj == 0)
5286         _OUT << "0";
5287     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5288     {
5289         if (b[i] == 1)
5290         {
5291             bitCount++;
5292             if (bitCount < b.count())
5293                 _OUT << VkQueryPipelineStatisticFlagBits_map[1ULL << i] << " | ";
5294             else
5295                 _OUT << VkQueryPipelineStatisticFlagBits_map[1ULL << i];
5296         }
5297     }
5298     if (commaNeeded)
5299         _OUT << "\""
5300              << ",";
5301     else
5302         _OUT << "\""
5303              << "";
5304     _OUT << std::endl;
5305 }
print_VkQueryPipelineStatisticFlags(const VkQueryPipelineStatisticFlags * obj,const std::string & str,bool commaNeeded=true)5306 static void print_VkQueryPipelineStatisticFlags(const VkQueryPipelineStatisticFlags *obj, const std::string &str,
5307                                                 bool commaNeeded = true)
5308 {
5309     PRINT_SPACE
5310     if (str != "")
5311         _OUT << "\"" << str << "\""
5312              << " : ";
5313     const int max_bits = 64; // We don't expect the number to be larger.
5314     std::bitset<max_bits> b(obj);
5315     _OUT << "\"";
5316     if (obj == 0)
5317         _OUT << "0";
5318     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5319     {
5320         if (b[i] == 1)
5321         {
5322             bitCount++;
5323             if (bitCount < b.count())
5324                 _OUT << VkQueryPipelineStatisticFlagBits_map[1ULL << i] << " | ";
5325             else
5326                 _OUT << VkQueryPipelineStatisticFlagBits_map[1ULL << i];
5327         }
5328     }
5329     if (commaNeeded)
5330         _OUT << "\""
5331              << ",";
5332     else
5333         _OUT << "\""
5334              << "";
5335     _OUT << std::endl;
5336 }
5337 
print_VkQueryPoolCreateFlags(VkQueryPoolCreateFlags obj,const std::string & str,bool commaNeeded=true)5338 static void print_VkQueryPoolCreateFlags(VkQueryPoolCreateFlags obj, const std::string &str, bool commaNeeded = true)
5339 {
5340     PRINT_SPACE
5341     if (commaNeeded)
5342         _OUT << "\"" << str << "\""
5343              << " : " << obj << "," << std::endl;
5344     else
5345         _OUT << "\"" << str << "\""
5346              << " : " << obj << std::endl;
5347 }
print_VkQueryPoolCreateFlags(const VkQueryPoolCreateFlags * obj,const std::string & str,bool commaNeeded=true)5348 static void print_VkQueryPoolCreateFlags(const VkQueryPoolCreateFlags *obj, const std::string &str,
5349                                          bool commaNeeded = true)
5350 {
5351     PRINT_SPACE
5352     if (commaNeeded)
5353         _OUT << "\"" << str << "\""
5354              << " : " << obj << "," << std::endl;
5355     else
5356         _OUT << "\"" << str << "\""
5357              << " : " << obj << std::endl;
5358 }
5359 
print_VkQueryResultFlags(VkQueryResultFlags obj,const std::string & str,bool commaNeeded=true)5360 static void print_VkQueryResultFlags(VkQueryResultFlags obj, const std::string &str, bool commaNeeded = true)
5361 {
5362     PRINT_SPACE
5363     if (str != "")
5364         _OUT << "\"" << str << "\""
5365              << " : ";
5366     const int max_bits = 64; // We don't expect the number to be larger.
5367     std::bitset<max_bits> b(obj);
5368     _OUT << "\"";
5369     if (obj == 0)
5370         _OUT << "0";
5371     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5372     {
5373         if (b[i] == 1)
5374         {
5375             bitCount++;
5376             if (bitCount < b.count())
5377                 _OUT << VkQueryResultFlagBits_map[1ULL << i] << " | ";
5378             else
5379                 _OUT << VkQueryResultFlagBits_map[1ULL << i];
5380         }
5381     }
5382     if (commaNeeded)
5383         _OUT << "\""
5384              << ",";
5385     else
5386         _OUT << "\""
5387              << "";
5388     _OUT << std::endl;
5389 }
print_VkQueryResultFlags(const VkQueryResultFlags * obj,const std::string & str,bool commaNeeded=true)5390 static void print_VkQueryResultFlags(const VkQueryResultFlags *obj, const std::string &str, bool commaNeeded = true)
5391 {
5392     PRINT_SPACE
5393     if (str != "")
5394         _OUT << "\"" << str << "\""
5395              << " : ";
5396     const int max_bits = 64; // We don't expect the number to be larger.
5397     std::bitset<max_bits> b(obj);
5398     _OUT << "\"";
5399     if (obj == 0)
5400         _OUT << "0";
5401     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5402     {
5403         if (b[i] == 1)
5404         {
5405             bitCount++;
5406             if (bitCount < b.count())
5407                 _OUT << VkQueryResultFlagBits_map[1ULL << i] << " | ";
5408             else
5409                 _OUT << VkQueryResultFlagBits_map[1ULL << i];
5410         }
5411     }
5412     if (commaNeeded)
5413         _OUT << "\""
5414              << ",";
5415     else
5416         _OUT << "\""
5417              << "";
5418     _OUT << std::endl;
5419 }
5420 
print_VkBufferCreateFlags(VkBufferCreateFlags obj,const std::string & str,bool commaNeeded=true)5421 static void print_VkBufferCreateFlags(VkBufferCreateFlags obj, const std::string &str, bool commaNeeded = true)
5422 {
5423     PRINT_SPACE
5424     if (str != "")
5425         _OUT << "\"" << str << "\""
5426              << " : ";
5427     const int max_bits = 64; // We don't expect the number to be larger.
5428     std::bitset<max_bits> b(obj);
5429     _OUT << "\"";
5430     if (obj == 0)
5431         _OUT << "0";
5432     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5433     {
5434         if (b[i] == 1)
5435         {
5436             bitCount++;
5437             if (bitCount < b.count())
5438                 _OUT << VkBufferCreateFlagBits_map[1ULL << i] << " | ";
5439             else
5440                 _OUT << VkBufferCreateFlagBits_map[1ULL << i];
5441         }
5442     }
5443     if (commaNeeded)
5444         _OUT << "\""
5445              << ",";
5446     else
5447         _OUT << "\""
5448              << "";
5449     _OUT << std::endl;
5450 }
print_VkBufferCreateFlags(const VkBufferCreateFlags * obj,const std::string & str,bool commaNeeded=true)5451 static void print_VkBufferCreateFlags(const VkBufferCreateFlags *obj, const std::string &str, bool commaNeeded = true)
5452 {
5453     PRINT_SPACE
5454     if (str != "")
5455         _OUT << "\"" << str << "\""
5456              << " : ";
5457     const int max_bits = 64; // We don't expect the number to be larger.
5458     std::bitset<max_bits> b(obj);
5459     _OUT << "\"";
5460     if (obj == 0)
5461         _OUT << "0";
5462     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5463     {
5464         if (b[i] == 1)
5465         {
5466             bitCount++;
5467             if (bitCount < b.count())
5468                 _OUT << VkBufferCreateFlagBits_map[1ULL << i] << " | ";
5469             else
5470                 _OUT << VkBufferCreateFlagBits_map[1ULL << i];
5471         }
5472     }
5473     if (commaNeeded)
5474         _OUT << "\""
5475              << ",";
5476     else
5477         _OUT << "\""
5478              << "";
5479     _OUT << std::endl;
5480 }
5481 
print_VkBufferUsageFlags(VkBufferUsageFlags obj,const std::string & str,bool commaNeeded=true)5482 static void print_VkBufferUsageFlags(VkBufferUsageFlags obj, const std::string &str, bool commaNeeded = true)
5483 {
5484     PRINT_SPACE
5485     if (str != "")
5486         _OUT << "\"" << str << "\""
5487              << " : ";
5488     const int max_bits = 64; // We don't expect the number to be larger.
5489     std::bitset<max_bits> b(obj);
5490     _OUT << "\"";
5491     if (obj == 0)
5492         _OUT << "0";
5493     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5494     {
5495         if (b[i] == 1)
5496         {
5497             bitCount++;
5498             if (bitCount < b.count())
5499                 _OUT << VkBufferUsageFlagBits_map[1ULL << i] << " | ";
5500             else
5501                 _OUT << VkBufferUsageFlagBits_map[1ULL << i];
5502         }
5503     }
5504     if (commaNeeded)
5505         _OUT << "\""
5506              << ",";
5507     else
5508         _OUT << "\""
5509              << "";
5510     _OUT << std::endl;
5511 }
print_VkBufferUsageFlags(const VkBufferUsageFlags * obj,const std::string & str,bool commaNeeded=true)5512 static void print_VkBufferUsageFlags(const VkBufferUsageFlags *obj, const std::string &str, bool commaNeeded = true)
5513 {
5514     PRINT_SPACE
5515     if (str != "")
5516         _OUT << "\"" << str << "\""
5517              << " : ";
5518     const int max_bits = 64; // We don't expect the number to be larger.
5519     std::bitset<max_bits> b(obj);
5520     _OUT << "\"";
5521     if (obj == 0)
5522         _OUT << "0";
5523     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5524     {
5525         if (b[i] == 1)
5526         {
5527             bitCount++;
5528             if (bitCount < b.count())
5529                 _OUT << VkBufferUsageFlagBits_map[1ULL << i] << " | ";
5530             else
5531                 _OUT << VkBufferUsageFlagBits_map[1ULL << i];
5532         }
5533     }
5534     if (commaNeeded)
5535         _OUT << "\""
5536              << ",";
5537     else
5538         _OUT << "\""
5539              << "";
5540     _OUT << std::endl;
5541 }
5542 
print_VkBufferViewCreateFlags(VkBufferViewCreateFlags obj,const std::string & str,bool commaNeeded=true)5543 static void print_VkBufferViewCreateFlags(VkBufferViewCreateFlags obj, const std::string &str, bool commaNeeded = true)
5544 {
5545     PRINT_SPACE
5546     if (commaNeeded)
5547         _OUT << "\"" << str << "\""
5548              << " : " << obj << "," << std::endl;
5549     else
5550         _OUT << "\"" << str << "\""
5551              << " : " << obj << std::endl;
5552 }
print_VkBufferViewCreateFlags(const VkBufferViewCreateFlags * obj,const std::string & str,bool commaNeeded=true)5553 static void print_VkBufferViewCreateFlags(const VkBufferViewCreateFlags *obj, const std::string &str,
5554                                           bool commaNeeded = true)
5555 {
5556     PRINT_SPACE
5557     if (commaNeeded)
5558         _OUT << "\"" << str << "\""
5559              << " : " << obj << "," << std::endl;
5560     else
5561         _OUT << "\"" << str << "\""
5562              << " : " << obj << std::endl;
5563 }
5564 
print_VkImageViewCreateFlags(VkImageViewCreateFlags obj,const std::string & str,bool commaNeeded=true)5565 static void print_VkImageViewCreateFlags(VkImageViewCreateFlags obj, const std::string &str, bool commaNeeded = true)
5566 {
5567     PRINT_SPACE
5568     if (str != "")
5569         _OUT << "\"" << str << "\""
5570              << " : ";
5571     const int max_bits = 64; // We don't expect the number to be larger.
5572     std::bitset<max_bits> b(obj);
5573     _OUT << "\"";
5574     if (obj == 0)
5575         _OUT << "0";
5576     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5577     {
5578         if (b[i] == 1)
5579         {
5580             bitCount++;
5581             if (bitCount < b.count())
5582                 _OUT << VkImageViewCreateFlagBits_map[1ULL << i] << " | ";
5583             else
5584                 _OUT << VkImageViewCreateFlagBits_map[1ULL << i];
5585         }
5586     }
5587     if (commaNeeded)
5588         _OUT << "\""
5589              << ",";
5590     else
5591         _OUT << "\""
5592              << "";
5593     _OUT << std::endl;
5594 }
print_VkImageViewCreateFlags(const VkImageViewCreateFlags * obj,const std::string & str,bool commaNeeded=true)5595 static void print_VkImageViewCreateFlags(const VkImageViewCreateFlags *obj, const std::string &str,
5596                                          bool commaNeeded = true)
5597 {
5598     PRINT_SPACE
5599     if (str != "")
5600         _OUT << "\"" << str << "\""
5601              << " : ";
5602     const int max_bits = 64; // We don't expect the number to be larger.
5603     std::bitset<max_bits> b(obj);
5604     _OUT << "\"";
5605     if (obj == 0)
5606         _OUT << "0";
5607     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5608     {
5609         if (b[i] == 1)
5610         {
5611             bitCount++;
5612             if (bitCount < b.count())
5613                 _OUT << VkImageViewCreateFlagBits_map[1ULL << i] << " | ";
5614             else
5615                 _OUT << VkImageViewCreateFlagBits_map[1ULL << i];
5616         }
5617     }
5618     if (commaNeeded)
5619         _OUT << "\""
5620              << ",";
5621     else
5622         _OUT << "\""
5623              << "";
5624     _OUT << std::endl;
5625 }
5626 
print_VkPipelineCacheCreateFlags(VkPipelineCacheCreateFlags obj,const std::string & str,bool commaNeeded=true)5627 static void print_VkPipelineCacheCreateFlags(VkPipelineCacheCreateFlags obj, const std::string &str,
5628                                              bool commaNeeded = true)
5629 {
5630     PRINT_SPACE
5631     if (str != "")
5632         _OUT << "\"" << str << "\""
5633              << " : ";
5634     const int max_bits = 64; // We don't expect the number to be larger.
5635     std::bitset<max_bits> b(obj);
5636     _OUT << "\"";
5637     if (obj == 0)
5638         _OUT << "0";
5639     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5640     {
5641         if (b[i] == 1)
5642         {
5643             bitCount++;
5644             if (bitCount < b.count())
5645                 _OUT << VkPipelineCacheCreateFlagBits_map[1ULL << i] << " | ";
5646             else
5647                 _OUT << VkPipelineCacheCreateFlagBits_map[1ULL << i];
5648         }
5649     }
5650     if (commaNeeded)
5651         _OUT << "\""
5652              << ",";
5653     else
5654         _OUT << "\""
5655              << "";
5656     _OUT << std::endl;
5657 }
print_VkPipelineCacheCreateFlags(const VkPipelineCacheCreateFlags * obj,const std::string & str,bool commaNeeded=true)5658 static void print_VkPipelineCacheCreateFlags(const VkPipelineCacheCreateFlags *obj, const std::string &str,
5659                                              bool commaNeeded = true)
5660 {
5661     PRINT_SPACE
5662     if (str != "")
5663         _OUT << "\"" << str << "\""
5664              << " : ";
5665     const int max_bits = 64; // We don't expect the number to be larger.
5666     std::bitset<max_bits> b(obj);
5667     _OUT << "\"";
5668     if (obj == 0)
5669         _OUT << "0";
5670     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5671     {
5672         if (b[i] == 1)
5673         {
5674             bitCount++;
5675             if (bitCount < b.count())
5676                 _OUT << VkPipelineCacheCreateFlagBits_map[1ULL << i] << " | ";
5677             else
5678                 _OUT << VkPipelineCacheCreateFlagBits_map[1ULL << i];
5679         }
5680     }
5681     if (commaNeeded)
5682         _OUT << "\""
5683              << ",";
5684     else
5685         _OUT << "\""
5686              << "";
5687     _OUT << std::endl;
5688 }
5689 
print_VkColorComponentFlags(VkColorComponentFlags obj,const std::string & str,bool commaNeeded=true)5690 static void print_VkColorComponentFlags(VkColorComponentFlags obj, const std::string &str, bool commaNeeded = true)
5691 {
5692     PRINT_SPACE
5693     if (str != "")
5694         _OUT << "\"" << str << "\""
5695              << " : ";
5696     const int max_bits = 64; // We don't expect the number to be larger.
5697     std::bitset<max_bits> b(obj);
5698     _OUT << "\"";
5699     if (obj == 0)
5700         _OUT << "0";
5701     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5702     {
5703         if (b[i] == 1)
5704         {
5705             bitCount++;
5706             if (bitCount < b.count())
5707                 _OUT << VkColorComponentFlagBits_map[1ULL << i] << " | ";
5708             else
5709                 _OUT << VkColorComponentFlagBits_map[1ULL << i];
5710         }
5711     }
5712     if (commaNeeded)
5713         _OUT << "\""
5714              << ",";
5715     else
5716         _OUT << "\""
5717              << "";
5718     _OUT << std::endl;
5719 }
print_VkColorComponentFlags(const VkColorComponentFlags * obj,const std::string & str,bool commaNeeded=true)5720 static void print_VkColorComponentFlags(const VkColorComponentFlags *obj, const std::string &str,
5721                                         bool commaNeeded = true)
5722 {
5723     PRINT_SPACE
5724     if (str != "")
5725         _OUT << "\"" << str << "\""
5726              << " : ";
5727     const int max_bits = 64; // We don't expect the number to be larger.
5728     std::bitset<max_bits> b(obj);
5729     _OUT << "\"";
5730     if (obj == 0)
5731         _OUT << "0";
5732     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5733     {
5734         if (b[i] == 1)
5735         {
5736             bitCount++;
5737             if (bitCount < b.count())
5738                 _OUT << VkColorComponentFlagBits_map[1ULL << i] << " | ";
5739             else
5740                 _OUT << VkColorComponentFlagBits_map[1ULL << i];
5741         }
5742     }
5743     if (commaNeeded)
5744         _OUT << "\""
5745              << ",";
5746     else
5747         _OUT << "\""
5748              << "";
5749     _OUT << std::endl;
5750 }
5751 
print_VkPipelineCreateFlags(VkPipelineCreateFlags obj,const std::string & str,bool commaNeeded=true)5752 static void print_VkPipelineCreateFlags(VkPipelineCreateFlags obj, const std::string &str, bool commaNeeded = true)
5753 {
5754     PRINT_SPACE
5755     if (str != "")
5756         _OUT << "\"" << str << "\""
5757              << " : ";
5758     const int max_bits = 64; // We don't expect the number to be larger.
5759     std::bitset<max_bits> b(obj);
5760     _OUT << "\"";
5761     if (obj == 0)
5762         _OUT << "0";
5763     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5764     {
5765         if (b[i] == 1)
5766         {
5767             bitCount++;
5768             if (bitCount < b.count())
5769                 _OUT << VkPipelineCreateFlagBits_map[1ULL << i] << " | ";
5770             else
5771                 _OUT << VkPipelineCreateFlagBits_map[1ULL << i];
5772         }
5773     }
5774     if (commaNeeded)
5775         _OUT << "\""
5776              << ",";
5777     else
5778         _OUT << "\""
5779              << "";
5780     _OUT << std::endl;
5781 }
print_VkPipelineCreateFlags(const VkPipelineCreateFlags * obj,const std::string & str,bool commaNeeded=true)5782 static void print_VkPipelineCreateFlags(const VkPipelineCreateFlags *obj, const std::string &str,
5783                                         bool commaNeeded = true)
5784 {
5785     PRINT_SPACE
5786     if (str != "")
5787         _OUT << "\"" << str << "\""
5788              << " : ";
5789     const int max_bits = 64; // We don't expect the number to be larger.
5790     std::bitset<max_bits> b(obj);
5791     _OUT << "\"";
5792     if (obj == 0)
5793         _OUT << "0";
5794     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5795     {
5796         if (b[i] == 1)
5797         {
5798             bitCount++;
5799             if (bitCount < b.count())
5800                 _OUT << VkPipelineCreateFlagBits_map[1ULL << i] << " | ";
5801             else
5802                 _OUT << VkPipelineCreateFlagBits_map[1ULL << i];
5803         }
5804     }
5805     if (commaNeeded)
5806         _OUT << "\""
5807              << ",";
5808     else
5809         _OUT << "\""
5810              << "";
5811     _OUT << std::endl;
5812 }
5813 
print_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags obj,const std::string & str,bool commaNeeded=true)5814 static void print_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags obj, const std::string &str,
5815                                                    bool commaNeeded = true)
5816 {
5817     PRINT_SPACE
5818     if (str != "")
5819         _OUT << "\"" << str << "\""
5820              << " : ";
5821     const int max_bits = 64; // We don't expect the number to be larger.
5822     std::bitset<max_bits> b(obj);
5823     _OUT << "\"";
5824     if (obj == 0)
5825         _OUT << "0";
5826     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5827     {
5828         if (b[i] == 1)
5829         {
5830             bitCount++;
5831             if (bitCount < b.count())
5832                 _OUT << VkPipelineShaderStageCreateFlagBits_map[1ULL << i] << " | ";
5833             else
5834                 _OUT << VkPipelineShaderStageCreateFlagBits_map[1ULL << i];
5835         }
5836     }
5837     if (commaNeeded)
5838         _OUT << "\""
5839              << ",";
5840     else
5841         _OUT << "\""
5842              << "";
5843     _OUT << std::endl;
5844 }
print_VkPipelineShaderStageCreateFlags(const VkPipelineShaderStageCreateFlags * obj,const std::string & str,bool commaNeeded=true)5845 static void print_VkPipelineShaderStageCreateFlags(const VkPipelineShaderStageCreateFlags *obj, const std::string &str,
5846                                                    bool commaNeeded = true)
5847 {
5848     PRINT_SPACE
5849     if (str != "")
5850         _OUT << "\"" << str << "\""
5851              << " : ";
5852     const int max_bits = 64; // We don't expect the number to be larger.
5853     std::bitset<max_bits> b(obj);
5854     _OUT << "\"";
5855     if (obj == 0)
5856         _OUT << "0";
5857     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5858     {
5859         if (b[i] == 1)
5860         {
5861             bitCount++;
5862             if (bitCount < b.count())
5863                 _OUT << VkPipelineShaderStageCreateFlagBits_map[1ULL << i] << " | ";
5864             else
5865                 _OUT << VkPipelineShaderStageCreateFlagBits_map[1ULL << i];
5866         }
5867     }
5868     if (commaNeeded)
5869         _OUT << "\""
5870              << ",";
5871     else
5872         _OUT << "\""
5873              << "";
5874     _OUT << std::endl;
5875 }
5876 
print_VkCullModeFlags(VkCullModeFlags obj,const std::string & str,bool commaNeeded=true)5877 static void print_VkCullModeFlags(VkCullModeFlags obj, const std::string &str, bool commaNeeded = true)
5878 {
5879     PRINT_SPACE
5880     if (str != "")
5881         _OUT << "\"" << str << "\""
5882              << " : ";
5883     const int max_bits = 64; // We don't expect the number to be larger.
5884     std::bitset<max_bits> b(obj);
5885     _OUT << "\"";
5886     if (obj == 0)
5887         _OUT << "0";
5888     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5889     {
5890         if (b[i] == 1)
5891         {
5892             bitCount++;
5893             if (bitCount < b.count())
5894                 _OUT << VkCullModeFlagBits_map[1ULL << i] << " | ";
5895             else
5896                 _OUT << VkCullModeFlagBits_map[1ULL << i];
5897         }
5898     }
5899     if (commaNeeded)
5900         _OUT << "\""
5901              << ",";
5902     else
5903         _OUT << "\""
5904              << "";
5905     _OUT << std::endl;
5906 }
print_VkCullModeFlags(const VkCullModeFlags * obj,const std::string & str,bool commaNeeded=true)5907 static void print_VkCullModeFlags(const VkCullModeFlags *obj, const std::string &str, bool commaNeeded = true)
5908 {
5909     PRINT_SPACE
5910     if (str != "")
5911         _OUT << "\"" << str << "\""
5912              << " : ";
5913     const int max_bits = 64; // We don't expect the number to be larger.
5914     std::bitset<max_bits> b(obj);
5915     _OUT << "\"";
5916     if (obj == 0)
5917         _OUT << "0";
5918     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
5919     {
5920         if (b[i] == 1)
5921         {
5922             bitCount++;
5923             if (bitCount < b.count())
5924                 _OUT << VkCullModeFlagBits_map[1ULL << i] << " | ";
5925             else
5926                 _OUT << VkCullModeFlagBits_map[1ULL << i];
5927         }
5928     }
5929     if (commaNeeded)
5930         _OUT << "\""
5931              << ",";
5932     else
5933         _OUT << "\""
5934              << "";
5935     _OUT << std::endl;
5936 }
5937 
print_VkPipelineVertexInputStateCreateFlags(VkPipelineVertexInputStateCreateFlags obj,const std::string & str,bool commaNeeded=true)5938 static void print_VkPipelineVertexInputStateCreateFlags(VkPipelineVertexInputStateCreateFlags obj,
5939                                                         const std::string &str, bool commaNeeded = true)
5940 {
5941     PRINT_SPACE
5942     if (commaNeeded)
5943         _OUT << "\"" << str << "\""
5944              << " : " << obj << "," << std::endl;
5945     else
5946         _OUT << "\"" << str << "\""
5947              << " : " << obj << std::endl;
5948 }
print_VkPipelineVertexInputStateCreateFlags(const VkPipelineVertexInputStateCreateFlags * obj,const std::string & str,bool commaNeeded=true)5949 static void print_VkPipelineVertexInputStateCreateFlags(const VkPipelineVertexInputStateCreateFlags *obj,
5950                                                         const std::string &str, bool commaNeeded = true)
5951 {
5952     PRINT_SPACE
5953     if (commaNeeded)
5954         _OUT << "\"" << str << "\""
5955              << " : " << obj << "," << std::endl;
5956     else
5957         _OUT << "\"" << str << "\""
5958              << " : " << obj << std::endl;
5959 }
5960 
print_VkPipelineInputAssemblyStateCreateFlags(VkPipelineInputAssemblyStateCreateFlags obj,const std::string & str,bool commaNeeded=true)5961 static void print_VkPipelineInputAssemblyStateCreateFlags(VkPipelineInputAssemblyStateCreateFlags obj,
5962                                                           const std::string &str, bool commaNeeded = true)
5963 {
5964     PRINT_SPACE
5965     if (commaNeeded)
5966         _OUT << "\"" << str << "\""
5967              << " : " << obj << "," << std::endl;
5968     else
5969         _OUT << "\"" << str << "\""
5970              << " : " << obj << std::endl;
5971 }
print_VkPipelineInputAssemblyStateCreateFlags(const VkPipelineInputAssemblyStateCreateFlags * obj,const std::string & str,bool commaNeeded=true)5972 static void print_VkPipelineInputAssemblyStateCreateFlags(const VkPipelineInputAssemblyStateCreateFlags *obj,
5973                                                           const std::string &str, bool commaNeeded = true)
5974 {
5975     PRINT_SPACE
5976     if (commaNeeded)
5977         _OUT << "\"" << str << "\""
5978              << " : " << obj << "," << std::endl;
5979     else
5980         _OUT << "\"" << str << "\""
5981              << " : " << obj << std::endl;
5982 }
5983 
print_VkPipelineTessellationStateCreateFlags(VkPipelineTessellationStateCreateFlags obj,const std::string & str,bool commaNeeded=true)5984 static void print_VkPipelineTessellationStateCreateFlags(VkPipelineTessellationStateCreateFlags obj,
5985                                                          const std::string &str, bool commaNeeded = true)
5986 {
5987     PRINT_SPACE
5988     if (commaNeeded)
5989         _OUT << "\"" << str << "\""
5990              << " : " << obj << "," << std::endl;
5991     else
5992         _OUT << "\"" << str << "\""
5993              << " : " << obj << std::endl;
5994 }
print_VkPipelineTessellationStateCreateFlags(const VkPipelineTessellationStateCreateFlags * obj,const std::string & str,bool commaNeeded=true)5995 static void print_VkPipelineTessellationStateCreateFlags(const VkPipelineTessellationStateCreateFlags *obj,
5996                                                          const std::string &str, bool commaNeeded = true)
5997 {
5998     PRINT_SPACE
5999     if (commaNeeded)
6000         _OUT << "\"" << str << "\""
6001              << " : " << obj << "," << std::endl;
6002     else
6003         _OUT << "\"" << str << "\""
6004              << " : " << obj << std::endl;
6005 }
6006 
print_VkPipelineViewportStateCreateFlags(VkPipelineViewportStateCreateFlags obj,const std::string & str,bool commaNeeded=true)6007 static void print_VkPipelineViewportStateCreateFlags(VkPipelineViewportStateCreateFlags obj, const std::string &str,
6008                                                      bool commaNeeded = true)
6009 {
6010     PRINT_SPACE
6011     if (commaNeeded)
6012         _OUT << "\"" << str << "\""
6013              << " : " << obj << "," << std::endl;
6014     else
6015         _OUT << "\"" << str << "\""
6016              << " : " << obj << std::endl;
6017 }
print_VkPipelineViewportStateCreateFlags(const VkPipelineViewportStateCreateFlags * obj,const std::string & str,bool commaNeeded=true)6018 static void print_VkPipelineViewportStateCreateFlags(const VkPipelineViewportStateCreateFlags *obj,
6019                                                      const std::string &str, bool commaNeeded = true)
6020 {
6021     PRINT_SPACE
6022     if (commaNeeded)
6023         _OUT << "\"" << str << "\""
6024              << " : " << obj << "," << std::endl;
6025     else
6026         _OUT << "\"" << str << "\""
6027              << " : " << obj << std::endl;
6028 }
6029 
print_VkPipelineRasterizationStateCreateFlags(VkPipelineRasterizationStateCreateFlags obj,const std::string & str,bool commaNeeded=true)6030 static void print_VkPipelineRasterizationStateCreateFlags(VkPipelineRasterizationStateCreateFlags obj,
6031                                                           const std::string &str, bool commaNeeded = true)
6032 {
6033     PRINT_SPACE
6034     if (commaNeeded)
6035         _OUT << "\"" << str << "\""
6036              << " : " << obj << "," << std::endl;
6037     else
6038         _OUT << "\"" << str << "\""
6039              << " : " << obj << std::endl;
6040 }
print_VkPipelineRasterizationStateCreateFlags(const VkPipelineRasterizationStateCreateFlags * obj,const std::string & str,bool commaNeeded=true)6041 static void print_VkPipelineRasterizationStateCreateFlags(const VkPipelineRasterizationStateCreateFlags *obj,
6042                                                           const std::string &str, bool commaNeeded = true)
6043 {
6044     PRINT_SPACE
6045     if (commaNeeded)
6046         _OUT << "\"" << str << "\""
6047              << " : " << obj << "," << std::endl;
6048     else
6049         _OUT << "\"" << str << "\""
6050              << " : " << obj << std::endl;
6051 }
6052 
print_VkPipelineMultisampleStateCreateFlags(VkPipelineMultisampleStateCreateFlags obj,const std::string & str,bool commaNeeded=true)6053 static void print_VkPipelineMultisampleStateCreateFlags(VkPipelineMultisampleStateCreateFlags obj,
6054                                                         const std::string &str, bool commaNeeded = true)
6055 {
6056     PRINT_SPACE
6057     if (commaNeeded)
6058         _OUT << "\"" << str << "\""
6059              << " : " << obj << "," << std::endl;
6060     else
6061         _OUT << "\"" << str << "\""
6062              << " : " << obj << std::endl;
6063 }
print_VkPipelineMultisampleStateCreateFlags(const VkPipelineMultisampleStateCreateFlags * obj,const std::string & str,bool commaNeeded=true)6064 static void print_VkPipelineMultisampleStateCreateFlags(const VkPipelineMultisampleStateCreateFlags *obj,
6065                                                         const std::string &str, bool commaNeeded = true)
6066 {
6067     PRINT_SPACE
6068     if (commaNeeded)
6069         _OUT << "\"" << str << "\""
6070              << " : " << obj << "," << std::endl;
6071     else
6072         _OUT << "\"" << str << "\""
6073              << " : " << obj << std::endl;
6074 }
6075 
print_VkPipelineDepthStencilStateCreateFlags(VkPipelineDepthStencilStateCreateFlags obj,const std::string & str,bool commaNeeded=true)6076 static void print_VkPipelineDepthStencilStateCreateFlags(VkPipelineDepthStencilStateCreateFlags obj,
6077                                                          const std::string &str, bool commaNeeded = true)
6078 {
6079     PRINT_SPACE
6080     if (commaNeeded)
6081         _OUT << "\"" << str << "\""
6082              << " : " << obj << "," << std::endl;
6083     else
6084         _OUT << "\"" << str << "\""
6085              << " : " << obj << std::endl;
6086 }
print_VkPipelineDepthStencilStateCreateFlags(const VkPipelineDepthStencilStateCreateFlags * obj,const std::string & str,bool commaNeeded=true)6087 static void print_VkPipelineDepthStencilStateCreateFlags(const VkPipelineDepthStencilStateCreateFlags *obj,
6088                                                          const std::string &str, bool commaNeeded = true)
6089 {
6090     PRINT_SPACE
6091     if (commaNeeded)
6092         _OUT << "\"" << str << "\""
6093              << " : " << obj << "," << std::endl;
6094     else
6095         _OUT << "\"" << str << "\""
6096              << " : " << obj << std::endl;
6097 }
6098 
print_VkPipelineColorBlendStateCreateFlags(VkPipelineColorBlendStateCreateFlags obj,const std::string & str,bool commaNeeded=true)6099 static void print_VkPipelineColorBlendStateCreateFlags(VkPipelineColorBlendStateCreateFlags obj, const std::string &str,
6100                                                        bool commaNeeded = true)
6101 {
6102     PRINT_SPACE
6103     if (commaNeeded)
6104         _OUT << "\"" << str << "\""
6105              << " : " << obj << "," << std::endl;
6106     else
6107         _OUT << "\"" << str << "\""
6108              << " : " << obj << std::endl;
6109 }
print_VkPipelineColorBlendStateCreateFlags(const VkPipelineColorBlendStateCreateFlags * obj,const std::string & str,bool commaNeeded=true)6110 static void print_VkPipelineColorBlendStateCreateFlags(const VkPipelineColorBlendStateCreateFlags *obj,
6111                                                        const std::string &str, bool commaNeeded = true)
6112 {
6113     PRINT_SPACE
6114     if (commaNeeded)
6115         _OUT << "\"" << str << "\""
6116              << " : " << obj << "," << std::endl;
6117     else
6118         _OUT << "\"" << str << "\""
6119              << " : " << obj << std::endl;
6120 }
6121 
print_VkPipelineDynamicStateCreateFlags(VkPipelineDynamicStateCreateFlags obj,const std::string & str,bool commaNeeded=true)6122 static void print_VkPipelineDynamicStateCreateFlags(VkPipelineDynamicStateCreateFlags obj, const std::string &str,
6123                                                     bool commaNeeded = true)
6124 {
6125     PRINT_SPACE
6126     if (commaNeeded)
6127         _OUT << "\"" << str << "\""
6128              << " : " << obj << "," << std::endl;
6129     else
6130         _OUT << "\"" << str << "\""
6131              << " : " << obj << std::endl;
6132 }
print_VkPipelineDynamicStateCreateFlags(const VkPipelineDynamicStateCreateFlags * obj,const std::string & str,bool commaNeeded=true)6133 static void print_VkPipelineDynamicStateCreateFlags(const VkPipelineDynamicStateCreateFlags *obj,
6134                                                     const std::string &str, bool commaNeeded = true)
6135 {
6136     PRINT_SPACE
6137     if (commaNeeded)
6138         _OUT << "\"" << str << "\""
6139              << " : " << obj << "," << std::endl;
6140     else
6141         _OUT << "\"" << str << "\""
6142              << " : " << obj << std::endl;
6143 }
6144 
print_VkPipelineLayoutCreateFlags(VkPipelineLayoutCreateFlags obj,const std::string & str,bool commaNeeded=true)6145 static void print_VkPipelineLayoutCreateFlags(VkPipelineLayoutCreateFlags obj, const std::string &str,
6146                                               bool commaNeeded = true)
6147 {
6148     PRINT_SPACE
6149     if (commaNeeded)
6150         _OUT << "\"" << str << "\""
6151              << " : " << obj << "," << std::endl;
6152     else
6153         _OUT << "\"" << str << "\""
6154              << " : " << obj << std::endl;
6155 }
print_VkPipelineLayoutCreateFlags(const VkPipelineLayoutCreateFlags * obj,const std::string & str,bool commaNeeded=true)6156 static void print_VkPipelineLayoutCreateFlags(const VkPipelineLayoutCreateFlags *obj, const std::string &str,
6157                                               bool commaNeeded = true)
6158 {
6159     PRINT_SPACE
6160     if (commaNeeded)
6161         _OUT << "\"" << str << "\""
6162              << " : " << obj << "," << std::endl;
6163     else
6164         _OUT << "\"" << str << "\""
6165              << " : " << obj << std::endl;
6166 }
6167 
print_VkShaderStageFlags(VkShaderStageFlags obj,const std::string & str,bool commaNeeded=true)6168 static void print_VkShaderStageFlags(VkShaderStageFlags obj, const std::string &str, bool commaNeeded = true)
6169 {
6170     PRINT_SPACE
6171     if (str != "")
6172         _OUT << "\"" << str << "\""
6173              << " : ";
6174     const int max_bits = 64; // We don't expect the number to be larger.
6175     std::bitset<max_bits> b(obj);
6176     _OUT << "\"";
6177     if (obj == 0)
6178         _OUT << "0";
6179     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6180     {
6181         if (b[i] == 1)
6182         {
6183             bitCount++;
6184             if (bitCount < b.count())
6185                 _OUT << VkShaderStageFlagBits_map[1ULL << i] << " | ";
6186             else
6187                 _OUT << VkShaderStageFlagBits_map[1ULL << i];
6188         }
6189     }
6190     if (commaNeeded)
6191         _OUT << "\""
6192              << ",";
6193     else
6194         _OUT << "\""
6195              << "";
6196     _OUT << std::endl;
6197 }
print_VkShaderStageFlags(const VkShaderStageFlags * obj,const std::string & str,bool commaNeeded=true)6198 static void print_VkShaderStageFlags(const VkShaderStageFlags *obj, const std::string &str, bool commaNeeded = true)
6199 {
6200     PRINT_SPACE
6201     if (str != "")
6202         _OUT << "\"" << str << "\""
6203              << " : ";
6204     const int max_bits = 64; // We don't expect the number to be larger.
6205     std::bitset<max_bits> b(obj);
6206     _OUT << "\"";
6207     if (obj == 0)
6208         _OUT << "0";
6209     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6210     {
6211         if (b[i] == 1)
6212         {
6213             bitCount++;
6214             if (bitCount < b.count())
6215                 _OUT << VkShaderStageFlagBits_map[1ULL << i] << " | ";
6216             else
6217                 _OUT << VkShaderStageFlagBits_map[1ULL << i];
6218         }
6219     }
6220     if (commaNeeded)
6221         _OUT << "\""
6222              << ",";
6223     else
6224         _OUT << "\""
6225              << "";
6226     _OUT << std::endl;
6227 }
6228 
print_VkSamplerCreateFlags(VkSamplerCreateFlags obj,const std::string & str,bool commaNeeded=true)6229 static void print_VkSamplerCreateFlags(VkSamplerCreateFlags obj, const std::string &str, bool commaNeeded = true)
6230 {
6231     PRINT_SPACE
6232     if (str != "")
6233         _OUT << "\"" << str << "\""
6234              << " : ";
6235     const int max_bits = 64; // We don't expect the number to be larger.
6236     std::bitset<max_bits> b(obj);
6237     _OUT << "\"";
6238     if (obj == 0)
6239         _OUT << "0";
6240     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6241     {
6242         if (b[i] == 1)
6243         {
6244             bitCount++;
6245             if (bitCount < b.count())
6246                 _OUT << VkSamplerCreateFlagBits_map[1ULL << i] << " | ";
6247             else
6248                 _OUT << VkSamplerCreateFlagBits_map[1ULL << i];
6249         }
6250     }
6251     if (commaNeeded)
6252         _OUT << "\""
6253              << ",";
6254     else
6255         _OUT << "\""
6256              << "";
6257     _OUT << std::endl;
6258 }
print_VkSamplerCreateFlags(const VkSamplerCreateFlags * obj,const std::string & str,bool commaNeeded=true)6259 static void print_VkSamplerCreateFlags(const VkSamplerCreateFlags *obj, const std::string &str, bool commaNeeded = true)
6260 {
6261     PRINT_SPACE
6262     if (str != "")
6263         _OUT << "\"" << str << "\""
6264              << " : ";
6265     const int max_bits = 64; // We don't expect the number to be larger.
6266     std::bitset<max_bits> b(obj);
6267     _OUT << "\"";
6268     if (obj == 0)
6269         _OUT << "0";
6270     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6271     {
6272         if (b[i] == 1)
6273         {
6274             bitCount++;
6275             if (bitCount < b.count())
6276                 _OUT << VkSamplerCreateFlagBits_map[1ULL << i] << " | ";
6277             else
6278                 _OUT << VkSamplerCreateFlagBits_map[1ULL << i];
6279         }
6280     }
6281     if (commaNeeded)
6282         _OUT << "\""
6283              << ",";
6284     else
6285         _OUT << "\""
6286              << "";
6287     _OUT << std::endl;
6288 }
6289 
print_VkDescriptorPoolCreateFlags(VkDescriptorPoolCreateFlags obj,const std::string & str,bool commaNeeded=true)6290 static void print_VkDescriptorPoolCreateFlags(VkDescriptorPoolCreateFlags obj, const std::string &str,
6291                                               bool commaNeeded = true)
6292 {
6293     PRINT_SPACE
6294     if (str != "")
6295         _OUT << "\"" << str << "\""
6296              << " : ";
6297     const int max_bits = 64; // We don't expect the number to be larger.
6298     std::bitset<max_bits> b(obj);
6299     _OUT << "\"";
6300     if (obj == 0)
6301         _OUT << "0";
6302     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6303     {
6304         if (b[i] == 1)
6305         {
6306             bitCount++;
6307             if (bitCount < b.count())
6308                 _OUT << VkDescriptorPoolCreateFlagBits_map[1ULL << i] << " | ";
6309             else
6310                 _OUT << VkDescriptorPoolCreateFlagBits_map[1ULL << i];
6311         }
6312     }
6313     if (commaNeeded)
6314         _OUT << "\""
6315              << ",";
6316     else
6317         _OUT << "\""
6318              << "";
6319     _OUT << std::endl;
6320 }
print_VkDescriptorPoolCreateFlags(const VkDescriptorPoolCreateFlags * obj,const std::string & str,bool commaNeeded=true)6321 static void print_VkDescriptorPoolCreateFlags(const VkDescriptorPoolCreateFlags *obj, const std::string &str,
6322                                               bool commaNeeded = true)
6323 {
6324     PRINT_SPACE
6325     if (str != "")
6326         _OUT << "\"" << str << "\""
6327              << " : ";
6328     const int max_bits = 64; // We don't expect the number to be larger.
6329     std::bitset<max_bits> b(obj);
6330     _OUT << "\"";
6331     if (obj == 0)
6332         _OUT << "0";
6333     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6334     {
6335         if (b[i] == 1)
6336         {
6337             bitCount++;
6338             if (bitCount < b.count())
6339                 _OUT << VkDescriptorPoolCreateFlagBits_map[1ULL << i] << " | ";
6340             else
6341                 _OUT << VkDescriptorPoolCreateFlagBits_map[1ULL << i];
6342         }
6343     }
6344     if (commaNeeded)
6345         _OUT << "\""
6346              << ",";
6347     else
6348         _OUT << "\""
6349              << "";
6350     _OUT << std::endl;
6351 }
6352 
print_VkDescriptorPoolResetFlags(VkDescriptorPoolResetFlags obj,const std::string & str,bool commaNeeded=true)6353 static void print_VkDescriptorPoolResetFlags(VkDescriptorPoolResetFlags obj, const std::string &str,
6354                                              bool commaNeeded = true)
6355 {
6356     PRINT_SPACE
6357     if (commaNeeded)
6358         _OUT << "\"" << str << "\""
6359              << " : " << obj << "," << std::endl;
6360     else
6361         _OUT << "\"" << str << "\""
6362              << " : " << obj << std::endl;
6363 }
print_VkDescriptorPoolResetFlags(const VkDescriptorPoolResetFlags * obj,const std::string & str,bool commaNeeded=true)6364 static void print_VkDescriptorPoolResetFlags(const VkDescriptorPoolResetFlags *obj, const std::string &str,
6365                                              bool commaNeeded = true)
6366 {
6367     PRINT_SPACE
6368     if (commaNeeded)
6369         _OUT << "\"" << str << "\""
6370              << " : " << obj << "," << std::endl;
6371     else
6372         _OUT << "\"" << str << "\""
6373              << " : " << obj << std::endl;
6374 }
6375 
print_VkDescriptorSetLayoutCreateFlags(VkDescriptorSetLayoutCreateFlags obj,const std::string & str,bool commaNeeded=true)6376 static void print_VkDescriptorSetLayoutCreateFlags(VkDescriptorSetLayoutCreateFlags obj, const std::string &str,
6377                                                    bool commaNeeded = true)
6378 {
6379     PRINT_SPACE
6380     if (str != "")
6381         _OUT << "\"" << str << "\""
6382              << " : ";
6383     const int max_bits = 64; // We don't expect the number to be larger.
6384     std::bitset<max_bits> b(obj);
6385     _OUT << "\"";
6386     if (obj == 0)
6387         _OUT << "0";
6388     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6389     {
6390         if (b[i] == 1)
6391         {
6392             bitCount++;
6393             if (bitCount < b.count())
6394                 _OUT << VkDescriptorSetLayoutCreateFlagBits_map[1ULL << i] << " | ";
6395             else
6396                 _OUT << VkDescriptorSetLayoutCreateFlagBits_map[1ULL << i];
6397         }
6398     }
6399     if (commaNeeded)
6400         _OUT << "\""
6401              << ",";
6402     else
6403         _OUT << "\""
6404              << "";
6405     _OUT << std::endl;
6406 }
print_VkDescriptorSetLayoutCreateFlags(const VkDescriptorSetLayoutCreateFlags * obj,const std::string & str,bool commaNeeded=true)6407 static void print_VkDescriptorSetLayoutCreateFlags(const VkDescriptorSetLayoutCreateFlags *obj, const std::string &str,
6408                                                    bool commaNeeded = true)
6409 {
6410     PRINT_SPACE
6411     if (str != "")
6412         _OUT << "\"" << str << "\""
6413              << " : ";
6414     const int max_bits = 64; // We don't expect the number to be larger.
6415     std::bitset<max_bits> b(obj);
6416     _OUT << "\"";
6417     if (obj == 0)
6418         _OUT << "0";
6419     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6420     {
6421         if (b[i] == 1)
6422         {
6423             bitCount++;
6424             if (bitCount < b.count())
6425                 _OUT << VkDescriptorSetLayoutCreateFlagBits_map[1ULL << i] << " | ";
6426             else
6427                 _OUT << VkDescriptorSetLayoutCreateFlagBits_map[1ULL << i];
6428         }
6429     }
6430     if (commaNeeded)
6431         _OUT << "\""
6432              << ",";
6433     else
6434         _OUT << "\""
6435              << "";
6436     _OUT << std::endl;
6437 }
6438 
print_VkAttachmentDescriptionFlags(VkAttachmentDescriptionFlags obj,const std::string & str,bool commaNeeded=true)6439 static void print_VkAttachmentDescriptionFlags(VkAttachmentDescriptionFlags obj, const std::string &str,
6440                                                bool commaNeeded = true)
6441 {
6442     PRINT_SPACE
6443     if (str != "")
6444         _OUT << "\"" << str << "\""
6445              << " : ";
6446     const int max_bits = 64; // We don't expect the number to be larger.
6447     std::bitset<max_bits> b(obj);
6448     _OUT << "\"";
6449     if (obj == 0)
6450         _OUT << "0";
6451     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6452     {
6453         if (b[i] == 1)
6454         {
6455             bitCount++;
6456             if (bitCount < b.count())
6457                 _OUT << VkAttachmentDescriptionFlagBits_map[1ULL << i] << " | ";
6458             else
6459                 _OUT << VkAttachmentDescriptionFlagBits_map[1ULL << i];
6460         }
6461     }
6462     if (commaNeeded)
6463         _OUT << "\""
6464              << ",";
6465     else
6466         _OUT << "\""
6467              << "";
6468     _OUT << std::endl;
6469 }
print_VkAttachmentDescriptionFlags(const VkAttachmentDescriptionFlags * obj,const std::string & str,bool commaNeeded=true)6470 static void print_VkAttachmentDescriptionFlags(const VkAttachmentDescriptionFlags *obj, const std::string &str,
6471                                                bool commaNeeded = true)
6472 {
6473     PRINT_SPACE
6474     if (str != "")
6475         _OUT << "\"" << str << "\""
6476              << " : ";
6477     const int max_bits = 64; // We don't expect the number to be larger.
6478     std::bitset<max_bits> b(obj);
6479     _OUT << "\"";
6480     if (obj == 0)
6481         _OUT << "0";
6482     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6483     {
6484         if (b[i] == 1)
6485         {
6486             bitCount++;
6487             if (bitCount < b.count())
6488                 _OUT << VkAttachmentDescriptionFlagBits_map[1ULL << i] << " | ";
6489             else
6490                 _OUT << VkAttachmentDescriptionFlagBits_map[1ULL << i];
6491         }
6492     }
6493     if (commaNeeded)
6494         _OUT << "\""
6495              << ",";
6496     else
6497         _OUT << "\""
6498              << "";
6499     _OUT << std::endl;
6500 }
6501 
print_VkDependencyFlags(VkDependencyFlags obj,const std::string & str,bool commaNeeded=true)6502 static void print_VkDependencyFlags(VkDependencyFlags obj, const std::string &str, bool commaNeeded = true)
6503 {
6504     PRINT_SPACE
6505     if (str != "")
6506         _OUT << "\"" << str << "\""
6507              << " : ";
6508     const int max_bits = 64; // We don't expect the number to be larger.
6509     std::bitset<max_bits> b(obj);
6510     _OUT << "\"";
6511     if (obj == 0)
6512         _OUT << "0";
6513     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6514     {
6515         if (b[i] == 1)
6516         {
6517             bitCount++;
6518             if (bitCount < b.count())
6519                 _OUT << VkDependencyFlagBits_map[1ULL << i] << " | ";
6520             else
6521                 _OUT << VkDependencyFlagBits_map[1ULL << i];
6522         }
6523     }
6524     if (commaNeeded)
6525         _OUT << "\""
6526              << ",";
6527     else
6528         _OUT << "\""
6529              << "";
6530     _OUT << std::endl;
6531 }
print_VkDependencyFlags(const VkDependencyFlags * obj,const std::string & str,bool commaNeeded=true)6532 static void print_VkDependencyFlags(const VkDependencyFlags *obj, const std::string &str, bool commaNeeded = true)
6533 {
6534     PRINT_SPACE
6535     if (str != "")
6536         _OUT << "\"" << str << "\""
6537              << " : ";
6538     const int max_bits = 64; // We don't expect the number to be larger.
6539     std::bitset<max_bits> b(obj);
6540     _OUT << "\"";
6541     if (obj == 0)
6542         _OUT << "0";
6543     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6544     {
6545         if (b[i] == 1)
6546         {
6547             bitCount++;
6548             if (bitCount < b.count())
6549                 _OUT << VkDependencyFlagBits_map[1ULL << i] << " | ";
6550             else
6551                 _OUT << VkDependencyFlagBits_map[1ULL << i];
6552         }
6553     }
6554     if (commaNeeded)
6555         _OUT << "\""
6556              << ",";
6557     else
6558         _OUT << "\""
6559              << "";
6560     _OUT << std::endl;
6561 }
6562 
print_VkFramebufferCreateFlags(VkFramebufferCreateFlags obj,const std::string & str,bool commaNeeded=true)6563 static void print_VkFramebufferCreateFlags(VkFramebufferCreateFlags obj, const std::string &str,
6564                                            bool commaNeeded = true)
6565 {
6566     PRINT_SPACE
6567     if (str != "")
6568         _OUT << "\"" << str << "\""
6569              << " : ";
6570     const int max_bits = 64; // We don't expect the number to be larger.
6571     std::bitset<max_bits> b(obj);
6572     _OUT << "\"";
6573     if (obj == 0)
6574         _OUT << "0";
6575     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6576     {
6577         if (b[i] == 1)
6578         {
6579             bitCount++;
6580             if (bitCount < b.count())
6581                 _OUT << VkFramebufferCreateFlagBits_map[1ULL << i] << " | ";
6582             else
6583                 _OUT << VkFramebufferCreateFlagBits_map[1ULL << i];
6584         }
6585     }
6586     if (commaNeeded)
6587         _OUT << "\""
6588              << ",";
6589     else
6590         _OUT << "\""
6591              << "";
6592     _OUT << std::endl;
6593 }
print_VkFramebufferCreateFlags(const VkFramebufferCreateFlags * obj,const std::string & str,bool commaNeeded=true)6594 static void print_VkFramebufferCreateFlags(const VkFramebufferCreateFlags *obj, const std::string &str,
6595                                            bool commaNeeded = true)
6596 {
6597     PRINT_SPACE
6598     if (str != "")
6599         _OUT << "\"" << str << "\""
6600              << " : ";
6601     const int max_bits = 64; // We don't expect the number to be larger.
6602     std::bitset<max_bits> b(obj);
6603     _OUT << "\"";
6604     if (obj == 0)
6605         _OUT << "0";
6606     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6607     {
6608         if (b[i] == 1)
6609         {
6610             bitCount++;
6611             if (bitCount < b.count())
6612                 _OUT << VkFramebufferCreateFlagBits_map[1ULL << i] << " | ";
6613             else
6614                 _OUT << VkFramebufferCreateFlagBits_map[1ULL << i];
6615         }
6616     }
6617     if (commaNeeded)
6618         _OUT << "\""
6619              << ",";
6620     else
6621         _OUT << "\""
6622              << "";
6623     _OUT << std::endl;
6624 }
6625 
print_VkRenderPassCreateFlags(VkRenderPassCreateFlags obj,const std::string & str,bool commaNeeded=true)6626 static void print_VkRenderPassCreateFlags(VkRenderPassCreateFlags obj, const std::string &str, bool commaNeeded = true)
6627 {
6628     PRINT_SPACE
6629     if (str != "")
6630         _OUT << "\"" << str << "\""
6631              << " : ";
6632     const int max_bits = 64; // We don't expect the number to be larger.
6633     std::bitset<max_bits> b(obj);
6634     _OUT << "\"";
6635     if (obj == 0)
6636         _OUT << "0";
6637     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6638     {
6639         if (b[i] == 1)
6640         {
6641             bitCount++;
6642             if (bitCount < b.count())
6643                 _OUT << VkRenderPassCreateFlagBits_map[1ULL << i] << " | ";
6644             else
6645                 _OUT << VkRenderPassCreateFlagBits_map[1ULL << i];
6646         }
6647     }
6648     if (commaNeeded)
6649         _OUT << "\""
6650              << ",";
6651     else
6652         _OUT << "\""
6653              << "";
6654     _OUT << std::endl;
6655 }
print_VkRenderPassCreateFlags(const VkRenderPassCreateFlags * obj,const std::string & str,bool commaNeeded=true)6656 static void print_VkRenderPassCreateFlags(const VkRenderPassCreateFlags *obj, const std::string &str,
6657                                           bool commaNeeded = true)
6658 {
6659     PRINT_SPACE
6660     if (str != "")
6661         _OUT << "\"" << str << "\""
6662              << " : ";
6663     const int max_bits = 64; // We don't expect the number to be larger.
6664     std::bitset<max_bits> b(obj);
6665     _OUT << "\"";
6666     if (obj == 0)
6667         _OUT << "0";
6668     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6669     {
6670         if (b[i] == 1)
6671         {
6672             bitCount++;
6673             if (bitCount < b.count())
6674                 _OUT << VkRenderPassCreateFlagBits_map[1ULL << i] << " | ";
6675             else
6676                 _OUT << VkRenderPassCreateFlagBits_map[1ULL << i];
6677         }
6678     }
6679     if (commaNeeded)
6680         _OUT << "\""
6681              << ",";
6682     else
6683         _OUT << "\""
6684              << "";
6685     _OUT << std::endl;
6686 }
6687 
print_VkSubpassDescriptionFlags(VkSubpassDescriptionFlags obj,const std::string & str,bool commaNeeded=true)6688 static void print_VkSubpassDescriptionFlags(VkSubpassDescriptionFlags obj, const std::string &str,
6689                                             bool commaNeeded = true)
6690 {
6691     PRINT_SPACE
6692     if (str != "")
6693         _OUT << "\"" << str << "\""
6694              << " : ";
6695     const int max_bits = 64; // We don't expect the number to be larger.
6696     std::bitset<max_bits> b(obj);
6697     _OUT << "\"";
6698     if (obj == 0)
6699         _OUT << "0";
6700     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6701     {
6702         if (b[i] == 1)
6703         {
6704             bitCount++;
6705             if (bitCount < b.count())
6706                 _OUT << VkSubpassDescriptionFlagBits_map[1ULL << i] << " | ";
6707             else
6708                 _OUT << VkSubpassDescriptionFlagBits_map[1ULL << i];
6709         }
6710     }
6711     if (commaNeeded)
6712         _OUT << "\""
6713              << ",";
6714     else
6715         _OUT << "\""
6716              << "";
6717     _OUT << std::endl;
6718 }
print_VkSubpassDescriptionFlags(const VkSubpassDescriptionFlags * obj,const std::string & str,bool commaNeeded=true)6719 static void print_VkSubpassDescriptionFlags(const VkSubpassDescriptionFlags *obj, const std::string &str,
6720                                             bool commaNeeded = true)
6721 {
6722     PRINT_SPACE
6723     if (str != "")
6724         _OUT << "\"" << str << "\""
6725              << " : ";
6726     const int max_bits = 64; // We don't expect the number to be larger.
6727     std::bitset<max_bits> b(obj);
6728     _OUT << "\"";
6729     if (obj == 0)
6730         _OUT << "0";
6731     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6732     {
6733         if (b[i] == 1)
6734         {
6735             bitCount++;
6736             if (bitCount < b.count())
6737                 _OUT << VkSubpassDescriptionFlagBits_map[1ULL << i] << " | ";
6738             else
6739                 _OUT << VkSubpassDescriptionFlagBits_map[1ULL << i];
6740         }
6741     }
6742     if (commaNeeded)
6743         _OUT << "\""
6744              << ",";
6745     else
6746         _OUT << "\""
6747              << "";
6748     _OUT << std::endl;
6749 }
6750 
print_VkCommandPoolCreateFlags(VkCommandPoolCreateFlags obj,const std::string & str,bool commaNeeded=true)6751 static void print_VkCommandPoolCreateFlags(VkCommandPoolCreateFlags obj, const std::string &str,
6752                                            bool commaNeeded = true)
6753 {
6754     PRINT_SPACE
6755     if (str != "")
6756         _OUT << "\"" << str << "\""
6757              << " : ";
6758     const int max_bits = 64; // We don't expect the number to be larger.
6759     std::bitset<max_bits> b(obj);
6760     _OUT << "\"";
6761     if (obj == 0)
6762         _OUT << "0";
6763     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6764     {
6765         if (b[i] == 1)
6766         {
6767             bitCount++;
6768             if (bitCount < b.count())
6769                 _OUT << VkCommandPoolCreateFlagBits_map[1ULL << i] << " | ";
6770             else
6771                 _OUT << VkCommandPoolCreateFlagBits_map[1ULL << i];
6772         }
6773     }
6774     if (commaNeeded)
6775         _OUT << "\""
6776              << ",";
6777     else
6778         _OUT << "\""
6779              << "";
6780     _OUT << std::endl;
6781 }
print_VkCommandPoolCreateFlags(const VkCommandPoolCreateFlags * obj,const std::string & str,bool commaNeeded=true)6782 static void print_VkCommandPoolCreateFlags(const VkCommandPoolCreateFlags *obj, const std::string &str,
6783                                            bool commaNeeded = true)
6784 {
6785     PRINT_SPACE
6786     if (str != "")
6787         _OUT << "\"" << str << "\""
6788              << " : ";
6789     const int max_bits = 64; // We don't expect the number to be larger.
6790     std::bitset<max_bits> b(obj);
6791     _OUT << "\"";
6792     if (obj == 0)
6793         _OUT << "0";
6794     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6795     {
6796         if (b[i] == 1)
6797         {
6798             bitCount++;
6799             if (bitCount < b.count())
6800                 _OUT << VkCommandPoolCreateFlagBits_map[1ULL << i] << " | ";
6801             else
6802                 _OUT << VkCommandPoolCreateFlagBits_map[1ULL << i];
6803         }
6804     }
6805     if (commaNeeded)
6806         _OUT << "\""
6807              << ",";
6808     else
6809         _OUT << "\""
6810              << "";
6811     _OUT << std::endl;
6812 }
6813 
print_VkCommandPoolResetFlags(VkCommandPoolResetFlags obj,const std::string & str,bool commaNeeded=true)6814 static void print_VkCommandPoolResetFlags(VkCommandPoolResetFlags obj, const std::string &str, bool commaNeeded = true)
6815 {
6816     PRINT_SPACE
6817     if (str != "")
6818         _OUT << "\"" << str << "\""
6819              << " : ";
6820     const int max_bits = 64; // We don't expect the number to be larger.
6821     std::bitset<max_bits> b(obj);
6822     _OUT << "\"";
6823     if (obj == 0)
6824         _OUT << "0";
6825     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6826     {
6827         if (b[i] == 1)
6828         {
6829             bitCount++;
6830             if (bitCount < b.count())
6831                 _OUT << VkCommandPoolResetFlagBits_map[1ULL << i] << " | ";
6832             else
6833                 _OUT << VkCommandPoolResetFlagBits_map[1ULL << i];
6834         }
6835     }
6836     if (commaNeeded)
6837         _OUT << "\""
6838              << ",";
6839     else
6840         _OUT << "\""
6841              << "";
6842     _OUT << std::endl;
6843 }
print_VkCommandPoolResetFlags(const VkCommandPoolResetFlags * obj,const std::string & str,bool commaNeeded=true)6844 static void print_VkCommandPoolResetFlags(const VkCommandPoolResetFlags *obj, const std::string &str,
6845                                           bool commaNeeded = true)
6846 {
6847     PRINT_SPACE
6848     if (str != "")
6849         _OUT << "\"" << str << "\""
6850              << " : ";
6851     const int max_bits = 64; // We don't expect the number to be larger.
6852     std::bitset<max_bits> b(obj);
6853     _OUT << "\"";
6854     if (obj == 0)
6855         _OUT << "0";
6856     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6857     {
6858         if (b[i] == 1)
6859         {
6860             bitCount++;
6861             if (bitCount < b.count())
6862                 _OUT << VkCommandPoolResetFlagBits_map[1ULL << i] << " | ";
6863             else
6864                 _OUT << VkCommandPoolResetFlagBits_map[1ULL << i];
6865         }
6866     }
6867     if (commaNeeded)
6868         _OUT << "\""
6869              << ",";
6870     else
6871         _OUT << "\""
6872              << "";
6873     _OUT << std::endl;
6874 }
6875 
print_VkCommandBufferUsageFlags(VkCommandBufferUsageFlags obj,const std::string & str,bool commaNeeded=true)6876 static void print_VkCommandBufferUsageFlags(VkCommandBufferUsageFlags obj, const std::string &str,
6877                                             bool commaNeeded = true)
6878 {
6879     PRINT_SPACE
6880     if (str != "")
6881         _OUT << "\"" << str << "\""
6882              << " : ";
6883     const int max_bits = 64; // We don't expect the number to be larger.
6884     std::bitset<max_bits> b(obj);
6885     _OUT << "\"";
6886     if (obj == 0)
6887         _OUT << "0";
6888     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6889     {
6890         if (b[i] == 1)
6891         {
6892             bitCount++;
6893             if (bitCount < b.count())
6894                 _OUT << VkCommandBufferUsageFlagBits_map[1ULL << i] << " | ";
6895             else
6896                 _OUT << VkCommandBufferUsageFlagBits_map[1ULL << i];
6897         }
6898     }
6899     if (commaNeeded)
6900         _OUT << "\""
6901              << ",";
6902     else
6903         _OUT << "\""
6904              << "";
6905     _OUT << std::endl;
6906 }
print_VkCommandBufferUsageFlags(const VkCommandBufferUsageFlags * obj,const std::string & str,bool commaNeeded=true)6907 static void print_VkCommandBufferUsageFlags(const VkCommandBufferUsageFlags *obj, const std::string &str,
6908                                             bool commaNeeded = true)
6909 {
6910     PRINT_SPACE
6911     if (str != "")
6912         _OUT << "\"" << str << "\""
6913              << " : ";
6914     const int max_bits = 64; // We don't expect the number to be larger.
6915     std::bitset<max_bits> b(obj);
6916     _OUT << "\"";
6917     if (obj == 0)
6918         _OUT << "0";
6919     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6920     {
6921         if (b[i] == 1)
6922         {
6923             bitCount++;
6924             if (bitCount < b.count())
6925                 _OUT << VkCommandBufferUsageFlagBits_map[1ULL << i] << " | ";
6926             else
6927                 _OUT << VkCommandBufferUsageFlagBits_map[1ULL << i];
6928         }
6929     }
6930     if (commaNeeded)
6931         _OUT << "\""
6932              << ",";
6933     else
6934         _OUT << "\""
6935              << "";
6936     _OUT << std::endl;
6937 }
6938 
print_VkQueryControlFlags(VkQueryControlFlags obj,const std::string & str,bool commaNeeded=true)6939 static void print_VkQueryControlFlags(VkQueryControlFlags obj, const std::string &str, bool commaNeeded = true)
6940 {
6941     PRINT_SPACE
6942     if (str != "")
6943         _OUT << "\"" << str << "\""
6944              << " : ";
6945     const int max_bits = 64; // We don't expect the number to be larger.
6946     std::bitset<max_bits> b(obj);
6947     _OUT << "\"";
6948     if (obj == 0)
6949         _OUT << "0";
6950     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6951     {
6952         if (b[i] == 1)
6953         {
6954             bitCount++;
6955             if (bitCount < b.count())
6956                 _OUT << VkQueryControlFlagBits_map[1ULL << i] << " | ";
6957             else
6958                 _OUT << VkQueryControlFlagBits_map[1ULL << i];
6959         }
6960     }
6961     if (commaNeeded)
6962         _OUT << "\""
6963              << ",";
6964     else
6965         _OUT << "\""
6966              << "";
6967     _OUT << std::endl;
6968 }
print_VkQueryControlFlags(const VkQueryControlFlags * obj,const std::string & str,bool commaNeeded=true)6969 static void print_VkQueryControlFlags(const VkQueryControlFlags *obj, const std::string &str, bool commaNeeded = true)
6970 {
6971     PRINT_SPACE
6972     if (str != "")
6973         _OUT << "\"" << str << "\""
6974              << " : ";
6975     const int max_bits = 64; // We don't expect the number to be larger.
6976     std::bitset<max_bits> b(obj);
6977     _OUT << "\"";
6978     if (obj == 0)
6979         _OUT << "0";
6980     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
6981     {
6982         if (b[i] == 1)
6983         {
6984             bitCount++;
6985             if (bitCount < b.count())
6986                 _OUT << VkQueryControlFlagBits_map[1ULL << i] << " | ";
6987             else
6988                 _OUT << VkQueryControlFlagBits_map[1ULL << i];
6989         }
6990     }
6991     if (commaNeeded)
6992         _OUT << "\""
6993              << ",";
6994     else
6995         _OUT << "\""
6996              << "";
6997     _OUT << std::endl;
6998 }
6999 
print_VkCommandBufferResetFlags(VkCommandBufferResetFlags obj,const std::string & str,bool commaNeeded=true)7000 static void print_VkCommandBufferResetFlags(VkCommandBufferResetFlags obj, const std::string &str,
7001                                             bool commaNeeded = true)
7002 {
7003     PRINT_SPACE
7004     if (str != "")
7005         _OUT << "\"" << str << "\""
7006              << " : ";
7007     const int max_bits = 64; // We don't expect the number to be larger.
7008     std::bitset<max_bits> b(obj);
7009     _OUT << "\"";
7010     if (obj == 0)
7011         _OUT << "0";
7012     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
7013     {
7014         if (b[i] == 1)
7015         {
7016             bitCount++;
7017             if (bitCount < b.count())
7018                 _OUT << VkCommandBufferResetFlagBits_map[1ULL << i] << " | ";
7019             else
7020                 _OUT << VkCommandBufferResetFlagBits_map[1ULL << i];
7021         }
7022     }
7023     if (commaNeeded)
7024         _OUT << "\""
7025              << ",";
7026     else
7027         _OUT << "\""
7028              << "";
7029     _OUT << std::endl;
7030 }
print_VkCommandBufferResetFlags(const VkCommandBufferResetFlags * obj,const std::string & str,bool commaNeeded=true)7031 static void print_VkCommandBufferResetFlags(const VkCommandBufferResetFlags *obj, const std::string &str,
7032                                             bool commaNeeded = true)
7033 {
7034     PRINT_SPACE
7035     if (str != "")
7036         _OUT << "\"" << str << "\""
7037              << " : ";
7038     const int max_bits = 64; // We don't expect the number to be larger.
7039     std::bitset<max_bits> b(obj);
7040     _OUT << "\"";
7041     if (obj == 0)
7042         _OUT << "0";
7043     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
7044     {
7045         if (b[i] == 1)
7046         {
7047             bitCount++;
7048             if (bitCount < b.count())
7049                 _OUT << VkCommandBufferResetFlagBits_map[1ULL << i] << " | ";
7050             else
7051                 _OUT << VkCommandBufferResetFlagBits_map[1ULL << i];
7052         }
7053     }
7054     if (commaNeeded)
7055         _OUT << "\""
7056              << ",";
7057     else
7058         _OUT << "\""
7059              << "";
7060     _OUT << std::endl;
7061 }
7062 
print_VkStencilFaceFlags(VkStencilFaceFlags obj,const std::string & str,bool commaNeeded=true)7063 static void print_VkStencilFaceFlags(VkStencilFaceFlags obj, const std::string &str, bool commaNeeded = true)
7064 {
7065     PRINT_SPACE
7066     if (str != "")
7067         _OUT << "\"" << str << "\""
7068              << " : ";
7069     const int max_bits = 64; // We don't expect the number to be larger.
7070     std::bitset<max_bits> b(obj);
7071     _OUT << "\"";
7072     if (obj == 0)
7073         _OUT << "0";
7074     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
7075     {
7076         if (b[i] == 1)
7077         {
7078             bitCount++;
7079             if (bitCount < b.count())
7080                 _OUT << VkStencilFaceFlagBits_map[1ULL << i] << " | ";
7081             else
7082                 _OUT << VkStencilFaceFlagBits_map[1ULL << i];
7083         }
7084     }
7085     if (commaNeeded)
7086         _OUT << "\""
7087              << ",";
7088     else
7089         _OUT << "\""
7090              << "";
7091     _OUT << std::endl;
7092 }
print_VkStencilFaceFlags(const VkStencilFaceFlags * obj,const std::string & str,bool commaNeeded=true)7093 static void print_VkStencilFaceFlags(const VkStencilFaceFlags *obj, const std::string &str, bool commaNeeded = true)
7094 {
7095     PRINT_SPACE
7096     if (str != "")
7097         _OUT << "\"" << str << "\""
7098              << " : ";
7099     const int max_bits = 64; // We don't expect the number to be larger.
7100     std::bitset<max_bits> b(obj);
7101     _OUT << "\"";
7102     if (obj == 0)
7103         _OUT << "0";
7104     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
7105     {
7106         if (b[i] == 1)
7107         {
7108             bitCount++;
7109             if (bitCount < b.count())
7110                 _OUT << VkStencilFaceFlagBits_map[1ULL << i] << " | ";
7111             else
7112                 _OUT << VkStencilFaceFlagBits_map[1ULL << i];
7113         }
7114     }
7115     if (commaNeeded)
7116         _OUT << "\""
7117              << ",";
7118     else
7119         _OUT << "\""
7120              << "";
7121     _OUT << std::endl;
7122 }
7123 
print_VkExtent2D(VkExtent2D obj,const std::string & s,bool commaNeeded=true)7124 static void print_VkExtent2D(VkExtent2D obj, const std::string &s, bool commaNeeded = true)
7125 {
7126     PRINT_SPACE
7127     _OUT << "{" << std::endl;
7128     INDENT(4);
7129 
7130     print_uint32_t(obj.width, "width", 1);
7131 
7132     print_uint32_t(obj.height, "height", 0);
7133 
7134     INDENT(-4);
7135     PRINT_SPACE
7136     if (commaNeeded)
7137         _OUT << "}," << std::endl;
7138     else
7139         _OUT << "}" << std::endl;
7140 }
print_VkExtent2D(const VkExtent2D * obj,const std::string & s,bool commaNeeded=true)7141 static void print_VkExtent2D(const VkExtent2D *obj, const std::string &s, bool commaNeeded = true)
7142 {
7143     PRINT_SPACE
7144     _OUT << "{" << std::endl;
7145     INDENT(4);
7146 
7147     print_uint32_t(obj->width, "width", 1);
7148 
7149     print_uint32_t(obj->height, "height", 0);
7150 
7151     INDENT(-4);
7152     PRINT_SPACE
7153     if (commaNeeded)
7154         _OUT << "}," << std::endl;
7155     else
7156         _OUT << "}" << std::endl;
7157 }
7158 
print_VkExtent3D(VkExtent3D obj,const std::string & s,bool commaNeeded=true)7159 static void print_VkExtent3D(VkExtent3D obj, const std::string &s, bool commaNeeded = true)
7160 {
7161     PRINT_SPACE
7162     _OUT << "{" << std::endl;
7163     INDENT(4);
7164 
7165     print_uint32_t(obj.width, "width", 1);
7166 
7167     print_uint32_t(obj.height, "height", 1);
7168 
7169     print_uint32_t(obj.depth, "depth", 0);
7170 
7171     INDENT(-4);
7172     PRINT_SPACE
7173     if (commaNeeded)
7174         _OUT << "}," << std::endl;
7175     else
7176         _OUT << "}" << std::endl;
7177 }
print_VkExtent3D(const VkExtent3D * obj,const std::string & s,bool commaNeeded=true)7178 static void print_VkExtent3D(const VkExtent3D *obj, const std::string &s, bool commaNeeded = true)
7179 {
7180     PRINT_SPACE
7181     _OUT << "{" << std::endl;
7182     INDENT(4);
7183 
7184     print_uint32_t(obj->width, "width", 1);
7185 
7186     print_uint32_t(obj->height, "height", 1);
7187 
7188     print_uint32_t(obj->depth, "depth", 0);
7189 
7190     INDENT(-4);
7191     PRINT_SPACE
7192     if (commaNeeded)
7193         _OUT << "}," << std::endl;
7194     else
7195         _OUT << "}" << std::endl;
7196 }
7197 
print_VkOffset2D(VkOffset2D obj,const std::string & s,bool commaNeeded=true)7198 static void print_VkOffset2D(VkOffset2D obj, const std::string &s, bool commaNeeded = true)
7199 {
7200     PRINT_SPACE
7201     _OUT << "{" << std::endl;
7202     INDENT(4);
7203 
7204     print_int32_t(obj.x, "x", 1);
7205 
7206     print_int32_t(obj.y, "y", 0);
7207 
7208     INDENT(-4);
7209     PRINT_SPACE
7210     if (commaNeeded)
7211         _OUT << "}," << std::endl;
7212     else
7213         _OUT << "}" << std::endl;
7214 }
print_VkOffset2D(const VkOffset2D * obj,const std::string & s,bool commaNeeded=true)7215 static void print_VkOffset2D(const VkOffset2D *obj, const std::string &s, bool commaNeeded = true)
7216 {
7217     PRINT_SPACE
7218     _OUT << "{" << std::endl;
7219     INDENT(4);
7220 
7221     print_int32_t(obj->x, "x", 1);
7222 
7223     print_int32_t(obj->y, "y", 0);
7224 
7225     INDENT(-4);
7226     PRINT_SPACE
7227     if (commaNeeded)
7228         _OUT << "}," << std::endl;
7229     else
7230         _OUT << "}" << std::endl;
7231 }
7232 
print_VkOffset3D(VkOffset3D obj,const std::string & s,bool commaNeeded=true)7233 static void print_VkOffset3D(VkOffset3D obj, const std::string &s, bool commaNeeded = true)
7234 {
7235     PRINT_SPACE
7236     _OUT << "{" << std::endl;
7237     INDENT(4);
7238 
7239     print_int32_t(obj.x, "x", 1);
7240 
7241     print_int32_t(obj.y, "y", 1);
7242 
7243     print_int32_t(obj.z, "z", 0);
7244 
7245     INDENT(-4);
7246     PRINT_SPACE
7247     if (commaNeeded)
7248         _OUT << "}," << std::endl;
7249     else
7250         _OUT << "}" << std::endl;
7251 }
print_VkOffset3D(const VkOffset3D * obj,const std::string & s,bool commaNeeded=true)7252 static void print_VkOffset3D(const VkOffset3D *obj, const std::string &s, bool commaNeeded = true)
7253 {
7254     PRINT_SPACE
7255     _OUT << "{" << std::endl;
7256     INDENT(4);
7257 
7258     print_int32_t(obj->x, "x", 1);
7259 
7260     print_int32_t(obj->y, "y", 1);
7261 
7262     print_int32_t(obj->z, "z", 0);
7263 
7264     INDENT(-4);
7265     PRINT_SPACE
7266     if (commaNeeded)
7267         _OUT << "}," << std::endl;
7268     else
7269         _OUT << "}" << std::endl;
7270 }
7271 
print_VkRect2D(VkRect2D obj,const std::string & s,bool commaNeeded=true)7272 static void print_VkRect2D(VkRect2D obj, const std::string &s, bool commaNeeded = true)
7273 {
7274     PRINT_SPACE
7275     _OUT << "{" << std::endl;
7276     INDENT(4);
7277 
7278     PRINT_SPACE
7279     _OUT << "\"offset\": " << std::endl;
7280     {
7281         print_VkOffset2D(obj.offset, "offset", 1);
7282     }
7283 
7284     PRINT_SPACE
7285     _OUT << "\"extent\": " << std::endl;
7286     {
7287         print_VkExtent2D(obj.extent, "extent", 0);
7288     }
7289 
7290     INDENT(-4);
7291     PRINT_SPACE
7292     if (commaNeeded)
7293         _OUT << "}," << std::endl;
7294     else
7295         _OUT << "}" << std::endl;
7296 }
print_VkRect2D(const VkRect2D * obj,const std::string & s,bool commaNeeded=true)7297 static void print_VkRect2D(const VkRect2D *obj, const std::string &s, bool commaNeeded = true)
7298 {
7299     PRINT_SPACE
7300     _OUT << "{" << std::endl;
7301     INDENT(4);
7302 
7303     PRINT_SPACE
7304     _OUT << "\"offset\": " << std::endl;
7305     {
7306         print_VkOffset2D(obj->offset, "offset", 1);
7307     }
7308 
7309     PRINT_SPACE
7310     _OUT << "\"extent\": " << std::endl;
7311     {
7312         print_VkExtent2D(obj->extent, "extent", 0);
7313     }
7314 
7315     INDENT(-4);
7316     PRINT_SPACE
7317     if (commaNeeded)
7318         _OUT << "}," << std::endl;
7319     else
7320         _OUT << "}" << std::endl;
7321 }
7322 
print_VkBaseInStructure(VkBaseInStructure obj,const std::string & s,bool commaNeeded=true)7323 static void print_VkBaseInStructure(VkBaseInStructure obj, const std::string &s, bool commaNeeded = true)
7324 {
7325     PRINT_SPACE
7326     _OUT << "{" << std::endl;
7327     INDENT(4);
7328 
7329     print_VkStructureType(obj.sType, "sType", 1);
7330 
7331     if (obj.pNext)
7332     {
7333         dumpPNextChain(obj.pNext);
7334     }
7335     else
7336     {
7337         PRINT_SPACE
7338         _OUT << "\"pNext\":"
7339              << "\"NULL\""
7340              << "," << std::endl;
7341     }
7342 
7343     INDENT(-4);
7344     PRINT_SPACE
7345     if (commaNeeded)
7346         _OUT << "}," << std::endl;
7347     else
7348         _OUT << "}" << std::endl;
7349 }
print_VkBaseInStructure(const VkBaseInStructure * obj,const std::string & s,bool commaNeeded=true)7350 static void print_VkBaseInStructure(const VkBaseInStructure *obj, const std::string &s, bool commaNeeded = true)
7351 {
7352     PRINT_SPACE
7353     _OUT << "{" << std::endl;
7354     INDENT(4);
7355 
7356     print_VkStructureType(obj->sType, "sType", 1);
7357 
7358     if (obj->pNext)
7359     {
7360         dumpPNextChain(obj->pNext);
7361     }
7362     else
7363     {
7364         PRINT_SPACE
7365         _OUT << "\"pNext\":"
7366              << "\"NULL\""
7367              << "," << std::endl;
7368     }
7369 
7370     INDENT(-4);
7371     PRINT_SPACE
7372     if (commaNeeded)
7373         _OUT << "}," << std::endl;
7374     else
7375         _OUT << "}" << std::endl;
7376 }
7377 
print_VkBaseOutStructure(VkBaseOutStructure obj,const std::string & s,bool commaNeeded=true)7378 static void print_VkBaseOutStructure(VkBaseOutStructure obj, const std::string &s, bool commaNeeded = true)
7379 {
7380     PRINT_SPACE
7381     _OUT << "{" << std::endl;
7382     INDENT(4);
7383 
7384     print_VkStructureType(obj.sType, "sType", 1);
7385 
7386     if (obj.pNext)
7387     {
7388         dumpPNextChain(obj.pNext);
7389     }
7390     else
7391     {
7392         PRINT_SPACE
7393         _OUT << "\"pNext\":"
7394              << "\"NULL\""
7395              << "," << std::endl;
7396     }
7397 
7398     INDENT(-4);
7399     PRINT_SPACE
7400     if (commaNeeded)
7401         _OUT << "}," << std::endl;
7402     else
7403         _OUT << "}" << std::endl;
7404 }
print_VkBaseOutStructure(const VkBaseOutStructure * obj,const std::string & s,bool commaNeeded=true)7405 static void print_VkBaseOutStructure(const VkBaseOutStructure *obj, const std::string &s, bool commaNeeded = true)
7406 {
7407     PRINT_SPACE
7408     _OUT << "{" << std::endl;
7409     INDENT(4);
7410 
7411     print_VkStructureType(obj->sType, "sType", 1);
7412 
7413     if (obj->pNext)
7414     {
7415         dumpPNextChain(obj->pNext);
7416     }
7417     else
7418     {
7419         PRINT_SPACE
7420         _OUT << "\"pNext\":"
7421              << "\"NULL\""
7422              << "," << std::endl;
7423     }
7424 
7425     INDENT(-4);
7426     PRINT_SPACE
7427     if (commaNeeded)
7428         _OUT << "}," << std::endl;
7429     else
7430         _OUT << "}" << std::endl;
7431 }
7432 
print_VkBufferMemoryBarrier(VkBufferMemoryBarrier obj,const std::string & s,bool commaNeeded=true)7433 static void print_VkBufferMemoryBarrier(VkBufferMemoryBarrier obj, const std::string &s, bool commaNeeded = true)
7434 {
7435     PRINT_SPACE
7436     _OUT << "{" << std::endl;
7437     INDENT(4);
7438 
7439     print_VkStructureType(obj.sType, "sType", 1);
7440 
7441     if (obj.pNext)
7442     {
7443         dumpPNextChain(obj.pNext);
7444     }
7445     else
7446     {
7447         PRINT_SPACE
7448         _OUT << "\"pNext\":"
7449              << "\"NULL\""
7450              << "," << std::endl;
7451     }
7452 
7453     print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1);
7454 
7455     print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 1);
7456 
7457     print_uint32_t(obj.srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
7458 
7459     print_uint32_t(obj.dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
7460 
7461     // CTS : required value
7462     PRINT_SPACE _OUT << "\""
7463                      << "buffer"
7464                      << "\""
7465                      << " : "
7466                      << "\""
7467                      << "\"," << std::endl;
7468 
7469     print_VkDeviceSize(obj.offset, "offset", 1);
7470 
7471     print_VkDeviceSize(obj.size, "size", 0);
7472 
7473     INDENT(-4);
7474     PRINT_SPACE
7475     if (commaNeeded)
7476         _OUT << "}," << std::endl;
7477     else
7478         _OUT << "}" << std::endl;
7479 }
print_VkBufferMemoryBarrier(const VkBufferMemoryBarrier * obj,const std::string & s,bool commaNeeded=true)7480 static void print_VkBufferMemoryBarrier(const VkBufferMemoryBarrier *obj, const std::string &s, bool commaNeeded = true)
7481 {
7482     PRINT_SPACE
7483     _OUT << "{" << std::endl;
7484     INDENT(4);
7485 
7486     print_VkStructureType(obj->sType, "sType", 1);
7487 
7488     if (obj->pNext)
7489     {
7490         dumpPNextChain(obj->pNext);
7491     }
7492     else
7493     {
7494         PRINT_SPACE
7495         _OUT << "\"pNext\":"
7496              << "\"NULL\""
7497              << "," << std::endl;
7498     }
7499 
7500     print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1);
7501 
7502     print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 1);
7503 
7504     print_uint32_t(obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
7505 
7506     print_uint32_t(obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
7507 
7508     // CTS : required value
7509     PRINT_SPACE _OUT << "\""
7510                      << "buffer"
7511                      << "\""
7512                      << " : "
7513                      << "\""
7514                      << "\"," << std::endl;
7515 
7516     print_VkDeviceSize(obj->offset, "offset", 1);
7517 
7518     print_VkDeviceSize(obj->size, "size", 0);
7519 
7520     INDENT(-4);
7521     PRINT_SPACE
7522     if (commaNeeded)
7523         _OUT << "}," << std::endl;
7524     else
7525         _OUT << "}" << std::endl;
7526 }
7527 
print_VkDispatchIndirectCommand(VkDispatchIndirectCommand obj,const std::string & s,bool commaNeeded=true)7528 static void print_VkDispatchIndirectCommand(VkDispatchIndirectCommand obj, const std::string &s,
7529                                             bool commaNeeded = true)
7530 {
7531     PRINT_SPACE
7532     _OUT << "{" << std::endl;
7533     INDENT(4);
7534 
7535     print_uint32_t(obj.x, "x", 1);
7536 
7537     print_uint32_t(obj.y, "y", 1);
7538 
7539     print_uint32_t(obj.z, "z", 0);
7540 
7541     INDENT(-4);
7542     PRINT_SPACE
7543     if (commaNeeded)
7544         _OUT << "}," << std::endl;
7545     else
7546         _OUT << "}" << std::endl;
7547 }
print_VkDispatchIndirectCommand(const VkDispatchIndirectCommand * obj,const std::string & s,bool commaNeeded=true)7548 static void print_VkDispatchIndirectCommand(const VkDispatchIndirectCommand *obj, const std::string &s,
7549                                             bool commaNeeded = true)
7550 {
7551     PRINT_SPACE
7552     _OUT << "{" << std::endl;
7553     INDENT(4);
7554 
7555     print_uint32_t(obj->x, "x", 1);
7556 
7557     print_uint32_t(obj->y, "y", 1);
7558 
7559     print_uint32_t(obj->z, "z", 0);
7560 
7561     INDENT(-4);
7562     PRINT_SPACE
7563     if (commaNeeded)
7564         _OUT << "}," << std::endl;
7565     else
7566         _OUT << "}" << std::endl;
7567 }
7568 
print_VkDrawIndexedIndirectCommand(VkDrawIndexedIndirectCommand obj,const std::string & s,bool commaNeeded=true)7569 static void print_VkDrawIndexedIndirectCommand(VkDrawIndexedIndirectCommand obj, const std::string &s,
7570                                                bool commaNeeded = true)
7571 {
7572     PRINT_SPACE
7573     _OUT << "{" << std::endl;
7574     INDENT(4);
7575 
7576     print_uint32_t(obj.indexCount, "indexCount", 1);
7577 
7578     print_uint32_t(obj.instanceCount, "instanceCount", 1);
7579 
7580     print_uint32_t(obj.firstIndex, "firstIndex", 1);
7581 
7582     print_int32_t(obj.vertexOffset, "vertexOffset", 1);
7583 
7584     print_uint32_t(obj.firstInstance, "firstInstance", 0);
7585 
7586     INDENT(-4);
7587     PRINT_SPACE
7588     if (commaNeeded)
7589         _OUT << "}," << std::endl;
7590     else
7591         _OUT << "}" << std::endl;
7592 }
print_VkDrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand * obj,const std::string & s,bool commaNeeded=true)7593 static void print_VkDrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand *obj, const std::string &s,
7594                                                bool commaNeeded = true)
7595 {
7596     PRINT_SPACE
7597     _OUT << "{" << std::endl;
7598     INDENT(4);
7599 
7600     print_uint32_t(obj->indexCount, "indexCount", 1);
7601 
7602     print_uint32_t(obj->instanceCount, "instanceCount", 1);
7603 
7604     print_uint32_t(obj->firstIndex, "firstIndex", 1);
7605 
7606     print_int32_t(obj->vertexOffset, "vertexOffset", 1);
7607 
7608     print_uint32_t(obj->firstInstance, "firstInstance", 0);
7609 
7610     INDENT(-4);
7611     PRINT_SPACE
7612     if (commaNeeded)
7613         _OUT << "}," << std::endl;
7614     else
7615         _OUT << "}" << std::endl;
7616 }
7617 
print_VkDrawIndirectCommand(VkDrawIndirectCommand obj,const std::string & s,bool commaNeeded=true)7618 static void print_VkDrawIndirectCommand(VkDrawIndirectCommand obj, const std::string &s, bool commaNeeded = true)
7619 {
7620     PRINT_SPACE
7621     _OUT << "{" << std::endl;
7622     INDENT(4);
7623 
7624     print_uint32_t(obj.vertexCount, "vertexCount", 1);
7625 
7626     print_uint32_t(obj.instanceCount, "instanceCount", 1);
7627 
7628     print_uint32_t(obj.firstVertex, "firstVertex", 1);
7629 
7630     print_uint32_t(obj.firstInstance, "firstInstance", 0);
7631 
7632     INDENT(-4);
7633     PRINT_SPACE
7634     if (commaNeeded)
7635         _OUT << "}," << std::endl;
7636     else
7637         _OUT << "}" << std::endl;
7638 }
print_VkDrawIndirectCommand(const VkDrawIndirectCommand * obj,const std::string & s,bool commaNeeded=true)7639 static void print_VkDrawIndirectCommand(const VkDrawIndirectCommand *obj, const std::string &s, bool commaNeeded = true)
7640 {
7641     PRINT_SPACE
7642     _OUT << "{" << std::endl;
7643     INDENT(4);
7644 
7645     print_uint32_t(obj->vertexCount, "vertexCount", 1);
7646 
7647     print_uint32_t(obj->instanceCount, "instanceCount", 1);
7648 
7649     print_uint32_t(obj->firstVertex, "firstVertex", 1);
7650 
7651     print_uint32_t(obj->firstInstance, "firstInstance", 0);
7652 
7653     INDENT(-4);
7654     PRINT_SPACE
7655     if (commaNeeded)
7656         _OUT << "}," << std::endl;
7657     else
7658         _OUT << "}" << std::endl;
7659 }
7660 
print_VkImageSubresourceRange(VkImageSubresourceRange obj,const std::string & s,bool commaNeeded=true)7661 static void print_VkImageSubresourceRange(VkImageSubresourceRange obj, const std::string &s, bool commaNeeded = true)
7662 {
7663     PRINT_SPACE
7664     _OUT << "{" << std::endl;
7665     INDENT(4);
7666 
7667     print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 1);
7668 
7669     print_uint32_t(obj.baseMipLevel, "baseMipLevel", 1);
7670 
7671     print_uint32_t(obj.levelCount, "levelCount", 1);
7672 
7673     print_uint32_t(obj.baseArrayLayer, "baseArrayLayer", 1);
7674 
7675     print_uint32_t(obj.layerCount, "layerCount", 0);
7676 
7677     INDENT(-4);
7678     PRINT_SPACE
7679     if (commaNeeded)
7680         _OUT << "}," << std::endl;
7681     else
7682         _OUT << "}" << std::endl;
7683 }
print_VkImageSubresourceRange(const VkImageSubresourceRange * obj,const std::string & s,bool commaNeeded=true)7684 static void print_VkImageSubresourceRange(const VkImageSubresourceRange *obj, const std::string &s,
7685                                           bool commaNeeded = true)
7686 {
7687     PRINT_SPACE
7688     _OUT << "{" << std::endl;
7689     INDENT(4);
7690 
7691     print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 1);
7692 
7693     print_uint32_t(obj->baseMipLevel, "baseMipLevel", 1);
7694 
7695     print_uint32_t(obj->levelCount, "levelCount", 1);
7696 
7697     print_uint32_t(obj->baseArrayLayer, "baseArrayLayer", 1);
7698 
7699     print_uint32_t(obj->layerCount, "layerCount", 0);
7700 
7701     INDENT(-4);
7702     PRINT_SPACE
7703     if (commaNeeded)
7704         _OUT << "}," << std::endl;
7705     else
7706         _OUT << "}" << std::endl;
7707 }
7708 
print_VkImageMemoryBarrier(VkImageMemoryBarrier obj,const std::string & s,bool commaNeeded=true)7709 static void print_VkImageMemoryBarrier(VkImageMemoryBarrier obj, const std::string &s, bool commaNeeded = true)
7710 {
7711     PRINT_SPACE
7712     _OUT << "{" << std::endl;
7713     INDENT(4);
7714 
7715     print_VkStructureType(obj.sType, "sType", 1);
7716 
7717     if (obj.pNext)
7718     {
7719         dumpPNextChain(obj.pNext);
7720     }
7721     else
7722     {
7723         PRINT_SPACE
7724         _OUT << "\"pNext\":"
7725              << "\"NULL\""
7726              << "," << std::endl;
7727     }
7728 
7729     print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1);
7730 
7731     print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 1);
7732 
7733     print_VkImageLayout(obj.oldLayout, "oldLayout", 1);
7734 
7735     print_VkImageLayout(obj.newLayout, "newLayout", 1);
7736 
7737     print_uint32_t(obj.srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
7738 
7739     print_uint32_t(obj.dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
7740 
7741     // CTS : required value
7742     PRINT_SPACE _OUT << "\""
7743                      << "image"
7744                      << "\""
7745                      << " : "
7746                      << "\""
7747                      << "\"," << std::endl;
7748 
7749     PRINT_SPACE
7750     _OUT << "\"subresourceRange\": " << std::endl;
7751     {
7752         print_VkImageSubresourceRange(obj.subresourceRange, "subresourceRange", 0);
7753     }
7754 
7755     INDENT(-4);
7756     PRINT_SPACE
7757     if (commaNeeded)
7758         _OUT << "}," << std::endl;
7759     else
7760         _OUT << "}" << std::endl;
7761 }
print_VkImageMemoryBarrier(const VkImageMemoryBarrier * obj,const std::string & s,bool commaNeeded=true)7762 static void print_VkImageMemoryBarrier(const VkImageMemoryBarrier *obj, const std::string &s, bool commaNeeded = true)
7763 {
7764     PRINT_SPACE
7765     _OUT << "{" << std::endl;
7766     INDENT(4);
7767 
7768     print_VkStructureType(obj->sType, "sType", 1);
7769 
7770     if (obj->pNext)
7771     {
7772         dumpPNextChain(obj->pNext);
7773     }
7774     else
7775     {
7776         PRINT_SPACE
7777         _OUT << "\"pNext\":"
7778              << "\"NULL\""
7779              << "," << std::endl;
7780     }
7781 
7782     print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1);
7783 
7784     print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 1);
7785 
7786     print_VkImageLayout(obj->oldLayout, "oldLayout", 1);
7787 
7788     print_VkImageLayout(obj->newLayout, "newLayout", 1);
7789 
7790     print_uint32_t(obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
7791 
7792     print_uint32_t(obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
7793 
7794     // CTS : required value
7795     PRINT_SPACE _OUT << "\""
7796                      << "image"
7797                      << "\""
7798                      << " : "
7799                      << "\""
7800                      << "\"," << std::endl;
7801 
7802     PRINT_SPACE
7803     _OUT << "\"subresourceRange\": " << std::endl;
7804     {
7805         print_VkImageSubresourceRange(obj->subresourceRange, "subresourceRange", 0);
7806     }
7807 
7808     INDENT(-4);
7809     PRINT_SPACE
7810     if (commaNeeded)
7811         _OUT << "}," << std::endl;
7812     else
7813         _OUT << "}" << std::endl;
7814 }
7815 
print_VkMemoryBarrier(VkMemoryBarrier obj,const std::string & s,bool commaNeeded=true)7816 static void print_VkMemoryBarrier(VkMemoryBarrier obj, const std::string &s, bool commaNeeded = true)
7817 {
7818     PRINT_SPACE
7819     _OUT << "{" << std::endl;
7820     INDENT(4);
7821 
7822     print_VkStructureType(obj.sType, "sType", 1);
7823 
7824     if (obj.pNext)
7825     {
7826         dumpPNextChain(obj.pNext);
7827     }
7828     else
7829     {
7830         PRINT_SPACE
7831         _OUT << "\"pNext\":"
7832              << "\"NULL\""
7833              << "," << std::endl;
7834     }
7835 
7836     print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1);
7837 
7838     print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 0);
7839 
7840     INDENT(-4);
7841     PRINT_SPACE
7842     if (commaNeeded)
7843         _OUT << "}," << std::endl;
7844     else
7845         _OUT << "}" << std::endl;
7846 }
print_VkMemoryBarrier(const VkMemoryBarrier * obj,const std::string & s,bool commaNeeded=true)7847 static void print_VkMemoryBarrier(const VkMemoryBarrier *obj, const std::string &s, bool commaNeeded = true)
7848 {
7849     PRINT_SPACE
7850     _OUT << "{" << std::endl;
7851     INDENT(4);
7852 
7853     print_VkStructureType(obj->sType, "sType", 1);
7854 
7855     if (obj->pNext)
7856     {
7857         dumpPNextChain(obj->pNext);
7858     }
7859     else
7860     {
7861         PRINT_SPACE
7862         _OUT << "\"pNext\":"
7863              << "\"NULL\""
7864              << "," << std::endl;
7865     }
7866 
7867     print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1);
7868 
7869     print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 0);
7870 
7871     INDENT(-4);
7872     PRINT_SPACE
7873     if (commaNeeded)
7874         _OUT << "}," << std::endl;
7875     else
7876         _OUT << "}" << std::endl;
7877 }
7878 
print_VkPipelineCacheHeaderVersionOne(VkPipelineCacheHeaderVersionOne obj,const std::string & s,bool commaNeeded=true)7879 static void print_VkPipelineCacheHeaderVersionOne(VkPipelineCacheHeaderVersionOne obj, const std::string &s,
7880                                                   bool commaNeeded = true)
7881 {
7882     PRINT_SPACE
7883     _OUT << "{" << std::endl;
7884     INDENT(4);
7885 
7886     print_uint32_t(obj.headerSize, "headerSize", 1);
7887 
7888     print_VkPipelineCacheHeaderVersion(obj.headerVersion, "headerVersion", 1);
7889 
7890     print_uint32_t(obj.vendorID, "vendorID", 1);
7891 
7892     print_uint32_t(obj.deviceID, "deviceID", 1);
7893 
7894     PRINT_SPACE
7895     _OUT << "\"pipelineCacheUUID\":" << std::endl;
7896     PRINT_SPACE
7897     _OUT << "[" << std::endl;
7898     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
7899     {
7900         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
7901         print_uint8_t(obj.pipelineCacheUUID[i], "", isCommaNeeded);
7902     }
7903     PRINT_SPACE
7904     _OUT << "]"
7905          << "" << std::endl;
7906 
7907     INDENT(-4);
7908     PRINT_SPACE
7909     if (commaNeeded)
7910         _OUT << "}," << std::endl;
7911     else
7912         _OUT << "}" << std::endl;
7913 }
print_VkPipelineCacheHeaderVersionOne(const VkPipelineCacheHeaderVersionOne * obj,const std::string & s,bool commaNeeded=true)7914 static void print_VkPipelineCacheHeaderVersionOne(const VkPipelineCacheHeaderVersionOne *obj, const std::string &s,
7915                                                   bool commaNeeded = true)
7916 {
7917     PRINT_SPACE
7918     _OUT << "{" << std::endl;
7919     INDENT(4);
7920 
7921     print_uint32_t(obj->headerSize, "headerSize", 1);
7922 
7923     print_VkPipelineCacheHeaderVersion(obj->headerVersion, "headerVersion", 1);
7924 
7925     print_uint32_t(obj->vendorID, "vendorID", 1);
7926 
7927     print_uint32_t(obj->deviceID, "deviceID", 1);
7928 
7929     PRINT_SPACE
7930     _OUT << "\"pipelineCacheUUID\":" << std::endl;
7931     PRINT_SPACE
7932     _OUT << "[" << std::endl;
7933     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
7934     {
7935         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
7936         print_uint8_t(obj->pipelineCacheUUID[i], "", isCommaNeeded);
7937     }
7938     PRINT_SPACE
7939     _OUT << "]"
7940          << "" << std::endl;
7941 
7942     INDENT(-4);
7943     PRINT_SPACE
7944     if (commaNeeded)
7945         _OUT << "}," << std::endl;
7946     else
7947         _OUT << "}" << std::endl;
7948 }
7949 
print_VkAllocationCallbacks(VkAllocationCallbacks obj,const std::string & s,bool commaNeeded=true)7950 static void print_VkAllocationCallbacks(VkAllocationCallbacks obj, const std::string &s, bool commaNeeded = true)
7951 {
7952     PRINT_SPACE
7953     _OUT << "{" << std::endl;
7954     INDENT(4);
7955 
7956     /** Note: Ignoring void* data. **/
7957 
7958     /** Note: Ignoring function pointer (PFN_vkAllocationFunction). **/
7959 
7960     /** Note: Ignoring function pointer (PFN_vkReallocationFunction). **/
7961 
7962     /** Note: Ignoring function pointer (PFN_vkFreeFunction). **/
7963 
7964     /** Note: Ignoring function pointer (PFN_vkInternalAllocationNotification). **/
7965 
7966     /** Note: Ignoring function pointer (PFN_vkInternalFreeNotification). **/
7967 
7968     INDENT(-4);
7969     PRINT_SPACE
7970     if (commaNeeded)
7971         _OUT << "}," << std::endl;
7972     else
7973         _OUT << "}" << std::endl;
7974 }
print_VkAllocationCallbacks(const VkAllocationCallbacks * obj,const std::string & s,bool commaNeeded=true)7975 static void print_VkAllocationCallbacks(const VkAllocationCallbacks *obj, const std::string &s, bool commaNeeded = true)
7976 {
7977     PRINT_SPACE
7978     _OUT << "{" << std::endl;
7979     INDENT(4);
7980 
7981     /** Note: Ignoring void* data. **/
7982 
7983     /** Note: Ignoring function pointer (PFN_vkAllocationFunction). **/
7984 
7985     /** Note: Ignoring function pointer (PFN_vkReallocationFunction). **/
7986 
7987     /** Note: Ignoring function pointer (PFN_vkFreeFunction). **/
7988 
7989     /** Note: Ignoring function pointer (PFN_vkInternalAllocationNotification). **/
7990 
7991     /** Note: Ignoring function pointer (PFN_vkInternalFreeNotification). **/
7992 
7993     INDENT(-4);
7994     PRINT_SPACE
7995     if (commaNeeded)
7996         _OUT << "}," << std::endl;
7997     else
7998         _OUT << "}" << std::endl;
7999 }
8000 
print_VkApplicationInfo(VkApplicationInfo obj,const std::string & s,bool commaNeeded=true)8001 static void print_VkApplicationInfo(VkApplicationInfo obj, const std::string &s, bool commaNeeded = true)
8002 {
8003     PRINT_SPACE
8004     _OUT << "{" << std::endl;
8005     INDENT(4);
8006 
8007     print_VkStructureType(obj.sType, "sType", 1);
8008 
8009     if (obj.pNext)
8010     {
8011         dumpPNextChain(obj.pNext);
8012     }
8013     else
8014     {
8015         PRINT_SPACE
8016         _OUT << "\"pNext\":"
8017              << "\"NULL\""
8018              << "," << std::endl;
8019     }
8020 
8021     print_char(obj.pApplicationName, "pApplicationName", 1);
8022 
8023     print_uint32_t(obj.applicationVersion, "applicationVersion", 1);
8024 
8025     print_char(obj.pEngineName, "pEngineName", 1);
8026 
8027     print_uint32_t(obj.engineVersion, "engineVersion", 1);
8028 
8029     print_uint32_t(obj.apiVersion, "apiVersion", 0);
8030 
8031     INDENT(-4);
8032     PRINT_SPACE
8033     if (commaNeeded)
8034         _OUT << "}," << std::endl;
8035     else
8036         _OUT << "}" << std::endl;
8037 }
print_VkApplicationInfo(const VkApplicationInfo * obj,const std::string & s,bool commaNeeded=true)8038 static void print_VkApplicationInfo(const VkApplicationInfo *obj, const std::string &s, bool commaNeeded = true)
8039 {
8040     PRINT_SPACE
8041     _OUT << "{" << std::endl;
8042     INDENT(4);
8043 
8044     print_VkStructureType(obj->sType, "sType", 1);
8045 
8046     if (obj->pNext)
8047     {
8048         dumpPNextChain(obj->pNext);
8049     }
8050     else
8051     {
8052         PRINT_SPACE
8053         _OUT << "\"pNext\":"
8054              << "\"NULL\""
8055              << "," << std::endl;
8056     }
8057 
8058     print_char(obj->pApplicationName, "pApplicationName", 1);
8059 
8060     print_uint32_t(obj->applicationVersion, "applicationVersion", 1);
8061 
8062     print_char(obj->pEngineName, "pEngineName", 1);
8063 
8064     print_uint32_t(obj->engineVersion, "engineVersion", 1);
8065 
8066     print_uint32_t(obj->apiVersion, "apiVersion", 0);
8067 
8068     INDENT(-4);
8069     PRINT_SPACE
8070     if (commaNeeded)
8071         _OUT << "}," << std::endl;
8072     else
8073         _OUT << "}" << std::endl;
8074 }
8075 
print_VkFormatProperties(VkFormatProperties obj,const std::string & s,bool commaNeeded=true)8076 static void print_VkFormatProperties(VkFormatProperties obj, const std::string &s, bool commaNeeded = true)
8077 {
8078     PRINT_SPACE
8079     _OUT << "{" << std::endl;
8080     INDENT(4);
8081 
8082     print_VkFormatFeatureFlags(obj.linearTilingFeatures, "linearTilingFeatures", 1);
8083 
8084     print_VkFormatFeatureFlags(obj.optimalTilingFeatures, "optimalTilingFeatures", 1);
8085 
8086     print_VkFormatFeatureFlags(obj.bufferFeatures, "bufferFeatures", 0);
8087 
8088     INDENT(-4);
8089     PRINT_SPACE
8090     if (commaNeeded)
8091         _OUT << "}," << std::endl;
8092     else
8093         _OUT << "}" << std::endl;
8094 }
print_VkFormatProperties(const VkFormatProperties * obj,const std::string & s,bool commaNeeded=true)8095 static void print_VkFormatProperties(const VkFormatProperties *obj, const std::string &s, bool commaNeeded = true)
8096 {
8097     PRINT_SPACE
8098     _OUT << "{" << std::endl;
8099     INDENT(4);
8100 
8101     print_VkFormatFeatureFlags(obj->linearTilingFeatures, "linearTilingFeatures", 1);
8102 
8103     print_VkFormatFeatureFlags(obj->optimalTilingFeatures, "optimalTilingFeatures", 1);
8104 
8105     print_VkFormatFeatureFlags(obj->bufferFeatures, "bufferFeatures", 0);
8106 
8107     INDENT(-4);
8108     PRINT_SPACE
8109     if (commaNeeded)
8110         _OUT << "}," << std::endl;
8111     else
8112         _OUT << "}" << std::endl;
8113 }
8114 
print_VkImageFormatProperties(VkImageFormatProperties obj,const std::string & s,bool commaNeeded=true)8115 static void print_VkImageFormatProperties(VkImageFormatProperties obj, const std::string &s, bool commaNeeded = true)
8116 {
8117     PRINT_SPACE
8118     _OUT << "{" << std::endl;
8119     INDENT(4);
8120 
8121     PRINT_SPACE
8122     _OUT << "\"maxExtent\": " << std::endl;
8123     {
8124         print_VkExtent3D(obj.maxExtent, "maxExtent", 1);
8125     }
8126 
8127     print_uint32_t(obj.maxMipLevels, "maxMipLevels", 1);
8128 
8129     print_uint32_t(obj.maxArrayLayers, "maxArrayLayers", 1);
8130 
8131     print_VkSampleCountFlags(obj.sampleCounts, "sampleCounts", 1);
8132 
8133     print_VkDeviceSize(obj.maxResourceSize, "maxResourceSize", 0);
8134 
8135     INDENT(-4);
8136     PRINT_SPACE
8137     if (commaNeeded)
8138         _OUT << "}," << std::endl;
8139     else
8140         _OUT << "}" << std::endl;
8141 }
print_VkImageFormatProperties(const VkImageFormatProperties * obj,const std::string & s,bool commaNeeded=true)8142 static void print_VkImageFormatProperties(const VkImageFormatProperties *obj, const std::string &s,
8143                                           bool commaNeeded = true)
8144 {
8145     PRINT_SPACE
8146     _OUT << "{" << std::endl;
8147     INDENT(4);
8148 
8149     PRINT_SPACE
8150     _OUT << "\"maxExtent\": " << std::endl;
8151     {
8152         print_VkExtent3D(obj->maxExtent, "maxExtent", 1);
8153     }
8154 
8155     print_uint32_t(obj->maxMipLevels, "maxMipLevels", 1);
8156 
8157     print_uint32_t(obj->maxArrayLayers, "maxArrayLayers", 1);
8158 
8159     print_VkSampleCountFlags(obj->sampleCounts, "sampleCounts", 1);
8160 
8161     print_VkDeviceSize(obj->maxResourceSize, "maxResourceSize", 0);
8162 
8163     INDENT(-4);
8164     PRINT_SPACE
8165     if (commaNeeded)
8166         _OUT << "}," << std::endl;
8167     else
8168         _OUT << "}" << std::endl;
8169 }
8170 
print_VkInstanceCreateInfo(VkInstanceCreateInfo obj,const std::string & s,bool commaNeeded=true)8171 static void print_VkInstanceCreateInfo(VkInstanceCreateInfo obj, const std::string &s, bool commaNeeded = true)
8172 {
8173     PRINT_SPACE
8174     _OUT << "{" << std::endl;
8175     INDENT(4);
8176 
8177     print_VkStructureType(obj.sType, "sType", 1);
8178 
8179     if (obj.pNext)
8180     {
8181         dumpPNextChain(obj.pNext);
8182     }
8183     else
8184     {
8185         PRINT_SPACE
8186         _OUT << "\"pNext\":"
8187              << "\"NULL\""
8188              << "," << std::endl;
8189     }
8190 
8191     print_VkInstanceCreateFlags(obj.flags, "flags", 1);
8192 
8193     PRINT_SPACE
8194     _OUT << "\"pApplicationInfo\": " << std::endl;
8195     if (obj.pApplicationInfo)
8196     {
8197         print_VkApplicationInfo(obj.pApplicationInfo, "pApplicationInfo", 1);
8198     }
8199     else
8200     {
8201         PRINT_SPACE _OUT << "\"NULL\""
8202                          << "," << std::endl;
8203     }
8204 
8205     print_uint32_t(obj.enabledLayerCount, "enabledLayerCount", 1);
8206 
8207     print_char(obj.ppEnabledLayerNames, "ppEnabledLayerNames", 1);
8208 
8209     print_uint32_t(obj.enabledExtensionCount, "enabledExtensionCount", 1);
8210 
8211     print_char(obj.ppEnabledExtensionNames, "ppEnabledExtensionNames", 0);
8212 
8213     INDENT(-4);
8214     PRINT_SPACE
8215     if (commaNeeded)
8216         _OUT << "}," << std::endl;
8217     else
8218         _OUT << "}" << std::endl;
8219 }
print_VkInstanceCreateInfo(const VkInstanceCreateInfo * obj,const std::string & s,bool commaNeeded=true)8220 static void print_VkInstanceCreateInfo(const VkInstanceCreateInfo *obj, const std::string &s, bool commaNeeded = true)
8221 {
8222     PRINT_SPACE
8223     _OUT << "{" << std::endl;
8224     INDENT(4);
8225 
8226     print_VkStructureType(obj->sType, "sType", 1);
8227 
8228     if (obj->pNext)
8229     {
8230         dumpPNextChain(obj->pNext);
8231     }
8232     else
8233     {
8234         PRINT_SPACE
8235         _OUT << "\"pNext\":"
8236              << "\"NULL\""
8237              << "," << std::endl;
8238     }
8239 
8240     print_VkInstanceCreateFlags(obj->flags, "flags", 1);
8241 
8242     PRINT_SPACE
8243     _OUT << "\"pApplicationInfo\": " << std::endl;
8244     if (obj->pApplicationInfo)
8245     {
8246         print_VkApplicationInfo(obj->pApplicationInfo, "pApplicationInfo", 1);
8247     }
8248     else
8249     {
8250         PRINT_SPACE _OUT << "\"NULL\""
8251                          << "," << std::endl;
8252     }
8253 
8254     print_uint32_t(obj->enabledLayerCount, "enabledLayerCount", 1);
8255 
8256     print_char(obj->ppEnabledLayerNames, "ppEnabledLayerNames", 1);
8257 
8258     print_uint32_t(obj->enabledExtensionCount, "enabledExtensionCount", 1);
8259 
8260     print_char(obj->ppEnabledExtensionNames, "ppEnabledExtensionNames", 0);
8261 
8262     INDENT(-4);
8263     PRINT_SPACE
8264     if (commaNeeded)
8265         _OUT << "}," << std::endl;
8266     else
8267         _OUT << "}" << std::endl;
8268 }
8269 
print_VkMemoryHeap(VkMemoryHeap obj,const std::string & s,bool commaNeeded=true)8270 static void print_VkMemoryHeap(VkMemoryHeap obj, const std::string &s, bool commaNeeded = true)
8271 {
8272     PRINT_SPACE
8273     _OUT << "{" << std::endl;
8274     INDENT(4);
8275 
8276     print_VkDeviceSize(obj.size, "size", 1);
8277 
8278     print_VkMemoryHeapFlags(obj.flags, "flags", 0);
8279 
8280     INDENT(-4);
8281     PRINT_SPACE
8282     if (commaNeeded)
8283         _OUT << "}," << std::endl;
8284     else
8285         _OUT << "}" << std::endl;
8286 }
print_VkMemoryHeap(const VkMemoryHeap * obj,const std::string & s,bool commaNeeded=true)8287 static void print_VkMemoryHeap(const VkMemoryHeap *obj, const std::string &s, bool commaNeeded = true)
8288 {
8289     PRINT_SPACE
8290     _OUT << "{" << std::endl;
8291     INDENT(4);
8292 
8293     print_VkDeviceSize(obj->size, "size", 1);
8294 
8295     print_VkMemoryHeapFlags(obj->flags, "flags", 0);
8296 
8297     INDENT(-4);
8298     PRINT_SPACE
8299     if (commaNeeded)
8300         _OUT << "}," << std::endl;
8301     else
8302         _OUT << "}" << std::endl;
8303 }
8304 
print_VkMemoryType(VkMemoryType obj,const std::string & s,bool commaNeeded=true)8305 static void print_VkMemoryType(VkMemoryType obj, const std::string &s, bool commaNeeded = true)
8306 {
8307     PRINT_SPACE
8308     _OUT << "{" << std::endl;
8309     INDENT(4);
8310 
8311     print_VkMemoryPropertyFlags(obj.propertyFlags, "propertyFlags", 1);
8312 
8313     print_uint32_t(obj.heapIndex, "heapIndex", 0);
8314 
8315     INDENT(-4);
8316     PRINT_SPACE
8317     if (commaNeeded)
8318         _OUT << "}," << std::endl;
8319     else
8320         _OUT << "}" << std::endl;
8321 }
print_VkMemoryType(const VkMemoryType * obj,const std::string & s,bool commaNeeded=true)8322 static void print_VkMemoryType(const VkMemoryType *obj, const std::string &s, bool commaNeeded = true)
8323 {
8324     PRINT_SPACE
8325     _OUT << "{" << std::endl;
8326     INDENT(4);
8327 
8328     print_VkMemoryPropertyFlags(obj->propertyFlags, "propertyFlags", 1);
8329 
8330     print_uint32_t(obj->heapIndex, "heapIndex", 0);
8331 
8332     INDENT(-4);
8333     PRINT_SPACE
8334     if (commaNeeded)
8335         _OUT << "}," << std::endl;
8336     else
8337         _OUT << "}" << std::endl;
8338 }
8339 
print_VkPhysicalDeviceFeatures(VkPhysicalDeviceFeatures obj,const std::string & s,bool commaNeeded=true)8340 static void print_VkPhysicalDeviceFeatures(VkPhysicalDeviceFeatures obj, const std::string &s, bool commaNeeded = true)
8341 {
8342     PRINT_SPACE
8343     _OUT << "{" << std::endl;
8344     INDENT(4);
8345 
8346     print_VkBool32(obj.robustBufferAccess, "robustBufferAccess", 1);
8347 
8348     print_VkBool32(obj.fullDrawIndexUint32, "fullDrawIndexUint32", 1);
8349 
8350     print_VkBool32(obj.imageCubeArray, "imageCubeArray", 1);
8351 
8352     print_VkBool32(obj.independentBlend, "independentBlend", 1);
8353 
8354     print_VkBool32(obj.geometryShader, "geometryShader", 1);
8355 
8356     print_VkBool32(obj.tessellationShader, "tessellationShader", 1);
8357 
8358     print_VkBool32(obj.sampleRateShading, "sampleRateShading", 1);
8359 
8360     print_VkBool32(obj.dualSrcBlend, "dualSrcBlend", 1);
8361 
8362     print_VkBool32(obj.logicOp, "logicOp", 1);
8363 
8364     print_VkBool32(obj.multiDrawIndirect, "multiDrawIndirect", 1);
8365 
8366     print_VkBool32(obj.drawIndirectFirstInstance, "drawIndirectFirstInstance", 1);
8367 
8368     print_VkBool32(obj.depthClamp, "depthClamp", 1);
8369 
8370     print_VkBool32(obj.depthBiasClamp, "depthBiasClamp", 1);
8371 
8372     print_VkBool32(obj.fillModeNonSolid, "fillModeNonSolid", 1);
8373 
8374     print_VkBool32(obj.depthBounds, "depthBounds", 1);
8375 
8376     print_VkBool32(obj.wideLines, "wideLines", 1);
8377 
8378     print_VkBool32(obj.largePoints, "largePoints", 1);
8379 
8380     print_VkBool32(obj.alphaToOne, "alphaToOne", 1);
8381 
8382     print_VkBool32(obj.multiViewport, "multiViewport", 1);
8383 
8384     print_VkBool32(obj.samplerAnisotropy, "samplerAnisotropy", 1);
8385 
8386     print_VkBool32(obj.textureCompressionETC2, "textureCompressionETC2", 1);
8387 
8388     print_VkBool32(obj.textureCompressionASTC_LDR, "textureCompressionASTC_LDR", 1);
8389 
8390     print_VkBool32(obj.textureCompressionBC, "textureCompressionBC", 1);
8391 
8392     print_VkBool32(obj.occlusionQueryPrecise, "occlusionQueryPrecise", 1);
8393 
8394     print_VkBool32(obj.pipelineStatisticsQuery, "pipelineStatisticsQuery", 1);
8395 
8396     print_VkBool32(obj.vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics", 1);
8397 
8398     print_VkBool32(obj.fragmentStoresAndAtomics, "fragmentStoresAndAtomics", 1);
8399 
8400     print_VkBool32(obj.shaderTessellationAndGeometryPointSize, "shaderTessellationAndGeometryPointSize", 1);
8401 
8402     print_VkBool32(obj.shaderImageGatherExtended, "shaderImageGatherExtended", 1);
8403 
8404     print_VkBool32(obj.shaderStorageImageExtendedFormats, "shaderStorageImageExtendedFormats", 1);
8405 
8406     print_VkBool32(obj.shaderStorageImageMultisample, "shaderStorageImageMultisample", 1);
8407 
8408     print_VkBool32(obj.shaderStorageImageReadWithoutFormat, "shaderStorageImageReadWithoutFormat", 1);
8409 
8410     print_VkBool32(obj.shaderStorageImageWriteWithoutFormat, "shaderStorageImageWriteWithoutFormat", 1);
8411 
8412     print_VkBool32(obj.shaderUniformBufferArrayDynamicIndexing, "shaderUniformBufferArrayDynamicIndexing", 1);
8413 
8414     print_VkBool32(obj.shaderSampledImageArrayDynamicIndexing, "shaderSampledImageArrayDynamicIndexing", 1);
8415 
8416     print_VkBool32(obj.shaderStorageBufferArrayDynamicIndexing, "shaderStorageBufferArrayDynamicIndexing", 1);
8417 
8418     print_VkBool32(obj.shaderStorageImageArrayDynamicIndexing, "shaderStorageImageArrayDynamicIndexing", 1);
8419 
8420     print_VkBool32(obj.shaderClipDistance, "shaderClipDistance", 1);
8421 
8422     print_VkBool32(obj.shaderCullDistance, "shaderCullDistance", 1);
8423 
8424     print_VkBool32(obj.shaderFloat64, "shaderFloat64", 1);
8425 
8426     print_VkBool32(obj.shaderInt64, "shaderInt64", 1);
8427 
8428     print_VkBool32(obj.shaderInt16, "shaderInt16", 1);
8429 
8430     print_VkBool32(obj.shaderResourceResidency, "shaderResourceResidency", 1);
8431 
8432     print_VkBool32(obj.shaderResourceMinLod, "shaderResourceMinLod", 1);
8433 
8434     print_VkBool32(obj.sparseBinding, "sparseBinding", 1);
8435 
8436     print_VkBool32(obj.sparseResidencyBuffer, "sparseResidencyBuffer", 1);
8437 
8438     print_VkBool32(obj.sparseResidencyImage2D, "sparseResidencyImage2D", 1);
8439 
8440     print_VkBool32(obj.sparseResidencyImage3D, "sparseResidencyImage3D", 1);
8441 
8442     print_VkBool32(obj.sparseResidency2Samples, "sparseResidency2Samples", 1);
8443 
8444     print_VkBool32(obj.sparseResidency4Samples, "sparseResidency4Samples", 1);
8445 
8446     print_VkBool32(obj.sparseResidency8Samples, "sparseResidency8Samples", 1);
8447 
8448     print_VkBool32(obj.sparseResidency16Samples, "sparseResidency16Samples", 1);
8449 
8450     print_VkBool32(obj.sparseResidencyAliased, "sparseResidencyAliased", 1);
8451 
8452     print_VkBool32(obj.variableMultisampleRate, "variableMultisampleRate", 1);
8453 
8454     print_VkBool32(obj.inheritedQueries, "inheritedQueries", 0);
8455 
8456     INDENT(-4);
8457     PRINT_SPACE
8458     if (commaNeeded)
8459         _OUT << "}," << std::endl;
8460     else
8461         _OUT << "}" << std::endl;
8462 }
print_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures * obj,const std::string & s,bool commaNeeded=true)8463 static void print_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures *obj, const std::string &s,
8464                                            bool commaNeeded = true)
8465 {
8466     PRINT_SPACE
8467     _OUT << "{" << std::endl;
8468     INDENT(4);
8469 
8470     print_VkBool32(obj->robustBufferAccess, "robustBufferAccess", 1);
8471 
8472     print_VkBool32(obj->fullDrawIndexUint32, "fullDrawIndexUint32", 1);
8473 
8474     print_VkBool32(obj->imageCubeArray, "imageCubeArray", 1);
8475 
8476     print_VkBool32(obj->independentBlend, "independentBlend", 1);
8477 
8478     print_VkBool32(obj->geometryShader, "geometryShader", 1);
8479 
8480     print_VkBool32(obj->tessellationShader, "tessellationShader", 1);
8481 
8482     print_VkBool32(obj->sampleRateShading, "sampleRateShading", 1);
8483 
8484     print_VkBool32(obj->dualSrcBlend, "dualSrcBlend", 1);
8485 
8486     print_VkBool32(obj->logicOp, "logicOp", 1);
8487 
8488     print_VkBool32(obj->multiDrawIndirect, "multiDrawIndirect", 1);
8489 
8490     print_VkBool32(obj->drawIndirectFirstInstance, "drawIndirectFirstInstance", 1);
8491 
8492     print_VkBool32(obj->depthClamp, "depthClamp", 1);
8493 
8494     print_VkBool32(obj->depthBiasClamp, "depthBiasClamp", 1);
8495 
8496     print_VkBool32(obj->fillModeNonSolid, "fillModeNonSolid", 1);
8497 
8498     print_VkBool32(obj->depthBounds, "depthBounds", 1);
8499 
8500     print_VkBool32(obj->wideLines, "wideLines", 1);
8501 
8502     print_VkBool32(obj->largePoints, "largePoints", 1);
8503 
8504     print_VkBool32(obj->alphaToOne, "alphaToOne", 1);
8505 
8506     print_VkBool32(obj->multiViewport, "multiViewport", 1);
8507 
8508     print_VkBool32(obj->samplerAnisotropy, "samplerAnisotropy", 1);
8509 
8510     print_VkBool32(obj->textureCompressionETC2, "textureCompressionETC2", 1);
8511 
8512     print_VkBool32(obj->textureCompressionASTC_LDR, "textureCompressionASTC_LDR", 1);
8513 
8514     print_VkBool32(obj->textureCompressionBC, "textureCompressionBC", 1);
8515 
8516     print_VkBool32(obj->occlusionQueryPrecise, "occlusionQueryPrecise", 1);
8517 
8518     print_VkBool32(obj->pipelineStatisticsQuery, "pipelineStatisticsQuery", 1);
8519 
8520     print_VkBool32(obj->vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics", 1);
8521 
8522     print_VkBool32(obj->fragmentStoresAndAtomics, "fragmentStoresAndAtomics", 1);
8523 
8524     print_VkBool32(obj->shaderTessellationAndGeometryPointSize, "shaderTessellationAndGeometryPointSize", 1);
8525 
8526     print_VkBool32(obj->shaderImageGatherExtended, "shaderImageGatherExtended", 1);
8527 
8528     print_VkBool32(obj->shaderStorageImageExtendedFormats, "shaderStorageImageExtendedFormats", 1);
8529 
8530     print_VkBool32(obj->shaderStorageImageMultisample, "shaderStorageImageMultisample", 1);
8531 
8532     print_VkBool32(obj->shaderStorageImageReadWithoutFormat, "shaderStorageImageReadWithoutFormat", 1);
8533 
8534     print_VkBool32(obj->shaderStorageImageWriteWithoutFormat, "shaderStorageImageWriteWithoutFormat", 1);
8535 
8536     print_VkBool32(obj->shaderUniformBufferArrayDynamicIndexing, "shaderUniformBufferArrayDynamicIndexing", 1);
8537 
8538     print_VkBool32(obj->shaderSampledImageArrayDynamicIndexing, "shaderSampledImageArrayDynamicIndexing", 1);
8539 
8540     print_VkBool32(obj->shaderStorageBufferArrayDynamicIndexing, "shaderStorageBufferArrayDynamicIndexing", 1);
8541 
8542     print_VkBool32(obj->shaderStorageImageArrayDynamicIndexing, "shaderStorageImageArrayDynamicIndexing", 1);
8543 
8544     print_VkBool32(obj->shaderClipDistance, "shaderClipDistance", 1);
8545 
8546     print_VkBool32(obj->shaderCullDistance, "shaderCullDistance", 1);
8547 
8548     print_VkBool32(obj->shaderFloat64, "shaderFloat64", 1);
8549 
8550     print_VkBool32(obj->shaderInt64, "shaderInt64", 1);
8551 
8552     print_VkBool32(obj->shaderInt16, "shaderInt16", 1);
8553 
8554     print_VkBool32(obj->shaderResourceResidency, "shaderResourceResidency", 1);
8555 
8556     print_VkBool32(obj->shaderResourceMinLod, "shaderResourceMinLod", 1);
8557 
8558     print_VkBool32(obj->sparseBinding, "sparseBinding", 1);
8559 
8560     print_VkBool32(obj->sparseResidencyBuffer, "sparseResidencyBuffer", 1);
8561 
8562     print_VkBool32(obj->sparseResidencyImage2D, "sparseResidencyImage2D", 1);
8563 
8564     print_VkBool32(obj->sparseResidencyImage3D, "sparseResidencyImage3D", 1);
8565 
8566     print_VkBool32(obj->sparseResidency2Samples, "sparseResidency2Samples", 1);
8567 
8568     print_VkBool32(obj->sparseResidency4Samples, "sparseResidency4Samples", 1);
8569 
8570     print_VkBool32(obj->sparseResidency8Samples, "sparseResidency8Samples", 1);
8571 
8572     print_VkBool32(obj->sparseResidency16Samples, "sparseResidency16Samples", 1);
8573 
8574     print_VkBool32(obj->sparseResidencyAliased, "sparseResidencyAliased", 1);
8575 
8576     print_VkBool32(obj->variableMultisampleRate, "variableMultisampleRate", 1);
8577 
8578     print_VkBool32(obj->inheritedQueries, "inheritedQueries", 0);
8579 
8580     INDENT(-4);
8581     PRINT_SPACE
8582     if (commaNeeded)
8583         _OUT << "}," << std::endl;
8584     else
8585         _OUT << "}" << std::endl;
8586 }
8587 
print_VkPhysicalDeviceLimits(VkPhysicalDeviceLimits obj,const std::string & s,bool commaNeeded=true)8588 static void print_VkPhysicalDeviceLimits(VkPhysicalDeviceLimits obj, const std::string &s, bool commaNeeded = true)
8589 {
8590     PRINT_SPACE
8591     _OUT << "{" << std::endl;
8592     INDENT(4);
8593 
8594     print_uint32_t(obj.maxImageDimension1D, "maxImageDimension1D", 1);
8595 
8596     print_uint32_t(obj.maxImageDimension2D, "maxImageDimension2D", 1);
8597 
8598     print_uint32_t(obj.maxImageDimension3D, "maxImageDimension3D", 1);
8599 
8600     print_uint32_t(obj.maxImageDimensionCube, "maxImageDimensionCube", 1);
8601 
8602     print_uint32_t(obj.maxImageArrayLayers, "maxImageArrayLayers", 1);
8603 
8604     print_uint32_t(obj.maxTexelBufferElements, "maxTexelBufferElements", 1);
8605 
8606     print_uint32_t(obj.maxUniformBufferRange, "maxUniformBufferRange", 1);
8607 
8608     print_uint32_t(obj.maxStorageBufferRange, "maxStorageBufferRange", 1);
8609 
8610     print_uint32_t(obj.maxPushConstantsSize, "maxPushConstantsSize", 1);
8611 
8612     print_uint32_t(obj.maxMemoryAllocationCount, "maxMemoryAllocationCount", 1);
8613 
8614     print_uint32_t(obj.maxSamplerAllocationCount, "maxSamplerAllocationCount", 1);
8615 
8616     print_VkDeviceSize(obj.bufferImageGranularity, "bufferImageGranularity", 1);
8617 
8618     print_VkDeviceSize(obj.sparseAddressSpaceSize, "sparseAddressSpaceSize", 1);
8619 
8620     print_uint32_t(obj.maxBoundDescriptorSets, "maxBoundDescriptorSets", 1);
8621 
8622     print_uint32_t(obj.maxPerStageDescriptorSamplers, "maxPerStageDescriptorSamplers", 1);
8623 
8624     print_uint32_t(obj.maxPerStageDescriptorUniformBuffers, "maxPerStageDescriptorUniformBuffers", 1);
8625 
8626     print_uint32_t(obj.maxPerStageDescriptorStorageBuffers, "maxPerStageDescriptorStorageBuffers", 1);
8627 
8628     print_uint32_t(obj.maxPerStageDescriptorSampledImages, "maxPerStageDescriptorSampledImages", 1);
8629 
8630     print_uint32_t(obj.maxPerStageDescriptorStorageImages, "maxPerStageDescriptorStorageImages", 1);
8631 
8632     print_uint32_t(obj.maxPerStageDescriptorInputAttachments, "maxPerStageDescriptorInputAttachments", 1);
8633 
8634     print_uint32_t(obj.maxPerStageResources, "maxPerStageResources", 1);
8635 
8636     print_uint32_t(obj.maxDescriptorSetSamplers, "maxDescriptorSetSamplers", 1);
8637 
8638     print_uint32_t(obj.maxDescriptorSetUniformBuffers, "maxDescriptorSetUniformBuffers", 1);
8639 
8640     print_uint32_t(obj.maxDescriptorSetUniformBuffersDynamic, "maxDescriptorSetUniformBuffersDynamic", 1);
8641 
8642     print_uint32_t(obj.maxDescriptorSetStorageBuffers, "maxDescriptorSetStorageBuffers", 1);
8643 
8644     print_uint32_t(obj.maxDescriptorSetStorageBuffersDynamic, "maxDescriptorSetStorageBuffersDynamic", 1);
8645 
8646     print_uint32_t(obj.maxDescriptorSetSampledImages, "maxDescriptorSetSampledImages", 1);
8647 
8648     print_uint32_t(obj.maxDescriptorSetStorageImages, "maxDescriptorSetStorageImages", 1);
8649 
8650     print_uint32_t(obj.maxDescriptorSetInputAttachments, "maxDescriptorSetInputAttachments", 1);
8651 
8652     print_uint32_t(obj.maxVertexInputAttributes, "maxVertexInputAttributes", 1);
8653 
8654     print_uint32_t(obj.maxVertexInputBindings, "maxVertexInputBindings", 1);
8655 
8656     print_uint32_t(obj.maxVertexInputAttributeOffset, "maxVertexInputAttributeOffset", 1);
8657 
8658     print_uint32_t(obj.maxVertexInputBindingStride, "maxVertexInputBindingStride", 1);
8659 
8660     print_uint32_t(obj.maxVertexOutputComponents, "maxVertexOutputComponents", 1);
8661 
8662     print_uint32_t(obj.maxTessellationGenerationLevel, "maxTessellationGenerationLevel", 1);
8663 
8664     print_uint32_t(obj.maxTessellationPatchSize, "maxTessellationPatchSize", 1);
8665 
8666     print_uint32_t(obj.maxTessellationControlPerVertexInputComponents, "maxTessellationControlPerVertexInputComponents",
8667                    1);
8668 
8669     print_uint32_t(obj.maxTessellationControlPerVertexOutputComponents,
8670                    "maxTessellationControlPerVertexOutputComponents", 1);
8671 
8672     print_uint32_t(obj.maxTessellationControlPerPatchOutputComponents, "maxTessellationControlPerPatchOutputComponents",
8673                    1);
8674 
8675     print_uint32_t(obj.maxTessellationControlTotalOutputComponents, "maxTessellationControlTotalOutputComponents", 1);
8676 
8677     print_uint32_t(obj.maxTessellationEvaluationInputComponents, "maxTessellationEvaluationInputComponents", 1);
8678 
8679     print_uint32_t(obj.maxTessellationEvaluationOutputComponents, "maxTessellationEvaluationOutputComponents", 1);
8680 
8681     print_uint32_t(obj.maxGeometryShaderInvocations, "maxGeometryShaderInvocations", 1);
8682 
8683     print_uint32_t(obj.maxGeometryInputComponents, "maxGeometryInputComponents", 1);
8684 
8685     print_uint32_t(obj.maxGeometryOutputComponents, "maxGeometryOutputComponents", 1);
8686 
8687     print_uint32_t(obj.maxGeometryOutputVertices, "maxGeometryOutputVertices", 1);
8688 
8689     print_uint32_t(obj.maxGeometryTotalOutputComponents, "maxGeometryTotalOutputComponents", 1);
8690 
8691     print_uint32_t(obj.maxFragmentInputComponents, "maxFragmentInputComponents", 1);
8692 
8693     print_uint32_t(obj.maxFragmentOutputAttachments, "maxFragmentOutputAttachments", 1);
8694 
8695     print_uint32_t(obj.maxFragmentDualSrcAttachments, "maxFragmentDualSrcAttachments", 1);
8696 
8697     print_uint32_t(obj.maxFragmentCombinedOutputResources, "maxFragmentCombinedOutputResources", 1);
8698 
8699     print_uint32_t(obj.maxComputeSharedMemorySize, "maxComputeSharedMemorySize", 1);
8700 
8701     PRINT_SPACE
8702     _OUT << "\"maxComputeWorkGroupCount\":" << std::endl;
8703     PRINT_SPACE
8704     _OUT << "[" << std::endl;
8705     for (unsigned int i = 0; i < 3; i++)
8706     {
8707         bool isCommaNeeded = (i + 1) != 3;
8708         print_uint32_t(obj.maxComputeWorkGroupCount[i], "", isCommaNeeded);
8709     }
8710     PRINT_SPACE
8711     _OUT << "]"
8712          << "," << std::endl;
8713 
8714     print_uint32_t(obj.maxComputeWorkGroupInvocations, "maxComputeWorkGroupInvocations", 1);
8715 
8716     PRINT_SPACE
8717     _OUT << "\"maxComputeWorkGroupSize\":" << std::endl;
8718     PRINT_SPACE
8719     _OUT << "[" << std::endl;
8720     for (unsigned int i = 0; i < 3; i++)
8721     {
8722         bool isCommaNeeded = (i + 1) != 3;
8723         print_uint32_t(obj.maxComputeWorkGroupSize[i], "", isCommaNeeded);
8724     }
8725     PRINT_SPACE
8726     _OUT << "]"
8727          << "," << std::endl;
8728 
8729     print_uint32_t(obj.subPixelPrecisionBits, "subPixelPrecisionBits", 1);
8730 
8731     print_uint32_t(obj.subTexelPrecisionBits, "subTexelPrecisionBits", 1);
8732 
8733     print_uint32_t(obj.mipmapPrecisionBits, "mipmapPrecisionBits", 1);
8734 
8735     print_uint32_t(obj.maxDrawIndexedIndexValue, "maxDrawIndexedIndexValue", 1);
8736 
8737     print_uint32_t(obj.maxDrawIndirectCount, "maxDrawIndirectCount", 1);
8738 
8739     print_float(obj.maxSamplerLodBias, "maxSamplerLodBias", 1);
8740 
8741     print_float(obj.maxSamplerAnisotropy, "maxSamplerAnisotropy", 1);
8742 
8743     print_uint32_t(obj.maxViewports, "maxViewports", 1);
8744 
8745     PRINT_SPACE
8746     _OUT << "\"maxViewportDimensions\":" << std::endl;
8747     PRINT_SPACE
8748     _OUT << "[" << std::endl;
8749     for (unsigned int i = 0; i < 2; i++)
8750     {
8751         bool isCommaNeeded = (i + 1) != 2;
8752         print_uint32_t(obj.maxViewportDimensions[i], "", isCommaNeeded);
8753     }
8754     PRINT_SPACE
8755     _OUT << "]"
8756          << "," << std::endl;
8757 
8758     PRINT_SPACE
8759     _OUT << "\"viewportBoundsRange\":" << std::endl;
8760     PRINT_SPACE
8761     _OUT << "[" << std::endl;
8762     for (unsigned int i = 0; i < 2; i++)
8763     {
8764         bool isCommaNeeded = (i + 1) != 2;
8765         print_float(obj.viewportBoundsRange[i], "", isCommaNeeded);
8766     }
8767     PRINT_SPACE
8768     _OUT << "]"
8769          << "," << std::endl;
8770 
8771     print_uint32_t(obj.viewportSubPixelBits, "viewportSubPixelBits", 1);
8772 
8773     print_size_t(obj.minMemoryMapAlignment, "minMemoryMapAlignment", 1);
8774 
8775     print_VkDeviceSize(obj.minTexelBufferOffsetAlignment, "minTexelBufferOffsetAlignment", 1);
8776 
8777     print_VkDeviceSize(obj.minUniformBufferOffsetAlignment, "minUniformBufferOffsetAlignment", 1);
8778 
8779     print_VkDeviceSize(obj.minStorageBufferOffsetAlignment, "minStorageBufferOffsetAlignment", 1);
8780 
8781     print_int32_t(obj.minTexelOffset, "minTexelOffset", 1);
8782 
8783     print_uint32_t(obj.maxTexelOffset, "maxTexelOffset", 1);
8784 
8785     print_int32_t(obj.minTexelGatherOffset, "minTexelGatherOffset", 1);
8786 
8787     print_uint32_t(obj.maxTexelGatherOffset, "maxTexelGatherOffset", 1);
8788 
8789     print_float(obj.minInterpolationOffset, "minInterpolationOffset", 1);
8790 
8791     print_float(obj.maxInterpolationOffset, "maxInterpolationOffset", 1);
8792 
8793     print_uint32_t(obj.subPixelInterpolationOffsetBits, "subPixelInterpolationOffsetBits", 1);
8794 
8795     print_uint32_t(obj.maxFramebufferWidth, "maxFramebufferWidth", 1);
8796 
8797     print_uint32_t(obj.maxFramebufferHeight, "maxFramebufferHeight", 1);
8798 
8799     print_uint32_t(obj.maxFramebufferLayers, "maxFramebufferLayers", 1);
8800 
8801     print_VkSampleCountFlags(obj.framebufferColorSampleCounts, "framebufferColorSampleCounts", 1);
8802 
8803     print_VkSampleCountFlags(obj.framebufferDepthSampleCounts, "framebufferDepthSampleCounts", 1);
8804 
8805     print_VkSampleCountFlags(obj.framebufferStencilSampleCounts, "framebufferStencilSampleCounts", 1);
8806 
8807     print_VkSampleCountFlags(obj.framebufferNoAttachmentsSampleCounts, "framebufferNoAttachmentsSampleCounts", 1);
8808 
8809     print_uint32_t(obj.maxColorAttachments, "maxColorAttachments", 1);
8810 
8811     print_VkSampleCountFlags(obj.sampledImageColorSampleCounts, "sampledImageColorSampleCounts", 1);
8812 
8813     print_VkSampleCountFlags(obj.sampledImageIntegerSampleCounts, "sampledImageIntegerSampleCounts", 1);
8814 
8815     print_VkSampleCountFlags(obj.sampledImageDepthSampleCounts, "sampledImageDepthSampleCounts", 1);
8816 
8817     print_VkSampleCountFlags(obj.sampledImageStencilSampleCounts, "sampledImageStencilSampleCounts", 1);
8818 
8819     print_VkSampleCountFlags(obj.storageImageSampleCounts, "storageImageSampleCounts", 1);
8820 
8821     print_uint32_t(obj.maxSampleMaskWords, "maxSampleMaskWords", 1);
8822 
8823     print_VkBool32(obj.timestampComputeAndGraphics, "timestampComputeAndGraphics", 1);
8824 
8825     print_float(obj.timestampPeriod, "timestampPeriod", 1);
8826 
8827     print_uint32_t(obj.maxClipDistances, "maxClipDistances", 1);
8828 
8829     print_uint32_t(obj.maxCullDistances, "maxCullDistances", 1);
8830 
8831     print_uint32_t(obj.maxCombinedClipAndCullDistances, "maxCombinedClipAndCullDistances", 1);
8832 
8833     print_uint32_t(obj.discreteQueuePriorities, "discreteQueuePriorities", 1);
8834 
8835     PRINT_SPACE
8836     _OUT << "\"pointSizeRange\":" << std::endl;
8837     PRINT_SPACE
8838     _OUT << "[" << std::endl;
8839     for (unsigned int i = 0; i < 2; i++)
8840     {
8841         bool isCommaNeeded = (i + 1) != 2;
8842         print_float(obj.pointSizeRange[i], "", isCommaNeeded);
8843     }
8844     PRINT_SPACE
8845     _OUT << "]"
8846          << "," << std::endl;
8847 
8848     PRINT_SPACE
8849     _OUT << "\"lineWidthRange\":" << std::endl;
8850     PRINT_SPACE
8851     _OUT << "[" << std::endl;
8852     for (unsigned int i = 0; i < 2; i++)
8853     {
8854         bool isCommaNeeded = (i + 1) != 2;
8855         print_float(obj.lineWidthRange[i], "", isCommaNeeded);
8856     }
8857     PRINT_SPACE
8858     _OUT << "]"
8859          << "," << std::endl;
8860 
8861     print_float(obj.pointSizeGranularity, "pointSizeGranularity", 1);
8862 
8863     print_float(obj.lineWidthGranularity, "lineWidthGranularity", 1);
8864 
8865     print_VkBool32(obj.strictLines, "strictLines", 1);
8866 
8867     print_VkBool32(obj.standardSampleLocations, "standardSampleLocations", 1);
8868 
8869     print_VkDeviceSize(obj.optimalBufferCopyOffsetAlignment, "optimalBufferCopyOffsetAlignment", 1);
8870 
8871     print_VkDeviceSize(obj.optimalBufferCopyRowPitchAlignment, "optimalBufferCopyRowPitchAlignment", 1);
8872 
8873     print_VkDeviceSize(obj.nonCoherentAtomSize, "nonCoherentAtomSize", 0);
8874 
8875     INDENT(-4);
8876     PRINT_SPACE
8877     if (commaNeeded)
8878         _OUT << "}," << std::endl;
8879     else
8880         _OUT << "}" << std::endl;
8881 }
print_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits * obj,const std::string & s,bool commaNeeded=true)8882 static void print_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits *obj, const std::string &s,
8883                                          bool commaNeeded = true)
8884 {
8885     PRINT_SPACE
8886     _OUT << "{" << std::endl;
8887     INDENT(4);
8888 
8889     print_uint32_t(obj->maxImageDimension1D, "maxImageDimension1D", 1);
8890 
8891     print_uint32_t(obj->maxImageDimension2D, "maxImageDimension2D", 1);
8892 
8893     print_uint32_t(obj->maxImageDimension3D, "maxImageDimension3D", 1);
8894 
8895     print_uint32_t(obj->maxImageDimensionCube, "maxImageDimensionCube", 1);
8896 
8897     print_uint32_t(obj->maxImageArrayLayers, "maxImageArrayLayers", 1);
8898 
8899     print_uint32_t(obj->maxTexelBufferElements, "maxTexelBufferElements", 1);
8900 
8901     print_uint32_t(obj->maxUniformBufferRange, "maxUniformBufferRange", 1);
8902 
8903     print_uint32_t(obj->maxStorageBufferRange, "maxStorageBufferRange", 1);
8904 
8905     print_uint32_t(obj->maxPushConstantsSize, "maxPushConstantsSize", 1);
8906 
8907     print_uint32_t(obj->maxMemoryAllocationCount, "maxMemoryAllocationCount", 1);
8908 
8909     print_uint32_t(obj->maxSamplerAllocationCount, "maxSamplerAllocationCount", 1);
8910 
8911     print_VkDeviceSize(obj->bufferImageGranularity, "bufferImageGranularity", 1);
8912 
8913     print_VkDeviceSize(obj->sparseAddressSpaceSize, "sparseAddressSpaceSize", 1);
8914 
8915     print_uint32_t(obj->maxBoundDescriptorSets, "maxBoundDescriptorSets", 1);
8916 
8917     print_uint32_t(obj->maxPerStageDescriptorSamplers, "maxPerStageDescriptorSamplers", 1);
8918 
8919     print_uint32_t(obj->maxPerStageDescriptorUniformBuffers, "maxPerStageDescriptorUniformBuffers", 1);
8920 
8921     print_uint32_t(obj->maxPerStageDescriptorStorageBuffers, "maxPerStageDescriptorStorageBuffers", 1);
8922 
8923     print_uint32_t(obj->maxPerStageDescriptorSampledImages, "maxPerStageDescriptorSampledImages", 1);
8924 
8925     print_uint32_t(obj->maxPerStageDescriptorStorageImages, "maxPerStageDescriptorStorageImages", 1);
8926 
8927     print_uint32_t(obj->maxPerStageDescriptorInputAttachments, "maxPerStageDescriptorInputAttachments", 1);
8928 
8929     print_uint32_t(obj->maxPerStageResources, "maxPerStageResources", 1);
8930 
8931     print_uint32_t(obj->maxDescriptorSetSamplers, "maxDescriptorSetSamplers", 1);
8932 
8933     print_uint32_t(obj->maxDescriptorSetUniformBuffers, "maxDescriptorSetUniformBuffers", 1);
8934 
8935     print_uint32_t(obj->maxDescriptorSetUniformBuffersDynamic, "maxDescriptorSetUniformBuffersDynamic", 1);
8936 
8937     print_uint32_t(obj->maxDescriptorSetStorageBuffers, "maxDescriptorSetStorageBuffers", 1);
8938 
8939     print_uint32_t(obj->maxDescriptorSetStorageBuffersDynamic, "maxDescriptorSetStorageBuffersDynamic", 1);
8940 
8941     print_uint32_t(obj->maxDescriptorSetSampledImages, "maxDescriptorSetSampledImages", 1);
8942 
8943     print_uint32_t(obj->maxDescriptorSetStorageImages, "maxDescriptorSetStorageImages", 1);
8944 
8945     print_uint32_t(obj->maxDescriptorSetInputAttachments, "maxDescriptorSetInputAttachments", 1);
8946 
8947     print_uint32_t(obj->maxVertexInputAttributes, "maxVertexInputAttributes", 1);
8948 
8949     print_uint32_t(obj->maxVertexInputBindings, "maxVertexInputBindings", 1);
8950 
8951     print_uint32_t(obj->maxVertexInputAttributeOffset, "maxVertexInputAttributeOffset", 1);
8952 
8953     print_uint32_t(obj->maxVertexInputBindingStride, "maxVertexInputBindingStride", 1);
8954 
8955     print_uint32_t(obj->maxVertexOutputComponents, "maxVertexOutputComponents", 1);
8956 
8957     print_uint32_t(obj->maxTessellationGenerationLevel, "maxTessellationGenerationLevel", 1);
8958 
8959     print_uint32_t(obj->maxTessellationPatchSize, "maxTessellationPatchSize", 1);
8960 
8961     print_uint32_t(obj->maxTessellationControlPerVertexInputComponents,
8962                    "maxTessellationControlPerVertexInputComponents", 1);
8963 
8964     print_uint32_t(obj->maxTessellationControlPerVertexOutputComponents,
8965                    "maxTessellationControlPerVertexOutputComponents", 1);
8966 
8967     print_uint32_t(obj->maxTessellationControlPerPatchOutputComponents,
8968                    "maxTessellationControlPerPatchOutputComponents", 1);
8969 
8970     print_uint32_t(obj->maxTessellationControlTotalOutputComponents, "maxTessellationControlTotalOutputComponents", 1);
8971 
8972     print_uint32_t(obj->maxTessellationEvaluationInputComponents, "maxTessellationEvaluationInputComponents", 1);
8973 
8974     print_uint32_t(obj->maxTessellationEvaluationOutputComponents, "maxTessellationEvaluationOutputComponents", 1);
8975 
8976     print_uint32_t(obj->maxGeometryShaderInvocations, "maxGeometryShaderInvocations", 1);
8977 
8978     print_uint32_t(obj->maxGeometryInputComponents, "maxGeometryInputComponents", 1);
8979 
8980     print_uint32_t(obj->maxGeometryOutputComponents, "maxGeometryOutputComponents", 1);
8981 
8982     print_uint32_t(obj->maxGeometryOutputVertices, "maxGeometryOutputVertices", 1);
8983 
8984     print_uint32_t(obj->maxGeometryTotalOutputComponents, "maxGeometryTotalOutputComponents", 1);
8985 
8986     print_uint32_t(obj->maxFragmentInputComponents, "maxFragmentInputComponents", 1);
8987 
8988     print_uint32_t(obj->maxFragmentOutputAttachments, "maxFragmentOutputAttachments", 1);
8989 
8990     print_uint32_t(obj->maxFragmentDualSrcAttachments, "maxFragmentDualSrcAttachments", 1);
8991 
8992     print_uint32_t(obj->maxFragmentCombinedOutputResources, "maxFragmentCombinedOutputResources", 1);
8993 
8994     print_uint32_t(obj->maxComputeSharedMemorySize, "maxComputeSharedMemorySize", 1);
8995 
8996     PRINT_SPACE
8997     _OUT << "\"maxComputeWorkGroupCount\":" << std::endl;
8998     PRINT_SPACE
8999     _OUT << "[" << std::endl;
9000     for (unsigned int i = 0; i < 3; i++)
9001     {
9002         bool isCommaNeeded = (i + 1) != 3;
9003         print_uint32_t(obj->maxComputeWorkGroupCount[i], "", isCommaNeeded);
9004     }
9005     PRINT_SPACE
9006     _OUT << "]"
9007          << "," << std::endl;
9008 
9009     print_uint32_t(obj->maxComputeWorkGroupInvocations, "maxComputeWorkGroupInvocations", 1);
9010 
9011     PRINT_SPACE
9012     _OUT << "\"maxComputeWorkGroupSize\":" << std::endl;
9013     PRINT_SPACE
9014     _OUT << "[" << std::endl;
9015     for (unsigned int i = 0; i < 3; i++)
9016     {
9017         bool isCommaNeeded = (i + 1) != 3;
9018         print_uint32_t(obj->maxComputeWorkGroupSize[i], "", isCommaNeeded);
9019     }
9020     PRINT_SPACE
9021     _OUT << "]"
9022          << "," << std::endl;
9023 
9024     print_uint32_t(obj->subPixelPrecisionBits, "subPixelPrecisionBits", 1);
9025 
9026     print_uint32_t(obj->subTexelPrecisionBits, "subTexelPrecisionBits", 1);
9027 
9028     print_uint32_t(obj->mipmapPrecisionBits, "mipmapPrecisionBits", 1);
9029 
9030     print_uint32_t(obj->maxDrawIndexedIndexValue, "maxDrawIndexedIndexValue", 1);
9031 
9032     print_uint32_t(obj->maxDrawIndirectCount, "maxDrawIndirectCount", 1);
9033 
9034     print_float(obj->maxSamplerLodBias, "maxSamplerLodBias", 1);
9035 
9036     print_float(obj->maxSamplerAnisotropy, "maxSamplerAnisotropy", 1);
9037 
9038     print_uint32_t(obj->maxViewports, "maxViewports", 1);
9039 
9040     PRINT_SPACE
9041     _OUT << "\"maxViewportDimensions\":" << std::endl;
9042     PRINT_SPACE
9043     _OUT << "[" << std::endl;
9044     for (unsigned int i = 0; i < 2; i++)
9045     {
9046         bool isCommaNeeded = (i + 1) != 2;
9047         print_uint32_t(obj->maxViewportDimensions[i], "", isCommaNeeded);
9048     }
9049     PRINT_SPACE
9050     _OUT << "]"
9051          << "," << std::endl;
9052 
9053     PRINT_SPACE
9054     _OUT << "\"viewportBoundsRange\":" << std::endl;
9055     PRINT_SPACE
9056     _OUT << "[" << std::endl;
9057     for (unsigned int i = 0; i < 2; i++)
9058     {
9059         bool isCommaNeeded = (i + 1) != 2;
9060         print_float(obj->viewportBoundsRange[i], "", isCommaNeeded);
9061     }
9062     PRINT_SPACE
9063     _OUT << "]"
9064          << "," << std::endl;
9065 
9066     print_uint32_t(obj->viewportSubPixelBits, "viewportSubPixelBits", 1);
9067 
9068     print_size_t(obj->minMemoryMapAlignment, "minMemoryMapAlignment", 1);
9069 
9070     print_VkDeviceSize(obj->minTexelBufferOffsetAlignment, "minTexelBufferOffsetAlignment", 1);
9071 
9072     print_VkDeviceSize(obj->minUniformBufferOffsetAlignment, "minUniformBufferOffsetAlignment", 1);
9073 
9074     print_VkDeviceSize(obj->minStorageBufferOffsetAlignment, "minStorageBufferOffsetAlignment", 1);
9075 
9076     print_int32_t(obj->minTexelOffset, "minTexelOffset", 1);
9077 
9078     print_uint32_t(obj->maxTexelOffset, "maxTexelOffset", 1);
9079 
9080     print_int32_t(obj->minTexelGatherOffset, "minTexelGatherOffset", 1);
9081 
9082     print_uint32_t(obj->maxTexelGatherOffset, "maxTexelGatherOffset", 1);
9083 
9084     print_float(obj->minInterpolationOffset, "minInterpolationOffset", 1);
9085 
9086     print_float(obj->maxInterpolationOffset, "maxInterpolationOffset", 1);
9087 
9088     print_uint32_t(obj->subPixelInterpolationOffsetBits, "subPixelInterpolationOffsetBits", 1);
9089 
9090     print_uint32_t(obj->maxFramebufferWidth, "maxFramebufferWidth", 1);
9091 
9092     print_uint32_t(obj->maxFramebufferHeight, "maxFramebufferHeight", 1);
9093 
9094     print_uint32_t(obj->maxFramebufferLayers, "maxFramebufferLayers", 1);
9095 
9096     print_VkSampleCountFlags(obj->framebufferColorSampleCounts, "framebufferColorSampleCounts", 1);
9097 
9098     print_VkSampleCountFlags(obj->framebufferDepthSampleCounts, "framebufferDepthSampleCounts", 1);
9099 
9100     print_VkSampleCountFlags(obj->framebufferStencilSampleCounts, "framebufferStencilSampleCounts", 1);
9101 
9102     print_VkSampleCountFlags(obj->framebufferNoAttachmentsSampleCounts, "framebufferNoAttachmentsSampleCounts", 1);
9103 
9104     print_uint32_t(obj->maxColorAttachments, "maxColorAttachments", 1);
9105 
9106     print_VkSampleCountFlags(obj->sampledImageColorSampleCounts, "sampledImageColorSampleCounts", 1);
9107 
9108     print_VkSampleCountFlags(obj->sampledImageIntegerSampleCounts, "sampledImageIntegerSampleCounts", 1);
9109 
9110     print_VkSampleCountFlags(obj->sampledImageDepthSampleCounts, "sampledImageDepthSampleCounts", 1);
9111 
9112     print_VkSampleCountFlags(obj->sampledImageStencilSampleCounts, "sampledImageStencilSampleCounts", 1);
9113 
9114     print_VkSampleCountFlags(obj->storageImageSampleCounts, "storageImageSampleCounts", 1);
9115 
9116     print_uint32_t(obj->maxSampleMaskWords, "maxSampleMaskWords", 1);
9117 
9118     print_VkBool32(obj->timestampComputeAndGraphics, "timestampComputeAndGraphics", 1);
9119 
9120     print_float(obj->timestampPeriod, "timestampPeriod", 1);
9121 
9122     print_uint32_t(obj->maxClipDistances, "maxClipDistances", 1);
9123 
9124     print_uint32_t(obj->maxCullDistances, "maxCullDistances", 1);
9125 
9126     print_uint32_t(obj->maxCombinedClipAndCullDistances, "maxCombinedClipAndCullDistances", 1);
9127 
9128     print_uint32_t(obj->discreteQueuePriorities, "discreteQueuePriorities", 1);
9129 
9130     PRINT_SPACE
9131     _OUT << "\"pointSizeRange\":" << std::endl;
9132     PRINT_SPACE
9133     _OUT << "[" << std::endl;
9134     for (unsigned int i = 0; i < 2; i++)
9135     {
9136         bool isCommaNeeded = (i + 1) != 2;
9137         print_float(obj->pointSizeRange[i], "", isCommaNeeded);
9138     }
9139     PRINT_SPACE
9140     _OUT << "]"
9141          << "," << std::endl;
9142 
9143     PRINT_SPACE
9144     _OUT << "\"lineWidthRange\":" << std::endl;
9145     PRINT_SPACE
9146     _OUT << "[" << std::endl;
9147     for (unsigned int i = 0; i < 2; i++)
9148     {
9149         bool isCommaNeeded = (i + 1) != 2;
9150         print_float(obj->lineWidthRange[i], "", isCommaNeeded);
9151     }
9152     PRINT_SPACE
9153     _OUT << "]"
9154          << "," << std::endl;
9155 
9156     print_float(obj->pointSizeGranularity, "pointSizeGranularity", 1);
9157 
9158     print_float(obj->lineWidthGranularity, "lineWidthGranularity", 1);
9159 
9160     print_VkBool32(obj->strictLines, "strictLines", 1);
9161 
9162     print_VkBool32(obj->standardSampleLocations, "standardSampleLocations", 1);
9163 
9164     print_VkDeviceSize(obj->optimalBufferCopyOffsetAlignment, "optimalBufferCopyOffsetAlignment", 1);
9165 
9166     print_VkDeviceSize(obj->optimalBufferCopyRowPitchAlignment, "optimalBufferCopyRowPitchAlignment", 1);
9167 
9168     print_VkDeviceSize(obj->nonCoherentAtomSize, "nonCoherentAtomSize", 0);
9169 
9170     INDENT(-4);
9171     PRINT_SPACE
9172     if (commaNeeded)
9173         _OUT << "}," << std::endl;
9174     else
9175         _OUT << "}" << std::endl;
9176 }
9177 
print_VkPhysicalDeviceMemoryProperties(VkPhysicalDeviceMemoryProperties obj,const std::string & s,bool commaNeeded=true)9178 static void print_VkPhysicalDeviceMemoryProperties(VkPhysicalDeviceMemoryProperties obj, const std::string &s,
9179                                                    bool commaNeeded = true)
9180 {
9181     PRINT_SPACE
9182     _OUT << "{" << std::endl;
9183     INDENT(4);
9184 
9185     print_uint32_t(obj.memoryTypeCount, "memoryTypeCount", 1);
9186 
9187     PRINT_SPACE
9188     _OUT << "\"memoryTypes\":" << std::endl;
9189     PRINT_SPACE
9190     _OUT << "[" << std::endl;
9191     for (unsigned int i = 0; i < VK_MAX_MEMORY_TYPES; i++)
9192     {
9193         bool isCommaNeeded = (i + 1) != VK_MAX_MEMORY_TYPES;
9194         print_VkMemoryType(obj.memoryTypes[i], "", isCommaNeeded);
9195     }
9196     PRINT_SPACE
9197     _OUT << "]"
9198          << "," << std::endl;
9199 
9200     print_uint32_t(obj.memoryHeapCount, "memoryHeapCount", 1);
9201 
9202     PRINT_SPACE
9203     _OUT << "\"memoryHeaps\":" << std::endl;
9204     PRINT_SPACE
9205     _OUT << "[" << std::endl;
9206     for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
9207     {
9208         bool isCommaNeeded = (i + 1) != VK_MAX_MEMORY_HEAPS;
9209         print_VkMemoryHeap(obj.memoryHeaps[i], "", isCommaNeeded);
9210     }
9211     PRINT_SPACE
9212     _OUT << "]"
9213          << "" << std::endl;
9214 
9215     INDENT(-4);
9216     PRINT_SPACE
9217     if (commaNeeded)
9218         _OUT << "}," << std::endl;
9219     else
9220         _OUT << "}" << std::endl;
9221 }
print_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties * obj,const std::string & s,bool commaNeeded=true)9222 static void print_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties *obj, const std::string &s,
9223                                                    bool commaNeeded = true)
9224 {
9225     PRINT_SPACE
9226     _OUT << "{" << std::endl;
9227     INDENT(4);
9228 
9229     print_uint32_t(obj->memoryTypeCount, "memoryTypeCount", 1);
9230 
9231     PRINT_SPACE
9232     _OUT << "\"memoryTypes\":" << std::endl;
9233     PRINT_SPACE
9234     _OUT << "[" << std::endl;
9235     for (unsigned int i = 0; i < VK_MAX_MEMORY_TYPES; i++)
9236     {
9237         bool isCommaNeeded = (i + 1) != VK_MAX_MEMORY_TYPES;
9238         print_VkMemoryType(obj->memoryTypes[i], "", isCommaNeeded);
9239     }
9240     PRINT_SPACE
9241     _OUT << "]"
9242          << "," << std::endl;
9243 
9244     print_uint32_t(obj->memoryHeapCount, "memoryHeapCount", 1);
9245 
9246     PRINT_SPACE
9247     _OUT << "\"memoryHeaps\":" << std::endl;
9248     PRINT_SPACE
9249     _OUT << "[" << std::endl;
9250     for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
9251     {
9252         bool isCommaNeeded = (i + 1) != VK_MAX_MEMORY_HEAPS;
9253         print_VkMemoryHeap(obj->memoryHeaps[i], "", isCommaNeeded);
9254     }
9255     PRINT_SPACE
9256     _OUT << "]"
9257          << "" << std::endl;
9258 
9259     INDENT(-4);
9260     PRINT_SPACE
9261     if (commaNeeded)
9262         _OUT << "}," << std::endl;
9263     else
9264         _OUT << "}" << std::endl;
9265 }
9266 
print_VkPhysicalDeviceSparseProperties(VkPhysicalDeviceSparseProperties obj,const std::string & s,bool commaNeeded=true)9267 static void print_VkPhysicalDeviceSparseProperties(VkPhysicalDeviceSparseProperties obj, const std::string &s,
9268                                                    bool commaNeeded = true)
9269 {
9270     PRINT_SPACE
9271     _OUT << "{" << std::endl;
9272     INDENT(4);
9273 
9274     print_VkBool32(obj.residencyStandard2DBlockShape, "residencyStandard2DBlockShape", 1);
9275 
9276     print_VkBool32(obj.residencyStandard2DMultisampleBlockShape, "residencyStandard2DMultisampleBlockShape", 1);
9277 
9278     print_VkBool32(obj.residencyStandard3DBlockShape, "residencyStandard3DBlockShape", 1);
9279 
9280     print_VkBool32(obj.residencyAlignedMipSize, "residencyAlignedMipSize", 1);
9281 
9282     print_VkBool32(obj.residencyNonResidentStrict, "residencyNonResidentStrict", 0);
9283 
9284     INDENT(-4);
9285     PRINT_SPACE
9286     if (commaNeeded)
9287         _OUT << "}," << std::endl;
9288     else
9289         _OUT << "}" << std::endl;
9290 }
print_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties * obj,const std::string & s,bool commaNeeded=true)9291 static void print_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties *obj, const std::string &s,
9292                                                    bool commaNeeded = true)
9293 {
9294     PRINT_SPACE
9295     _OUT << "{" << std::endl;
9296     INDENT(4);
9297 
9298     print_VkBool32(obj->residencyStandard2DBlockShape, "residencyStandard2DBlockShape", 1);
9299 
9300     print_VkBool32(obj->residencyStandard2DMultisampleBlockShape, "residencyStandard2DMultisampleBlockShape", 1);
9301 
9302     print_VkBool32(obj->residencyStandard3DBlockShape, "residencyStandard3DBlockShape", 1);
9303 
9304     print_VkBool32(obj->residencyAlignedMipSize, "residencyAlignedMipSize", 1);
9305 
9306     print_VkBool32(obj->residencyNonResidentStrict, "residencyNonResidentStrict", 0);
9307 
9308     INDENT(-4);
9309     PRINT_SPACE
9310     if (commaNeeded)
9311         _OUT << "}," << std::endl;
9312     else
9313         _OUT << "}" << std::endl;
9314 }
9315 
print_VkPhysicalDeviceProperties(VkPhysicalDeviceProperties obj,const std::string & s,bool commaNeeded=true)9316 static void print_VkPhysicalDeviceProperties(VkPhysicalDeviceProperties obj, const std::string &s,
9317                                              bool commaNeeded = true)
9318 {
9319     PRINT_SPACE
9320     _OUT << "{" << std::endl;
9321     INDENT(4);
9322 
9323     print_uint32_t(obj.apiVersion, "apiVersion", 1);
9324 
9325     print_uint32_t(obj.driverVersion, "driverVersion", 1);
9326 
9327     print_uint32_t(obj.vendorID, "vendorID", 1);
9328 
9329     print_uint32_t(obj.deviceID, "deviceID", 1);
9330 
9331     print_VkPhysicalDeviceType(obj.deviceType, "deviceType", 1);
9332 
9333     PRINT_SPACE
9334     _OUT << "\"deviceName\":" << std::endl;
9335     PRINT_SPACE
9336     _OUT << "[" << std::endl;
9337     for (unsigned int i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; i++)
9338     {
9339         bool isCommaNeeded = (i + 1) != VK_MAX_PHYSICAL_DEVICE_NAME_SIZE;
9340         print_char(obj.deviceName[i], "", isCommaNeeded);
9341     }
9342     PRINT_SPACE
9343     _OUT << "]"
9344          << "," << std::endl;
9345 
9346     PRINT_SPACE
9347     _OUT << "\"pipelineCacheUUID\":" << std::endl;
9348     PRINT_SPACE
9349     _OUT << "[" << std::endl;
9350     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
9351     {
9352         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
9353         print_uint8_t(obj.pipelineCacheUUID[i], "", isCommaNeeded);
9354     }
9355     PRINT_SPACE
9356     _OUT << "]"
9357          << "," << std::endl;
9358 
9359     PRINT_SPACE
9360     _OUT << "\"limits\": " << std::endl;
9361     {
9362         print_VkPhysicalDeviceLimits(obj.limits, "limits", 1);
9363     }
9364 
9365     PRINT_SPACE
9366     _OUT << "\"sparseProperties\": " << std::endl;
9367     {
9368         print_VkPhysicalDeviceSparseProperties(obj.sparseProperties, "sparseProperties", 0);
9369     }
9370 
9371     INDENT(-4);
9372     PRINT_SPACE
9373     if (commaNeeded)
9374         _OUT << "}," << std::endl;
9375     else
9376         _OUT << "}" << std::endl;
9377 }
print_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties * obj,const std::string & s,bool commaNeeded=true)9378 static void print_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties *obj, const std::string &s,
9379                                              bool commaNeeded = true)
9380 {
9381     PRINT_SPACE
9382     _OUT << "{" << std::endl;
9383     INDENT(4);
9384 
9385     print_uint32_t(obj->apiVersion, "apiVersion", 1);
9386 
9387     print_uint32_t(obj->driverVersion, "driverVersion", 1);
9388 
9389     print_uint32_t(obj->vendorID, "vendorID", 1);
9390 
9391     print_uint32_t(obj->deviceID, "deviceID", 1);
9392 
9393     print_VkPhysicalDeviceType(obj->deviceType, "deviceType", 1);
9394 
9395     PRINT_SPACE
9396     _OUT << "\"deviceName\":" << std::endl;
9397     PRINT_SPACE
9398     _OUT << "[" << std::endl;
9399     for (unsigned int i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; i++)
9400     {
9401         bool isCommaNeeded = (i + 1) != VK_MAX_PHYSICAL_DEVICE_NAME_SIZE;
9402         print_char(obj->deviceName[i], "", isCommaNeeded);
9403     }
9404     PRINT_SPACE
9405     _OUT << "]"
9406          << "," << std::endl;
9407 
9408     PRINT_SPACE
9409     _OUT << "\"pipelineCacheUUID\":" << std::endl;
9410     PRINT_SPACE
9411     _OUT << "[" << std::endl;
9412     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
9413     {
9414         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
9415         print_uint8_t(obj->pipelineCacheUUID[i], "", isCommaNeeded);
9416     }
9417     PRINT_SPACE
9418     _OUT << "]"
9419          << "," << std::endl;
9420 
9421     PRINT_SPACE
9422     _OUT << "\"limits\": " << std::endl;
9423     {
9424         print_VkPhysicalDeviceLimits(obj->limits, "limits", 1);
9425     }
9426 
9427     PRINT_SPACE
9428     _OUT << "\"sparseProperties\": " << std::endl;
9429     {
9430         print_VkPhysicalDeviceSparseProperties(obj->sparseProperties, "sparseProperties", 0);
9431     }
9432 
9433     INDENT(-4);
9434     PRINT_SPACE
9435     if (commaNeeded)
9436         _OUT << "}," << std::endl;
9437     else
9438         _OUT << "}" << std::endl;
9439 }
9440 
print_VkQueueFamilyProperties(VkQueueFamilyProperties obj,const std::string & s,bool commaNeeded=true)9441 static void print_VkQueueFamilyProperties(VkQueueFamilyProperties obj, const std::string &s, bool commaNeeded = true)
9442 {
9443     PRINT_SPACE
9444     _OUT << "{" << std::endl;
9445     INDENT(4);
9446 
9447     print_VkQueueFlags(obj.queueFlags, "queueFlags", 1);
9448 
9449     print_uint32_t(obj.queueCount, "queueCount", 1);
9450 
9451     print_uint32_t(obj.timestampValidBits, "timestampValidBits", 1);
9452 
9453     PRINT_SPACE
9454     _OUT << "\"minImageTransferGranularity\": " << std::endl;
9455     {
9456         print_VkExtent3D(obj.minImageTransferGranularity, "minImageTransferGranularity", 0);
9457     }
9458 
9459     INDENT(-4);
9460     PRINT_SPACE
9461     if (commaNeeded)
9462         _OUT << "}," << std::endl;
9463     else
9464         _OUT << "}" << std::endl;
9465 }
print_VkQueueFamilyProperties(const VkQueueFamilyProperties * obj,const std::string & s,bool commaNeeded=true)9466 static void print_VkQueueFamilyProperties(const VkQueueFamilyProperties *obj, const std::string &s,
9467                                           bool commaNeeded = true)
9468 {
9469     PRINT_SPACE
9470     _OUT << "{" << std::endl;
9471     INDENT(4);
9472 
9473     print_VkQueueFlags(obj->queueFlags, "queueFlags", 1);
9474 
9475     print_uint32_t(obj->queueCount, "queueCount", 1);
9476 
9477     print_uint32_t(obj->timestampValidBits, "timestampValidBits", 1);
9478 
9479     PRINT_SPACE
9480     _OUT << "\"minImageTransferGranularity\": " << std::endl;
9481     {
9482         print_VkExtent3D(obj->minImageTransferGranularity, "minImageTransferGranularity", 0);
9483     }
9484 
9485     INDENT(-4);
9486     PRINT_SPACE
9487     if (commaNeeded)
9488         _OUT << "}," << std::endl;
9489     else
9490         _OUT << "}" << std::endl;
9491 }
9492 
print_VkDeviceQueueCreateInfo(VkDeviceQueueCreateInfo obj,const std::string & s,bool commaNeeded=true)9493 static void print_VkDeviceQueueCreateInfo(VkDeviceQueueCreateInfo obj, const std::string &s, bool commaNeeded = true)
9494 {
9495     PRINT_SPACE
9496     _OUT << "{" << std::endl;
9497     INDENT(4);
9498 
9499     print_VkStructureType(obj.sType, "sType", 1);
9500 
9501     if (obj.pNext)
9502     {
9503         dumpPNextChain(obj.pNext);
9504     }
9505     else
9506     {
9507         PRINT_SPACE
9508         _OUT << "\"pNext\":"
9509              << "\"NULL\""
9510              << "," << std::endl;
9511     }
9512 
9513     print_VkDeviceQueueCreateFlags(obj.flags, "flags", 1);
9514 
9515     print_uint32_t(obj.queueFamilyIndex, "queueFamilyIndex", 1);
9516 
9517     print_uint32_t(obj.queueCount, "queueCount", 1);
9518 
9519     PRINT_SPACE
9520     _OUT << "\"pQueuePriorities\":" << std::endl;
9521     PRINT_SPACE
9522     if (obj.pQueuePriorities)
9523     {
9524         _OUT << "[" << std::endl;
9525         for (unsigned int i = 0; i < obj.queueCount; i++)
9526         {
9527             bool isCommaNeeded = (i + 1) != obj.queueCount;
9528             print_float(obj.pQueuePriorities[i], "", isCommaNeeded);
9529         }
9530         PRINT_SPACE
9531         _OUT << "]"
9532              << "" << std::endl;
9533     }
9534     else
9535     {
9536         _OUT << "\"NULL\""
9537              << "" << std::endl;
9538     }
9539 
9540     INDENT(-4);
9541     PRINT_SPACE
9542     if (commaNeeded)
9543         _OUT << "}," << std::endl;
9544     else
9545         _OUT << "}" << std::endl;
9546 }
print_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo * obj,const std::string & s,bool commaNeeded=true)9547 static void print_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo *obj, const std::string &s,
9548                                           bool commaNeeded = true)
9549 {
9550     PRINT_SPACE
9551     _OUT << "{" << std::endl;
9552     INDENT(4);
9553 
9554     print_VkStructureType(obj->sType, "sType", 1);
9555 
9556     if (obj->pNext)
9557     {
9558         dumpPNextChain(obj->pNext);
9559     }
9560     else
9561     {
9562         PRINT_SPACE
9563         _OUT << "\"pNext\":"
9564              << "\"NULL\""
9565              << "," << std::endl;
9566     }
9567 
9568     print_VkDeviceQueueCreateFlags(obj->flags, "flags", 1);
9569 
9570     print_uint32_t(obj->queueFamilyIndex, "queueFamilyIndex", 1);
9571 
9572     print_uint32_t(obj->queueCount, "queueCount", 1);
9573 
9574     PRINT_SPACE
9575     _OUT << "\"pQueuePriorities\":" << std::endl;
9576     PRINT_SPACE
9577     if (obj->pQueuePriorities)
9578     {
9579         _OUT << "[" << std::endl;
9580         for (unsigned int i = 0; i < obj->queueCount; i++)
9581         {
9582             bool isCommaNeeded = (i + 1) != obj->queueCount;
9583             print_float(obj->pQueuePriorities[i], "", isCommaNeeded);
9584         }
9585         PRINT_SPACE
9586         _OUT << "]"
9587              << "" << std::endl;
9588     }
9589     else
9590     {
9591         _OUT << "\"NULL\""
9592              << "" << std::endl;
9593     }
9594 
9595     INDENT(-4);
9596     PRINT_SPACE
9597     if (commaNeeded)
9598         _OUT << "}," << std::endl;
9599     else
9600         _OUT << "}" << std::endl;
9601 }
9602 
print_VkDeviceCreateInfo(VkDeviceCreateInfo obj,const std::string & s,bool commaNeeded=true)9603 static void print_VkDeviceCreateInfo(VkDeviceCreateInfo obj, const std::string &s, bool commaNeeded = true)
9604 {
9605     PRINT_SPACE
9606     _OUT << "{" << std::endl;
9607     INDENT(4);
9608 
9609     print_VkStructureType(obj.sType, "sType", 1);
9610 
9611     if (obj.pNext)
9612     {
9613         dumpPNextChain(obj.pNext);
9614     }
9615     else
9616     {
9617         PRINT_SPACE
9618         _OUT << "\"pNext\":"
9619              << "\"NULL\""
9620              << "," << std::endl;
9621     }
9622 
9623     print_VkDeviceCreateFlags(obj.flags, "flags", 1);
9624 
9625     print_uint32_t(obj.queueCreateInfoCount, "queueCreateInfoCount", 1);
9626 
9627     PRINT_SPACE
9628     _OUT << "\"pQueueCreateInfos\": " << std::endl;
9629     if (obj.pQueueCreateInfos)
9630     {
9631         PRINT_SPACE
9632         _OUT << "[" << std::endl;
9633         for (unsigned int i = 0; i < obj.queueCreateInfoCount; i++)
9634         {
9635             if (i + 1 == obj.queueCreateInfoCount)
9636                 print_VkDeviceQueueCreateInfo(obj.pQueueCreateInfos[i], "pQueueCreateInfos", 0);
9637             else
9638                 print_VkDeviceQueueCreateInfo(obj.pQueueCreateInfos[i], "pQueueCreateInfos", 1);
9639         }
9640         PRINT_SPACE
9641         _OUT << "]," << std::endl;
9642     }
9643     else
9644     {
9645         PRINT_SPACE _OUT << "\"NULL\""
9646                          << "," << std::endl;
9647     }
9648 
9649     print_uint32_t(obj.enabledLayerCount, "enabledLayerCount", 1);
9650 
9651     print_char(obj.ppEnabledLayerNames, "ppEnabledLayerNames", 1);
9652 
9653     print_uint32_t(obj.enabledExtensionCount, "enabledExtensionCount", 1);
9654 
9655     print_char(obj.ppEnabledExtensionNames, "ppEnabledExtensionNames", 1);
9656 
9657     PRINT_SPACE
9658     _OUT << "\"pEnabledFeatures\": " << std::endl;
9659     if (obj.pEnabledFeatures)
9660     {
9661         print_VkPhysicalDeviceFeatures(obj.pEnabledFeatures, "pEnabledFeatures", 0);
9662     }
9663     else
9664     {
9665         PRINT_SPACE _OUT << "\"NULL\""
9666                          << "" << std::endl;
9667     }
9668 
9669     INDENT(-4);
9670     PRINT_SPACE
9671     if (commaNeeded)
9672         _OUT << "}," << std::endl;
9673     else
9674         _OUT << "}" << std::endl;
9675 }
print_VkDeviceCreateInfo(const VkDeviceCreateInfo * obj,const std::string & s,bool commaNeeded=true)9676 static void print_VkDeviceCreateInfo(const VkDeviceCreateInfo *obj, const std::string &s, bool commaNeeded = true)
9677 {
9678     PRINT_SPACE
9679     _OUT << "{" << std::endl;
9680     INDENT(4);
9681 
9682     print_VkStructureType(obj->sType, "sType", 1);
9683 
9684     if (obj->pNext)
9685     {
9686         dumpPNextChain(obj->pNext);
9687     }
9688     else
9689     {
9690         PRINT_SPACE
9691         _OUT << "\"pNext\":"
9692              << "\"NULL\""
9693              << "," << std::endl;
9694     }
9695 
9696     print_VkDeviceCreateFlags(obj->flags, "flags", 1);
9697 
9698     print_uint32_t(obj->queueCreateInfoCount, "queueCreateInfoCount", 1);
9699 
9700     PRINT_SPACE
9701     _OUT << "\"pQueueCreateInfos\": " << std::endl;
9702     if (obj->pQueueCreateInfos)
9703     {
9704         PRINT_SPACE
9705         _OUT << "[" << std::endl;
9706         for (unsigned int i = 0; i < obj->queueCreateInfoCount; i++)
9707         {
9708             if (i + 1 == obj->queueCreateInfoCount)
9709                 print_VkDeviceQueueCreateInfo(obj->pQueueCreateInfos[i], "pQueueCreateInfos", 0);
9710             else
9711                 print_VkDeviceQueueCreateInfo(obj->pQueueCreateInfos[i], "pQueueCreateInfos", 1);
9712         }
9713         PRINT_SPACE
9714         _OUT << "]," << std::endl;
9715     }
9716     else
9717     {
9718         PRINT_SPACE _OUT << "\"NULL\""
9719                          << "," << std::endl;
9720     }
9721 
9722     print_uint32_t(obj->enabledLayerCount, "enabledLayerCount", 1);
9723 
9724     print_char(obj->ppEnabledLayerNames, "ppEnabledLayerNames", 1);
9725 
9726     print_uint32_t(obj->enabledExtensionCount, "enabledExtensionCount", 1);
9727 
9728     print_char(obj->ppEnabledExtensionNames, "ppEnabledExtensionNames", 1);
9729 
9730     PRINT_SPACE
9731     _OUT << "\"pEnabledFeatures\": " << std::endl;
9732     if (obj->pEnabledFeatures)
9733     {
9734         print_VkPhysicalDeviceFeatures(obj->pEnabledFeatures, "pEnabledFeatures", 0);
9735     }
9736     else
9737     {
9738         PRINT_SPACE _OUT << "\"NULL\""
9739                          << "" << std::endl;
9740     }
9741 
9742     INDENT(-4);
9743     PRINT_SPACE
9744     if (commaNeeded)
9745         _OUT << "}," << std::endl;
9746     else
9747         _OUT << "}" << std::endl;
9748 }
9749 
print_VkExtensionProperties(VkExtensionProperties obj,const std::string & s,bool commaNeeded=true)9750 static void print_VkExtensionProperties(VkExtensionProperties obj, const std::string &s, bool commaNeeded = true)
9751 {
9752     PRINT_SPACE
9753     _OUT << "{" << std::endl;
9754     INDENT(4);
9755 
9756     PRINT_SPACE
9757     _OUT << "\"extensionName\":" << std::endl;
9758     PRINT_SPACE
9759     _OUT << "[" << std::endl;
9760     for (unsigned int i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++)
9761     {
9762         bool isCommaNeeded = (i + 1) != VK_MAX_EXTENSION_NAME_SIZE;
9763         print_char(obj.extensionName[i], "", isCommaNeeded);
9764     }
9765     PRINT_SPACE
9766     _OUT << "]"
9767          << "," << std::endl;
9768 
9769     print_uint32_t(obj.specVersion, "specVersion", 0);
9770 
9771     INDENT(-4);
9772     PRINT_SPACE
9773     if (commaNeeded)
9774         _OUT << "}," << std::endl;
9775     else
9776         _OUT << "}" << std::endl;
9777 }
print_VkExtensionProperties(const VkExtensionProperties * obj,const std::string & s,bool commaNeeded=true)9778 static void print_VkExtensionProperties(const VkExtensionProperties *obj, const std::string &s, bool commaNeeded = true)
9779 {
9780     PRINT_SPACE
9781     _OUT << "{" << std::endl;
9782     INDENT(4);
9783 
9784     PRINT_SPACE
9785     _OUT << "\"extensionName\":" << std::endl;
9786     PRINT_SPACE
9787     _OUT << "[" << std::endl;
9788     for (unsigned int i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++)
9789     {
9790         bool isCommaNeeded = (i + 1) != VK_MAX_EXTENSION_NAME_SIZE;
9791         print_char(obj->extensionName[i], "", isCommaNeeded);
9792     }
9793     PRINT_SPACE
9794     _OUT << "]"
9795          << "," << std::endl;
9796 
9797     print_uint32_t(obj->specVersion, "specVersion", 0);
9798 
9799     INDENT(-4);
9800     PRINT_SPACE
9801     if (commaNeeded)
9802         _OUT << "}," << std::endl;
9803     else
9804         _OUT << "}" << std::endl;
9805 }
9806 
print_VkLayerProperties(VkLayerProperties obj,const std::string & s,bool commaNeeded=true)9807 static void print_VkLayerProperties(VkLayerProperties obj, const std::string &s, bool commaNeeded = true)
9808 {
9809     PRINT_SPACE
9810     _OUT << "{" << std::endl;
9811     INDENT(4);
9812 
9813     PRINT_SPACE
9814     _OUT << "\"layerName\":" << std::endl;
9815     PRINT_SPACE
9816     _OUT << "[" << std::endl;
9817     for (unsigned int i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++)
9818     {
9819         bool isCommaNeeded = (i + 1) != VK_MAX_EXTENSION_NAME_SIZE;
9820         print_char(obj.layerName[i], "", isCommaNeeded);
9821     }
9822     PRINT_SPACE
9823     _OUT << "]"
9824          << "," << std::endl;
9825 
9826     print_uint32_t(obj.specVersion, "specVersion", 1);
9827 
9828     print_uint32_t(obj.implementationVersion, "implementationVersion", 1);
9829 
9830     PRINT_SPACE
9831     _OUT << "\"description\":" << std::endl;
9832     PRINT_SPACE
9833     _OUT << "[" << std::endl;
9834     for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++)
9835     {
9836         bool isCommaNeeded = (i + 1) != VK_MAX_DESCRIPTION_SIZE;
9837         print_char(obj.description[i], "", isCommaNeeded);
9838     }
9839     PRINT_SPACE
9840     _OUT << "]"
9841          << "" << std::endl;
9842 
9843     INDENT(-4);
9844     PRINT_SPACE
9845     if (commaNeeded)
9846         _OUT << "}," << std::endl;
9847     else
9848         _OUT << "}" << std::endl;
9849 }
print_VkLayerProperties(const VkLayerProperties * obj,const std::string & s,bool commaNeeded=true)9850 static void print_VkLayerProperties(const VkLayerProperties *obj, const std::string &s, bool commaNeeded = true)
9851 {
9852     PRINT_SPACE
9853     _OUT << "{" << std::endl;
9854     INDENT(4);
9855 
9856     PRINT_SPACE
9857     _OUT << "\"layerName\":" << std::endl;
9858     PRINT_SPACE
9859     _OUT << "[" << std::endl;
9860     for (unsigned int i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++)
9861     {
9862         bool isCommaNeeded = (i + 1) != VK_MAX_EXTENSION_NAME_SIZE;
9863         print_char(obj->layerName[i], "", isCommaNeeded);
9864     }
9865     PRINT_SPACE
9866     _OUT << "]"
9867          << "," << std::endl;
9868 
9869     print_uint32_t(obj->specVersion, "specVersion", 1);
9870 
9871     print_uint32_t(obj->implementationVersion, "implementationVersion", 1);
9872 
9873     PRINT_SPACE
9874     _OUT << "\"description\":" << std::endl;
9875     PRINT_SPACE
9876     _OUT << "[" << std::endl;
9877     for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++)
9878     {
9879         bool isCommaNeeded = (i + 1) != VK_MAX_DESCRIPTION_SIZE;
9880         print_char(obj->description[i], "", isCommaNeeded);
9881     }
9882     PRINT_SPACE
9883     _OUT << "]"
9884          << "" << std::endl;
9885 
9886     INDENT(-4);
9887     PRINT_SPACE
9888     if (commaNeeded)
9889         _OUT << "}," << std::endl;
9890     else
9891         _OUT << "}" << std::endl;
9892 }
9893 
print_VkSubmitInfo(VkSubmitInfo obj,const std::string & s,bool commaNeeded=true)9894 static void print_VkSubmitInfo(VkSubmitInfo obj, const std::string &s, bool commaNeeded = true)
9895 {
9896     PRINT_SPACE
9897     _OUT << "{" << std::endl;
9898     INDENT(4);
9899 
9900     print_VkStructureType(obj.sType, "sType", 1);
9901 
9902     if (obj.pNext)
9903     {
9904         dumpPNextChain(obj.pNext);
9905     }
9906     else
9907     {
9908         PRINT_SPACE
9909         _OUT << "\"pNext\":"
9910              << "\"NULL\""
9911              << "," << std::endl;
9912     }
9913 
9914     print_uint32_t(obj.waitSemaphoreCount, "waitSemaphoreCount", 1);
9915 
9916     PRINT_SPACE
9917     _OUT << "\"pWaitSemaphores\":" << std::endl;
9918     PRINT_SPACE
9919     if (obj.pWaitSemaphores)
9920     {
9921         _OUT << "[" << std::endl;
9922         for (unsigned int i = 0; i < obj.waitSemaphoreCount; i++)
9923         {
9924             std::stringstream tmp;
9925             tmp << "pWaitSemaphores"
9926                 << "_" << i;
9927             bool isCommaNeeded = (i + 1) != obj.waitSemaphoreCount;
9928             print_VkSemaphore(obj.pWaitSemaphores[i], tmp.str(), isCommaNeeded);
9929         }
9930         PRINT_SPACE
9931         _OUT << "]"
9932              << "," << std::endl;
9933     }
9934     else
9935     {
9936         _OUT << "\"NULL\""
9937              << "," << std::endl;
9938     }
9939 
9940     PRINT_SPACE
9941     _OUT << "\"pWaitDstStageMask\":" << std::endl;
9942     PRINT_SPACE
9943     if (obj.pWaitDstStageMask)
9944     {
9945         _OUT << "[" << std::endl;
9946         for (unsigned int i = 0; i < obj.waitSemaphoreCount; i++)
9947         {
9948             bool isCommaNeeded = (i + 1) != obj.waitSemaphoreCount;
9949             print_VkPipelineStageFlags(obj.pWaitDstStageMask[i], "", isCommaNeeded);
9950         }
9951         PRINT_SPACE
9952         _OUT << "]"
9953              << "," << std::endl;
9954     }
9955     else
9956     {
9957         _OUT << "\"NULL\""
9958              << "," << std::endl;
9959     }
9960 
9961     print_uint32_t(obj.commandBufferCount, "commandBufferCount", 1);
9962 
9963     PRINT_SPACE
9964     _OUT << "\"pCommandBuffers\":" << std::endl;
9965     PRINT_SPACE
9966     if (obj.pCommandBuffers)
9967     {
9968         _OUT << "[" << std::endl;
9969         for (unsigned int i = 0; i < obj.commandBufferCount; i++)
9970         {
9971             std::stringstream tmp;
9972             tmp << "pCommandBuffers"
9973                 << "_" << i;
9974             bool isCommaNeeded = (i + 1) != obj.commandBufferCount;
9975             print_VkCommandBuffer(obj.pCommandBuffers[i], tmp.str(), isCommaNeeded);
9976         }
9977         PRINT_SPACE
9978         _OUT << "]"
9979              << "," << std::endl;
9980     }
9981     else
9982     {
9983         _OUT << "\"NULL\""
9984              << "," << std::endl;
9985     }
9986 
9987     print_uint32_t(obj.signalSemaphoreCount, "signalSemaphoreCount", 1);
9988 
9989     PRINT_SPACE
9990     _OUT << "\"pSignalSemaphores\":" << std::endl;
9991     PRINT_SPACE
9992     if (obj.pSignalSemaphores)
9993     {
9994         _OUT << "[" << std::endl;
9995         for (unsigned int i = 0; i < obj.signalSemaphoreCount; i++)
9996         {
9997             std::stringstream tmp;
9998             tmp << "pSignalSemaphores"
9999                 << "_" << i;
10000             bool isCommaNeeded = (i + 1) != obj.signalSemaphoreCount;
10001             print_VkSemaphore(obj.pSignalSemaphores[i], tmp.str(), isCommaNeeded);
10002         }
10003         PRINT_SPACE
10004         _OUT << "]"
10005              << "" << std::endl;
10006     }
10007     else
10008     {
10009         _OUT << "\"NULL\""
10010              << "" << std::endl;
10011     }
10012 
10013     INDENT(-4);
10014     PRINT_SPACE
10015     if (commaNeeded)
10016         _OUT << "}," << std::endl;
10017     else
10018         _OUT << "}" << std::endl;
10019 }
print_VkSubmitInfo(const VkSubmitInfo * obj,const std::string & s,bool commaNeeded=true)10020 static void print_VkSubmitInfo(const VkSubmitInfo *obj, const std::string &s, bool commaNeeded = true)
10021 {
10022     PRINT_SPACE
10023     _OUT << "{" << std::endl;
10024     INDENT(4);
10025 
10026     print_VkStructureType(obj->sType, "sType", 1);
10027 
10028     if (obj->pNext)
10029     {
10030         dumpPNextChain(obj->pNext);
10031     }
10032     else
10033     {
10034         PRINT_SPACE
10035         _OUT << "\"pNext\":"
10036              << "\"NULL\""
10037              << "," << std::endl;
10038     }
10039 
10040     print_uint32_t(obj->waitSemaphoreCount, "waitSemaphoreCount", 1);
10041 
10042     PRINT_SPACE
10043     _OUT << "\"pWaitSemaphores\":" << std::endl;
10044     PRINT_SPACE
10045     if (obj->pWaitSemaphores)
10046     {
10047         _OUT << "[" << std::endl;
10048         for (unsigned int i = 0; i < obj->waitSemaphoreCount; i++)
10049         {
10050             std::stringstream tmp;
10051             tmp << "pWaitSemaphores"
10052                 << "_" << i;
10053             bool isCommaNeeded = (i + 1) != obj->waitSemaphoreCount;
10054             print_VkSemaphore(obj->pWaitSemaphores[i], tmp.str(), isCommaNeeded);
10055         }
10056         PRINT_SPACE
10057         _OUT << "]"
10058              << "," << std::endl;
10059     }
10060     else
10061     {
10062         _OUT << "\"NULL\""
10063              << "," << std::endl;
10064     }
10065 
10066     PRINT_SPACE
10067     _OUT << "\"pWaitDstStageMask\":" << std::endl;
10068     PRINT_SPACE
10069     if (obj->pWaitDstStageMask)
10070     {
10071         _OUT << "[" << std::endl;
10072         for (unsigned int i = 0; i < obj->waitSemaphoreCount; i++)
10073         {
10074             bool isCommaNeeded = (i + 1) != obj->waitSemaphoreCount;
10075             print_VkPipelineStageFlags(obj->pWaitDstStageMask[i], "", isCommaNeeded);
10076         }
10077         PRINT_SPACE
10078         _OUT << "]"
10079              << "," << std::endl;
10080     }
10081     else
10082     {
10083         _OUT << "\"NULL\""
10084              << "," << std::endl;
10085     }
10086 
10087     print_uint32_t(obj->commandBufferCount, "commandBufferCount", 1);
10088 
10089     PRINT_SPACE
10090     _OUT << "\"pCommandBuffers\":" << std::endl;
10091     PRINT_SPACE
10092     if (obj->pCommandBuffers)
10093     {
10094         _OUT << "[" << std::endl;
10095         for (unsigned int i = 0; i < obj->commandBufferCount; i++)
10096         {
10097             std::stringstream tmp;
10098             tmp << "pCommandBuffers"
10099                 << "_" << i;
10100             bool isCommaNeeded = (i + 1) != obj->commandBufferCount;
10101             print_VkCommandBuffer(obj->pCommandBuffers[i], tmp.str(), isCommaNeeded);
10102         }
10103         PRINT_SPACE
10104         _OUT << "]"
10105              << "," << std::endl;
10106     }
10107     else
10108     {
10109         _OUT << "\"NULL\""
10110              << "," << std::endl;
10111     }
10112 
10113     print_uint32_t(obj->signalSemaphoreCount, "signalSemaphoreCount", 1);
10114 
10115     PRINT_SPACE
10116     _OUT << "\"pSignalSemaphores\":" << std::endl;
10117     PRINT_SPACE
10118     if (obj->pSignalSemaphores)
10119     {
10120         _OUT << "[" << std::endl;
10121         for (unsigned int i = 0; i < obj->signalSemaphoreCount; i++)
10122         {
10123             std::stringstream tmp;
10124             tmp << "pSignalSemaphores"
10125                 << "_" << i;
10126             bool isCommaNeeded = (i + 1) != obj->signalSemaphoreCount;
10127             print_VkSemaphore(obj->pSignalSemaphores[i], tmp.str(), isCommaNeeded);
10128         }
10129         PRINT_SPACE
10130         _OUT << "]"
10131              << "" << std::endl;
10132     }
10133     else
10134     {
10135         _OUT << "\"NULL\""
10136              << "" << std::endl;
10137     }
10138 
10139     INDENT(-4);
10140     PRINT_SPACE
10141     if (commaNeeded)
10142         _OUT << "}," << std::endl;
10143     else
10144         _OUT << "}" << std::endl;
10145 }
10146 
print_VkMappedMemoryRange(VkMappedMemoryRange obj,const std::string & s,bool commaNeeded=true)10147 static void print_VkMappedMemoryRange(VkMappedMemoryRange obj, const std::string &s, bool commaNeeded = true)
10148 {
10149     PRINT_SPACE
10150     _OUT << "{" << std::endl;
10151     INDENT(4);
10152 
10153     print_VkStructureType(obj.sType, "sType", 1);
10154 
10155     if (obj.pNext)
10156     {
10157         dumpPNextChain(obj.pNext);
10158     }
10159     else
10160     {
10161         PRINT_SPACE
10162         _OUT << "\"pNext\":"
10163              << "\"NULL\""
10164              << "," << std::endl;
10165     }
10166 
10167     // CTS : required value
10168     PRINT_SPACE _OUT << "\""
10169                      << "memory"
10170                      << "\""
10171                      << " : "
10172                      << "\""
10173                      << "\"," << std::endl;
10174 
10175     print_VkDeviceSize(obj.offset, "offset", 1);
10176 
10177     print_VkDeviceSize(obj.size, "size", 0);
10178 
10179     INDENT(-4);
10180     PRINT_SPACE
10181     if (commaNeeded)
10182         _OUT << "}," << std::endl;
10183     else
10184         _OUT << "}" << std::endl;
10185 }
print_VkMappedMemoryRange(const VkMappedMemoryRange * obj,const std::string & s,bool commaNeeded=true)10186 static void print_VkMappedMemoryRange(const VkMappedMemoryRange *obj, const std::string &s, bool commaNeeded = true)
10187 {
10188     PRINT_SPACE
10189     _OUT << "{" << std::endl;
10190     INDENT(4);
10191 
10192     print_VkStructureType(obj->sType, "sType", 1);
10193 
10194     if (obj->pNext)
10195     {
10196         dumpPNextChain(obj->pNext);
10197     }
10198     else
10199     {
10200         PRINT_SPACE
10201         _OUT << "\"pNext\":"
10202              << "\"NULL\""
10203              << "," << std::endl;
10204     }
10205 
10206     // CTS : required value
10207     PRINT_SPACE _OUT << "\""
10208                      << "memory"
10209                      << "\""
10210                      << " : "
10211                      << "\""
10212                      << "\"," << std::endl;
10213 
10214     print_VkDeviceSize(obj->offset, "offset", 1);
10215 
10216     print_VkDeviceSize(obj->size, "size", 0);
10217 
10218     INDENT(-4);
10219     PRINT_SPACE
10220     if (commaNeeded)
10221         _OUT << "}," << std::endl;
10222     else
10223         _OUT << "}" << std::endl;
10224 }
10225 
print_VkMemoryAllocateInfo(VkMemoryAllocateInfo obj,const std::string & s,bool commaNeeded=true)10226 static void print_VkMemoryAllocateInfo(VkMemoryAllocateInfo obj, const std::string &s, bool commaNeeded = true)
10227 {
10228     PRINT_SPACE
10229     _OUT << "{" << std::endl;
10230     INDENT(4);
10231 
10232     print_VkStructureType(obj.sType, "sType", 1);
10233 
10234     if (obj.pNext)
10235     {
10236         dumpPNextChain(obj.pNext);
10237     }
10238     else
10239     {
10240         PRINT_SPACE
10241         _OUT << "\"pNext\":"
10242              << "\"NULL\""
10243              << "," << std::endl;
10244     }
10245 
10246     print_VkDeviceSize(obj.allocationSize, "allocationSize", 1);
10247 
10248     print_uint32_t(obj.memoryTypeIndex, "memoryTypeIndex", 0);
10249 
10250     INDENT(-4);
10251     PRINT_SPACE
10252     if (commaNeeded)
10253         _OUT << "}," << std::endl;
10254     else
10255         _OUT << "}" << std::endl;
10256 }
print_VkMemoryAllocateInfo(const VkMemoryAllocateInfo * obj,const std::string & s,bool commaNeeded=true)10257 static void print_VkMemoryAllocateInfo(const VkMemoryAllocateInfo *obj, const std::string &s, bool commaNeeded = true)
10258 {
10259     PRINT_SPACE
10260     _OUT << "{" << std::endl;
10261     INDENT(4);
10262 
10263     print_VkStructureType(obj->sType, "sType", 1);
10264 
10265     if (obj->pNext)
10266     {
10267         dumpPNextChain(obj->pNext);
10268     }
10269     else
10270     {
10271         PRINT_SPACE
10272         _OUT << "\"pNext\":"
10273              << "\"NULL\""
10274              << "," << std::endl;
10275     }
10276 
10277     print_VkDeviceSize(obj->allocationSize, "allocationSize", 1);
10278 
10279     print_uint32_t(obj->memoryTypeIndex, "memoryTypeIndex", 0);
10280 
10281     INDENT(-4);
10282     PRINT_SPACE
10283     if (commaNeeded)
10284         _OUT << "}," << std::endl;
10285     else
10286         _OUT << "}" << std::endl;
10287 }
10288 
print_VkMemoryRequirements(VkMemoryRequirements obj,const std::string & s,bool commaNeeded=true)10289 static void print_VkMemoryRequirements(VkMemoryRequirements obj, const std::string &s, bool commaNeeded = true)
10290 {
10291     PRINT_SPACE
10292     _OUT << "{" << std::endl;
10293     INDENT(4);
10294 
10295     print_VkDeviceSize(obj.size, "size", 1);
10296 
10297     print_VkDeviceSize(obj.alignment, "alignment", 1);
10298 
10299     print_uint32_t(obj.memoryTypeBits, "memoryTypeBits", 0);
10300 
10301     INDENT(-4);
10302     PRINT_SPACE
10303     if (commaNeeded)
10304         _OUT << "}," << std::endl;
10305     else
10306         _OUT << "}" << std::endl;
10307 }
print_VkMemoryRequirements(const VkMemoryRequirements * obj,const std::string & s,bool commaNeeded=true)10308 static void print_VkMemoryRequirements(const VkMemoryRequirements *obj, const std::string &s, bool commaNeeded = true)
10309 {
10310     PRINT_SPACE
10311     _OUT << "{" << std::endl;
10312     INDENT(4);
10313 
10314     print_VkDeviceSize(obj->size, "size", 1);
10315 
10316     print_VkDeviceSize(obj->alignment, "alignment", 1);
10317 
10318     print_uint32_t(obj->memoryTypeBits, "memoryTypeBits", 0);
10319 
10320     INDENT(-4);
10321     PRINT_SPACE
10322     if (commaNeeded)
10323         _OUT << "}," << std::endl;
10324     else
10325         _OUT << "}" << std::endl;
10326 }
10327 
print_VkImageSubresource(VkImageSubresource obj,const std::string & s,bool commaNeeded=true)10328 static void print_VkImageSubresource(VkImageSubresource obj, const std::string &s, bool commaNeeded = true)
10329 {
10330     PRINT_SPACE
10331     _OUT << "{" << std::endl;
10332     INDENT(4);
10333 
10334     print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 1);
10335 
10336     print_uint32_t(obj.mipLevel, "mipLevel", 1);
10337 
10338     print_uint32_t(obj.arrayLayer, "arrayLayer", 0);
10339 
10340     INDENT(-4);
10341     PRINT_SPACE
10342     if (commaNeeded)
10343         _OUT << "}," << std::endl;
10344     else
10345         _OUT << "}" << std::endl;
10346 }
print_VkImageSubresource(const VkImageSubresource * obj,const std::string & s,bool commaNeeded=true)10347 static void print_VkImageSubresource(const VkImageSubresource *obj, const std::string &s, bool commaNeeded = true)
10348 {
10349     PRINT_SPACE
10350     _OUT << "{" << std::endl;
10351     INDENT(4);
10352 
10353     print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 1);
10354 
10355     print_uint32_t(obj->mipLevel, "mipLevel", 1);
10356 
10357     print_uint32_t(obj->arrayLayer, "arrayLayer", 0);
10358 
10359     INDENT(-4);
10360     PRINT_SPACE
10361     if (commaNeeded)
10362         _OUT << "}," << std::endl;
10363     else
10364         _OUT << "}" << std::endl;
10365 }
10366 
print_VkFenceCreateInfo(VkFenceCreateInfo obj,const std::string & s,bool commaNeeded=true)10367 static void print_VkFenceCreateInfo(VkFenceCreateInfo obj, const std::string &s, bool commaNeeded = true)
10368 {
10369     PRINT_SPACE
10370     _OUT << "{" << std::endl;
10371     INDENT(4);
10372 
10373     print_VkStructureType(obj.sType, "sType", 1);
10374 
10375     if (obj.pNext)
10376     {
10377         dumpPNextChain(obj.pNext);
10378     }
10379     else
10380     {
10381         PRINT_SPACE
10382         _OUT << "\"pNext\":"
10383              << "\"NULL\""
10384              << "," << std::endl;
10385     }
10386 
10387     print_VkFenceCreateFlags(obj.flags, "flags", 0);
10388 
10389     INDENT(-4);
10390     PRINT_SPACE
10391     if (commaNeeded)
10392         _OUT << "}," << std::endl;
10393     else
10394         _OUT << "}" << std::endl;
10395 }
print_VkFenceCreateInfo(const VkFenceCreateInfo * obj,const std::string & s,bool commaNeeded=true)10396 static void print_VkFenceCreateInfo(const VkFenceCreateInfo *obj, const std::string &s, bool commaNeeded = true)
10397 {
10398     PRINT_SPACE
10399     _OUT << "{" << std::endl;
10400     INDENT(4);
10401 
10402     print_VkStructureType(obj->sType, "sType", 1);
10403 
10404     if (obj->pNext)
10405     {
10406         dumpPNextChain(obj->pNext);
10407     }
10408     else
10409     {
10410         PRINT_SPACE
10411         _OUT << "\"pNext\":"
10412              << "\"NULL\""
10413              << "," << std::endl;
10414     }
10415 
10416     print_VkFenceCreateFlags(obj->flags, "flags", 0);
10417 
10418     INDENT(-4);
10419     PRINT_SPACE
10420     if (commaNeeded)
10421         _OUT << "}," << std::endl;
10422     else
10423         _OUT << "}" << std::endl;
10424 }
10425 
print_VkSemaphoreCreateInfo(VkSemaphoreCreateInfo obj,const std::string & s,bool commaNeeded=true)10426 static void print_VkSemaphoreCreateInfo(VkSemaphoreCreateInfo obj, const std::string &s, bool commaNeeded = true)
10427 {
10428     PRINT_SPACE
10429     _OUT << "{" << std::endl;
10430     INDENT(4);
10431 
10432     print_VkStructureType(obj.sType, "sType", 1);
10433 
10434     if (obj.pNext)
10435     {
10436         dumpPNextChain(obj.pNext);
10437     }
10438     else
10439     {
10440         PRINT_SPACE
10441         _OUT << "\"pNext\":"
10442              << "\"NULL\""
10443              << "," << std::endl;
10444     }
10445 
10446     print_VkSemaphoreCreateFlags(obj.flags, "flags", 0);
10447 
10448     INDENT(-4);
10449     PRINT_SPACE
10450     if (commaNeeded)
10451         _OUT << "}," << std::endl;
10452     else
10453         _OUT << "}" << std::endl;
10454 }
print_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo * obj,const std::string & s,bool commaNeeded=true)10455 static void print_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo *obj, const std::string &s, bool commaNeeded = true)
10456 {
10457     PRINT_SPACE
10458     _OUT << "{" << std::endl;
10459     INDENT(4);
10460 
10461     print_VkStructureType(obj->sType, "sType", 1);
10462 
10463     if (obj->pNext)
10464     {
10465         dumpPNextChain(obj->pNext);
10466     }
10467     else
10468     {
10469         PRINT_SPACE
10470         _OUT << "\"pNext\":"
10471              << "\"NULL\""
10472              << "," << std::endl;
10473     }
10474 
10475     print_VkSemaphoreCreateFlags(obj->flags, "flags", 0);
10476 
10477     INDENT(-4);
10478     PRINT_SPACE
10479     if (commaNeeded)
10480         _OUT << "}," << std::endl;
10481     else
10482         _OUT << "}" << std::endl;
10483 }
10484 
print_VkEventCreateInfo(VkEventCreateInfo obj,const std::string & s,bool commaNeeded=true)10485 static void print_VkEventCreateInfo(VkEventCreateInfo obj, const std::string &s, bool commaNeeded = true)
10486 {
10487     PRINT_SPACE
10488     _OUT << "{" << std::endl;
10489     INDENT(4);
10490 
10491     print_VkStructureType(obj.sType, "sType", 1);
10492 
10493     if (obj.pNext)
10494     {
10495         dumpPNextChain(obj.pNext);
10496     }
10497     else
10498     {
10499         PRINT_SPACE
10500         _OUT << "\"pNext\":"
10501              << "\"NULL\""
10502              << "," << std::endl;
10503     }
10504 
10505     print_VkEventCreateFlags(obj.flags, "flags", 0);
10506 
10507     INDENT(-4);
10508     PRINT_SPACE
10509     if (commaNeeded)
10510         _OUT << "}," << std::endl;
10511     else
10512         _OUT << "}" << std::endl;
10513 }
print_VkEventCreateInfo(const VkEventCreateInfo * obj,const std::string & s,bool commaNeeded=true)10514 static void print_VkEventCreateInfo(const VkEventCreateInfo *obj, const std::string &s, bool commaNeeded = true)
10515 {
10516     PRINT_SPACE
10517     _OUT << "{" << std::endl;
10518     INDENT(4);
10519 
10520     print_VkStructureType(obj->sType, "sType", 1);
10521 
10522     if (obj->pNext)
10523     {
10524         dumpPNextChain(obj->pNext);
10525     }
10526     else
10527     {
10528         PRINT_SPACE
10529         _OUT << "\"pNext\":"
10530              << "\"NULL\""
10531              << "," << std::endl;
10532     }
10533 
10534     print_VkEventCreateFlags(obj->flags, "flags", 0);
10535 
10536     INDENT(-4);
10537     PRINT_SPACE
10538     if (commaNeeded)
10539         _OUT << "}," << std::endl;
10540     else
10541         _OUT << "}" << std::endl;
10542 }
10543 
print_VkQueryPoolCreateInfo(VkQueryPoolCreateInfo obj,const std::string & s,bool commaNeeded=true)10544 static void print_VkQueryPoolCreateInfo(VkQueryPoolCreateInfo obj, const std::string &s, bool commaNeeded = true)
10545 {
10546     PRINT_SPACE
10547     _OUT << "{" << std::endl;
10548     INDENT(4);
10549 
10550     print_VkStructureType(obj.sType, "sType", 1);
10551 
10552     if (obj.pNext)
10553     {
10554         dumpPNextChain(obj.pNext);
10555     }
10556     else
10557     {
10558         PRINT_SPACE
10559         _OUT << "\"pNext\":"
10560              << "\"NULL\""
10561              << "," << std::endl;
10562     }
10563 
10564     print_VkQueryPoolCreateFlags(obj.flags, "flags", 1);
10565 
10566     print_VkQueryType(obj.queryType, "queryType", 1);
10567 
10568     print_uint32_t(obj.queryCount, "queryCount", 1);
10569 
10570     print_VkQueryPipelineStatisticFlags(obj.pipelineStatistics, "pipelineStatistics", 0);
10571 
10572     INDENT(-4);
10573     PRINT_SPACE
10574     if (commaNeeded)
10575         _OUT << "}," << std::endl;
10576     else
10577         _OUT << "}" << std::endl;
10578 }
print_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo * obj,const std::string & s,bool commaNeeded=true)10579 static void print_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo *obj, const std::string &s, bool commaNeeded = true)
10580 {
10581     PRINT_SPACE
10582     _OUT << "{" << std::endl;
10583     INDENT(4);
10584 
10585     print_VkStructureType(obj->sType, "sType", 1);
10586 
10587     if (obj->pNext)
10588     {
10589         dumpPNextChain(obj->pNext);
10590     }
10591     else
10592     {
10593         PRINT_SPACE
10594         _OUT << "\"pNext\":"
10595              << "\"NULL\""
10596              << "," << std::endl;
10597     }
10598 
10599     print_VkQueryPoolCreateFlags(obj->flags, "flags", 1);
10600 
10601     print_VkQueryType(obj->queryType, "queryType", 1);
10602 
10603     print_uint32_t(obj->queryCount, "queryCount", 1);
10604 
10605     print_VkQueryPipelineStatisticFlags(obj->pipelineStatistics, "pipelineStatistics", 0);
10606 
10607     INDENT(-4);
10608     PRINT_SPACE
10609     if (commaNeeded)
10610         _OUT << "}," << std::endl;
10611     else
10612         _OUT << "}" << std::endl;
10613 }
10614 
print_VkBufferCreateInfo(VkBufferCreateInfo obj,const std::string & s,bool commaNeeded=true)10615 static void print_VkBufferCreateInfo(VkBufferCreateInfo obj, const std::string &s, bool commaNeeded = true)
10616 {
10617     PRINT_SPACE
10618     _OUT << "{" << std::endl;
10619     INDENT(4);
10620 
10621     print_VkStructureType(obj.sType, "sType", 1);
10622 
10623     if (obj.pNext)
10624     {
10625         dumpPNextChain(obj.pNext);
10626     }
10627     else
10628     {
10629         PRINT_SPACE
10630         _OUT << "\"pNext\":"
10631              << "\"NULL\""
10632              << "," << std::endl;
10633     }
10634 
10635     print_VkBufferCreateFlags(obj.flags, "flags", 1);
10636 
10637     print_VkDeviceSize(obj.size, "size", 1);
10638 
10639     print_VkBufferUsageFlags(obj.usage, "usage", 1);
10640 
10641     print_VkSharingMode(obj.sharingMode, "sharingMode", 1);
10642 
10643     print_uint32_t(obj.queueFamilyIndexCount, "queueFamilyIndexCount", 1);
10644 
10645     PRINT_SPACE
10646     _OUT << "\"pQueueFamilyIndices\":" << std::endl;
10647     PRINT_SPACE
10648     if (obj.pQueueFamilyIndices)
10649     {
10650         _OUT << "[" << std::endl;
10651         for (unsigned int i = 0; i < obj.queueFamilyIndexCount; i++)
10652         {
10653             bool isCommaNeeded = (i + 1) != obj.queueFamilyIndexCount;
10654             print_uint32_t(obj.pQueueFamilyIndices[i], "", isCommaNeeded);
10655         }
10656         PRINT_SPACE
10657         _OUT << "]"
10658              << "" << std::endl;
10659     }
10660     else
10661     {
10662         _OUT << "\"NULL\""
10663              << "" << std::endl;
10664     }
10665 
10666     INDENT(-4);
10667     PRINT_SPACE
10668     if (commaNeeded)
10669         _OUT << "}," << std::endl;
10670     else
10671         _OUT << "}" << std::endl;
10672 }
print_VkBufferCreateInfo(const VkBufferCreateInfo * obj,const std::string & s,bool commaNeeded=true)10673 static void print_VkBufferCreateInfo(const VkBufferCreateInfo *obj, const std::string &s, bool commaNeeded = true)
10674 {
10675     PRINT_SPACE
10676     _OUT << "{" << std::endl;
10677     INDENT(4);
10678 
10679     print_VkStructureType(obj->sType, "sType", 1);
10680 
10681     if (obj->pNext)
10682     {
10683         dumpPNextChain(obj->pNext);
10684     }
10685     else
10686     {
10687         PRINT_SPACE
10688         _OUT << "\"pNext\":"
10689              << "\"NULL\""
10690              << "," << std::endl;
10691     }
10692 
10693     print_VkBufferCreateFlags(obj->flags, "flags", 1);
10694 
10695     print_VkDeviceSize(obj->size, "size", 1);
10696 
10697     print_VkBufferUsageFlags(obj->usage, "usage", 1);
10698 
10699     print_VkSharingMode(obj->sharingMode, "sharingMode", 1);
10700 
10701     print_uint32_t(obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1);
10702 
10703     PRINT_SPACE
10704     _OUT << "\"pQueueFamilyIndices\":" << std::endl;
10705     PRINT_SPACE
10706     if (obj->pQueueFamilyIndices)
10707     {
10708         _OUT << "[" << std::endl;
10709         for (unsigned int i = 0; i < obj->queueFamilyIndexCount; i++)
10710         {
10711             bool isCommaNeeded = (i + 1) != obj->queueFamilyIndexCount;
10712             print_uint32_t(obj->pQueueFamilyIndices[i], "", isCommaNeeded);
10713         }
10714         PRINT_SPACE
10715         _OUT << "]"
10716              << "" << std::endl;
10717     }
10718     else
10719     {
10720         _OUT << "\"NULL\""
10721              << "" << std::endl;
10722     }
10723 
10724     INDENT(-4);
10725     PRINT_SPACE
10726     if (commaNeeded)
10727         _OUT << "}," << std::endl;
10728     else
10729         _OUT << "}" << std::endl;
10730 }
10731 
print_VkBufferViewCreateInfo(VkBufferViewCreateInfo obj,const std::string & s,bool commaNeeded=true)10732 static void print_VkBufferViewCreateInfo(VkBufferViewCreateInfo obj, const std::string &s, bool commaNeeded = true)
10733 {
10734     PRINT_SPACE
10735     _OUT << "{" << std::endl;
10736     INDENT(4);
10737 
10738     print_VkStructureType(obj.sType, "sType", 1);
10739 
10740     if (obj.pNext)
10741     {
10742         dumpPNextChain(obj.pNext);
10743     }
10744     else
10745     {
10746         PRINT_SPACE
10747         _OUT << "\"pNext\":"
10748              << "\"NULL\""
10749              << "," << std::endl;
10750     }
10751 
10752     print_VkBufferViewCreateFlags(obj.flags, "flags", 1);
10753 
10754     // CTS : required value
10755     PRINT_SPACE _OUT << "\""
10756                      << "buffer"
10757                      << "\""
10758                      << " : "
10759                      << "\""
10760                      << "\"," << std::endl;
10761 
10762     print_VkFormat(obj.format, "format", 1);
10763 
10764     print_VkDeviceSize(obj.offset, "offset", 1);
10765 
10766     print_VkDeviceSize(obj.range, "range", 0);
10767 
10768     INDENT(-4);
10769     PRINT_SPACE
10770     if (commaNeeded)
10771         _OUT << "}," << std::endl;
10772     else
10773         _OUT << "}" << std::endl;
10774 }
print_VkBufferViewCreateInfo(const VkBufferViewCreateInfo * obj,const std::string & s,bool commaNeeded=true)10775 static void print_VkBufferViewCreateInfo(const VkBufferViewCreateInfo *obj, const std::string &s,
10776                                          bool commaNeeded = true)
10777 {
10778     PRINT_SPACE
10779     _OUT << "{" << std::endl;
10780     INDENT(4);
10781 
10782     print_VkStructureType(obj->sType, "sType", 1);
10783 
10784     if (obj->pNext)
10785     {
10786         dumpPNextChain(obj->pNext);
10787     }
10788     else
10789     {
10790         PRINT_SPACE
10791         _OUT << "\"pNext\":"
10792              << "\"NULL\""
10793              << "," << std::endl;
10794     }
10795 
10796     print_VkBufferViewCreateFlags(obj->flags, "flags", 1);
10797 
10798     // CTS : required value
10799     PRINT_SPACE _OUT << "\""
10800                      << "buffer"
10801                      << "\""
10802                      << " : "
10803                      << "\""
10804                      << "\"," << std::endl;
10805 
10806     print_VkFormat(obj->format, "format", 1);
10807 
10808     print_VkDeviceSize(obj->offset, "offset", 1);
10809 
10810     print_VkDeviceSize(obj->range, "range", 0);
10811 
10812     INDENT(-4);
10813     PRINT_SPACE
10814     if (commaNeeded)
10815         _OUT << "}," << std::endl;
10816     else
10817         _OUT << "}" << std::endl;
10818 }
10819 
print_VkImageCreateInfo(VkImageCreateInfo obj,const std::string & s,bool commaNeeded=true)10820 static void print_VkImageCreateInfo(VkImageCreateInfo obj, const std::string &s, bool commaNeeded = true)
10821 {
10822     PRINT_SPACE
10823     _OUT << "{" << std::endl;
10824     INDENT(4);
10825 
10826     print_VkStructureType(obj.sType, "sType", 1);
10827 
10828     if (obj.pNext)
10829     {
10830         dumpPNextChain(obj.pNext);
10831     }
10832     else
10833     {
10834         PRINT_SPACE
10835         _OUT << "\"pNext\":"
10836              << "\"NULL\""
10837              << "," << std::endl;
10838     }
10839 
10840     print_VkImageCreateFlags(obj.flags, "flags", 1);
10841 
10842     print_VkImageType(obj.imageType, "imageType", 1);
10843 
10844     print_VkFormat(obj.format, "format", 1);
10845 
10846     PRINT_SPACE
10847     _OUT << "\"extent\": " << std::endl;
10848     {
10849         print_VkExtent3D(obj.extent, "extent", 1);
10850     }
10851 
10852     print_uint32_t(obj.mipLevels, "mipLevels", 1);
10853 
10854     print_uint32_t(obj.arrayLayers, "arrayLayers", 1);
10855 
10856     print_VkSampleCountFlagBits(obj.samples, "samples", 1);
10857 
10858     print_VkImageTiling(obj.tiling, "tiling", 1);
10859 
10860     print_VkImageUsageFlags(obj.usage, "usage", 1);
10861 
10862     print_VkSharingMode(obj.sharingMode, "sharingMode", 1);
10863 
10864     print_uint32_t(obj.queueFamilyIndexCount, "queueFamilyIndexCount", 1);
10865 
10866     PRINT_SPACE
10867     _OUT << "\"pQueueFamilyIndices\":" << std::endl;
10868     PRINT_SPACE
10869     if (obj.pQueueFamilyIndices)
10870     {
10871         _OUT << "[" << std::endl;
10872         for (unsigned int i = 0; i < obj.queueFamilyIndexCount; i++)
10873         {
10874             bool isCommaNeeded = (i + 1) != obj.queueFamilyIndexCount;
10875             print_uint32_t(obj.pQueueFamilyIndices[i], "", isCommaNeeded);
10876         }
10877         PRINT_SPACE
10878         _OUT << "]"
10879              << "," << std::endl;
10880     }
10881     else
10882     {
10883         _OUT << "\"NULL\""
10884              << "," << std::endl;
10885     }
10886 
10887     print_VkImageLayout(obj.initialLayout, "initialLayout", 0);
10888 
10889     INDENT(-4);
10890     PRINT_SPACE
10891     if (commaNeeded)
10892         _OUT << "}," << std::endl;
10893     else
10894         _OUT << "}" << std::endl;
10895 }
print_VkImageCreateInfo(const VkImageCreateInfo * obj,const std::string & s,bool commaNeeded=true)10896 static void print_VkImageCreateInfo(const VkImageCreateInfo *obj, const std::string &s, bool commaNeeded = true)
10897 {
10898     PRINT_SPACE
10899     _OUT << "{" << std::endl;
10900     INDENT(4);
10901 
10902     print_VkStructureType(obj->sType, "sType", 1);
10903 
10904     if (obj->pNext)
10905     {
10906         dumpPNextChain(obj->pNext);
10907     }
10908     else
10909     {
10910         PRINT_SPACE
10911         _OUT << "\"pNext\":"
10912              << "\"NULL\""
10913              << "," << std::endl;
10914     }
10915 
10916     print_VkImageCreateFlags(obj->flags, "flags", 1);
10917 
10918     print_VkImageType(obj->imageType, "imageType", 1);
10919 
10920     print_VkFormat(obj->format, "format", 1);
10921 
10922     PRINT_SPACE
10923     _OUT << "\"extent\": " << std::endl;
10924     {
10925         print_VkExtent3D(obj->extent, "extent", 1);
10926     }
10927 
10928     print_uint32_t(obj->mipLevels, "mipLevels", 1);
10929 
10930     print_uint32_t(obj->arrayLayers, "arrayLayers", 1);
10931 
10932     print_VkSampleCountFlagBits(obj->samples, "samples", 1);
10933 
10934     print_VkImageTiling(obj->tiling, "tiling", 1);
10935 
10936     print_VkImageUsageFlags(obj->usage, "usage", 1);
10937 
10938     print_VkSharingMode(obj->sharingMode, "sharingMode", 1);
10939 
10940     print_uint32_t(obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1);
10941 
10942     PRINT_SPACE
10943     _OUT << "\"pQueueFamilyIndices\":" << std::endl;
10944     PRINT_SPACE
10945     if (obj->pQueueFamilyIndices)
10946     {
10947         _OUT << "[" << std::endl;
10948         for (unsigned int i = 0; i < obj->queueFamilyIndexCount; i++)
10949         {
10950             bool isCommaNeeded = (i + 1) != obj->queueFamilyIndexCount;
10951             print_uint32_t(obj->pQueueFamilyIndices[i], "", isCommaNeeded);
10952         }
10953         PRINT_SPACE
10954         _OUT << "]"
10955              << "," << std::endl;
10956     }
10957     else
10958     {
10959         _OUT << "\"NULL\""
10960              << "," << std::endl;
10961     }
10962 
10963     print_VkImageLayout(obj->initialLayout, "initialLayout", 0);
10964 
10965     INDENT(-4);
10966     PRINT_SPACE
10967     if (commaNeeded)
10968         _OUT << "}," << std::endl;
10969     else
10970         _OUT << "}" << std::endl;
10971 }
10972 
print_VkSubresourceLayout(VkSubresourceLayout obj,const std::string & s,bool commaNeeded=true)10973 static void print_VkSubresourceLayout(VkSubresourceLayout obj, const std::string &s, bool commaNeeded = true)
10974 {
10975     PRINT_SPACE
10976     _OUT << "{" << std::endl;
10977     INDENT(4);
10978 
10979     print_VkDeviceSize(obj.offset, "offset", 1);
10980 
10981     print_VkDeviceSize(obj.size, "size", 1);
10982 
10983     print_VkDeviceSize(obj.rowPitch, "rowPitch", 1);
10984 
10985     print_VkDeviceSize(obj.arrayPitch, "arrayPitch", 1);
10986 
10987     print_VkDeviceSize(obj.depthPitch, "depthPitch", 0);
10988 
10989     INDENT(-4);
10990     PRINT_SPACE
10991     if (commaNeeded)
10992         _OUT << "}," << std::endl;
10993     else
10994         _OUT << "}" << std::endl;
10995 }
print_VkSubresourceLayout(const VkSubresourceLayout * obj,const std::string & s,bool commaNeeded=true)10996 static void print_VkSubresourceLayout(const VkSubresourceLayout *obj, const std::string &s, bool commaNeeded = true)
10997 {
10998     PRINT_SPACE
10999     _OUT << "{" << std::endl;
11000     INDENT(4);
11001 
11002     print_VkDeviceSize(obj->offset, "offset", 1);
11003 
11004     print_VkDeviceSize(obj->size, "size", 1);
11005 
11006     print_VkDeviceSize(obj->rowPitch, "rowPitch", 1);
11007 
11008     print_VkDeviceSize(obj->arrayPitch, "arrayPitch", 1);
11009 
11010     print_VkDeviceSize(obj->depthPitch, "depthPitch", 0);
11011 
11012     INDENT(-4);
11013     PRINT_SPACE
11014     if (commaNeeded)
11015         _OUT << "}," << std::endl;
11016     else
11017         _OUT << "}" << std::endl;
11018 }
11019 
print_VkComponentMapping(VkComponentMapping obj,const std::string & s,bool commaNeeded=true)11020 static void print_VkComponentMapping(VkComponentMapping obj, const std::string &s, bool commaNeeded = true)
11021 {
11022     PRINT_SPACE
11023     _OUT << "{" << std::endl;
11024     INDENT(4);
11025 
11026     print_VkComponentSwizzle(obj.r, "r", 1);
11027 
11028     print_VkComponentSwizzle(obj.g, "g", 1);
11029 
11030     print_VkComponentSwizzle(obj.b, "b", 1);
11031 
11032     print_VkComponentSwizzle(obj.a, "a", 0);
11033 
11034     INDENT(-4);
11035     PRINT_SPACE
11036     if (commaNeeded)
11037         _OUT << "}," << std::endl;
11038     else
11039         _OUT << "}" << std::endl;
11040 }
print_VkComponentMapping(const VkComponentMapping * obj,const std::string & s,bool commaNeeded=true)11041 static void print_VkComponentMapping(const VkComponentMapping *obj, const std::string &s, bool commaNeeded = true)
11042 {
11043     PRINT_SPACE
11044     _OUT << "{" << std::endl;
11045     INDENT(4);
11046 
11047     print_VkComponentSwizzle(obj->r, "r", 1);
11048 
11049     print_VkComponentSwizzle(obj->g, "g", 1);
11050 
11051     print_VkComponentSwizzle(obj->b, "b", 1);
11052 
11053     print_VkComponentSwizzle(obj->a, "a", 0);
11054 
11055     INDENT(-4);
11056     PRINT_SPACE
11057     if (commaNeeded)
11058         _OUT << "}," << std::endl;
11059     else
11060         _OUT << "}" << std::endl;
11061 }
11062 
print_VkImageViewCreateInfo(VkImageViewCreateInfo obj,const std::string & s,bool commaNeeded=true)11063 static void print_VkImageViewCreateInfo(VkImageViewCreateInfo obj, const std::string &s, bool commaNeeded = true)
11064 {
11065     PRINT_SPACE
11066     _OUT << "{" << std::endl;
11067     INDENT(4);
11068 
11069     print_VkStructureType(obj.sType, "sType", 1);
11070 
11071     if (obj.pNext)
11072     {
11073         dumpPNextChain(obj.pNext);
11074     }
11075     else
11076     {
11077         PRINT_SPACE
11078         _OUT << "\"pNext\":"
11079              << "\"NULL\""
11080              << "," << std::endl;
11081     }
11082 
11083     print_VkImageViewCreateFlags(obj.flags, "flags", 1);
11084 
11085     // CTS : required value
11086     PRINT_SPACE _OUT << "\""
11087                      << "image"
11088                      << "\""
11089                      << " : "
11090                      << "\""
11091                      << "\"," << std::endl;
11092 
11093     print_VkImageViewType(obj.viewType, "viewType", 1);
11094 
11095     print_VkFormat(obj.format, "format", 1);
11096 
11097     PRINT_SPACE
11098     _OUT << "\"components\": " << std::endl;
11099     {
11100         print_VkComponentMapping(obj.components, "components", 1);
11101     }
11102 
11103     PRINT_SPACE
11104     _OUT << "\"subresourceRange\": " << std::endl;
11105     {
11106         print_VkImageSubresourceRange(obj.subresourceRange, "subresourceRange", 0);
11107     }
11108 
11109     INDENT(-4);
11110     PRINT_SPACE
11111     if (commaNeeded)
11112         _OUT << "}," << std::endl;
11113     else
11114         _OUT << "}" << std::endl;
11115 }
print_VkImageViewCreateInfo(const VkImageViewCreateInfo * obj,const std::string & s,bool commaNeeded=true)11116 static void print_VkImageViewCreateInfo(const VkImageViewCreateInfo *obj, const std::string &s, bool commaNeeded = true)
11117 {
11118     PRINT_SPACE
11119     _OUT << "{" << std::endl;
11120     INDENT(4);
11121 
11122     print_VkStructureType(obj->sType, "sType", 1);
11123 
11124     if (obj->pNext)
11125     {
11126         dumpPNextChain(obj->pNext);
11127     }
11128     else
11129     {
11130         PRINT_SPACE
11131         _OUT << "\"pNext\":"
11132              << "\"NULL\""
11133              << "," << std::endl;
11134     }
11135 
11136     print_VkImageViewCreateFlags(obj->flags, "flags", 1);
11137 
11138     // CTS : required value
11139     PRINT_SPACE _OUT << "\""
11140                      << "image"
11141                      << "\""
11142                      << " : "
11143                      << "\""
11144                      << "\"," << std::endl;
11145 
11146     print_VkImageViewType(obj->viewType, "viewType", 1);
11147 
11148     print_VkFormat(obj->format, "format", 1);
11149 
11150     PRINT_SPACE
11151     _OUT << "\"components\": " << std::endl;
11152     {
11153         print_VkComponentMapping(obj->components, "components", 1);
11154     }
11155 
11156     PRINT_SPACE
11157     _OUT << "\"subresourceRange\": " << std::endl;
11158     {
11159         print_VkImageSubresourceRange(obj->subresourceRange, "subresourceRange", 0);
11160     }
11161 
11162     INDENT(-4);
11163     PRINT_SPACE
11164     if (commaNeeded)
11165         _OUT << "}," << std::endl;
11166     else
11167         _OUT << "}" << std::endl;
11168 }
11169 
print_VkPipelineCacheCreateInfo(VkPipelineCacheCreateInfo obj,const std::string & s,bool commaNeeded=true)11170 static void print_VkPipelineCacheCreateInfo(VkPipelineCacheCreateInfo obj, const std::string &s,
11171                                             bool commaNeeded = true)
11172 {
11173     PRINT_SPACE
11174     _OUT << "{" << std::endl;
11175     INDENT(4);
11176 
11177     print_VkStructureType(obj.sType, "sType", 1);
11178 
11179     if (obj.pNext)
11180     {
11181         dumpPNextChain(obj.pNext);
11182     }
11183     else
11184     {
11185         PRINT_SPACE
11186         _OUT << "\"pNext\":"
11187              << "\"NULL\""
11188              << "," << std::endl;
11189     }
11190 
11191     print_VkPipelineCacheCreateFlags(obj.flags, "flags", 1);
11192 
11193     print_size_t(obj.initialDataSize, "initialDataSize", 1);
11194 
11195     print_void_data(obj.pInitialData, int(obj.initialDataSize), "pInitialData", 0);
11196 
11197     INDENT(-4);
11198     PRINT_SPACE
11199     if (commaNeeded)
11200         _OUT << "}," << std::endl;
11201     else
11202         _OUT << "}" << std::endl;
11203 }
print_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo * obj,const std::string & s,bool commaNeeded=true)11204 static void print_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo *obj, const std::string &s,
11205                                             bool commaNeeded = true)
11206 {
11207     PRINT_SPACE
11208     _OUT << "{" << std::endl;
11209     INDENT(4);
11210 
11211     print_VkStructureType(obj->sType, "sType", 1);
11212 
11213     if (obj->pNext)
11214     {
11215         dumpPNextChain(obj->pNext);
11216     }
11217     else
11218     {
11219         PRINT_SPACE
11220         _OUT << "\"pNext\":"
11221              << "\"NULL\""
11222              << "," << std::endl;
11223     }
11224 
11225     print_VkPipelineCacheCreateFlags(obj->flags, "flags", 1);
11226 
11227     print_size_t(obj->initialDataSize, "initialDataSize", 1);
11228 
11229     print_void_data(obj->pInitialData, int(obj->initialDataSize), "pInitialData", 0);
11230 
11231     INDENT(-4);
11232     PRINT_SPACE
11233     if (commaNeeded)
11234         _OUT << "}," << std::endl;
11235     else
11236         _OUT << "}" << std::endl;
11237 }
11238 
print_VkSpecializationMapEntry(VkSpecializationMapEntry obj,const std::string & s,bool commaNeeded=true)11239 static void print_VkSpecializationMapEntry(VkSpecializationMapEntry obj, const std::string &s, bool commaNeeded = true)
11240 {
11241     PRINT_SPACE
11242     _OUT << "{" << std::endl;
11243     INDENT(4);
11244 
11245     print_uint32_t(obj.constantID, "constantID", 1);
11246 
11247     print_uint32_t(obj.offset, "offset", 1);
11248 
11249     print_size_t(obj.size, "size", 0);
11250 
11251     INDENT(-4);
11252     PRINT_SPACE
11253     if (commaNeeded)
11254         _OUT << "}," << std::endl;
11255     else
11256         _OUT << "}" << std::endl;
11257 }
print_VkSpecializationMapEntry(const VkSpecializationMapEntry * obj,const std::string & s,bool commaNeeded=true)11258 static void print_VkSpecializationMapEntry(const VkSpecializationMapEntry *obj, const std::string &s,
11259                                            bool commaNeeded = true)
11260 {
11261     PRINT_SPACE
11262     _OUT << "{" << std::endl;
11263     INDENT(4);
11264 
11265     print_uint32_t(obj->constantID, "constantID", 1);
11266 
11267     print_uint32_t(obj->offset, "offset", 1);
11268 
11269     print_size_t(obj->size, "size", 0);
11270 
11271     INDENT(-4);
11272     PRINT_SPACE
11273     if (commaNeeded)
11274         _OUT << "}," << std::endl;
11275     else
11276         _OUT << "}" << std::endl;
11277 }
11278 
print_VkSpecializationInfo(VkSpecializationInfo obj,const std::string & s,bool commaNeeded=true)11279 static void print_VkSpecializationInfo(VkSpecializationInfo obj, const std::string &s, bool commaNeeded = true)
11280 {
11281     PRINT_SPACE
11282     _OUT << "{" << std::endl;
11283     INDENT(4);
11284 
11285     print_uint32_t(obj.mapEntryCount, "mapEntryCount", 1);
11286 
11287     PRINT_SPACE
11288     _OUT << "\"pMapEntries\": " << std::endl;
11289     if (obj.pMapEntries)
11290     {
11291         PRINT_SPACE
11292         _OUT << "[" << std::endl;
11293         for (unsigned int i = 0; i < obj.mapEntryCount; i++)
11294         {
11295             if (i + 1 == obj.mapEntryCount)
11296                 print_VkSpecializationMapEntry(obj.pMapEntries[i], "pMapEntries", 0);
11297             else
11298                 print_VkSpecializationMapEntry(obj.pMapEntries[i], "pMapEntries", 1);
11299         }
11300         PRINT_SPACE
11301         _OUT << "]," << std::endl;
11302     }
11303     else
11304     {
11305         PRINT_SPACE _OUT << "\"NULL\""
11306                          << "," << std::endl;
11307     }
11308 
11309     print_size_t(obj.dataSize, "dataSize", 1);
11310 
11311     print_void_data(obj.pData, int(obj.dataSize), "pData", 0);
11312 
11313     INDENT(-4);
11314     PRINT_SPACE
11315     if (commaNeeded)
11316         _OUT << "}," << std::endl;
11317     else
11318         _OUT << "}" << std::endl;
11319 }
print_VkSpecializationInfo(const VkSpecializationInfo * obj,const std::string & s,bool commaNeeded=true)11320 static void print_VkSpecializationInfo(const VkSpecializationInfo *obj, const std::string &s, bool commaNeeded = true)
11321 {
11322     PRINT_SPACE
11323     _OUT << "{" << std::endl;
11324     INDENT(4);
11325 
11326     print_uint32_t(obj->mapEntryCount, "mapEntryCount", 1);
11327 
11328     PRINT_SPACE
11329     _OUT << "\"pMapEntries\": " << std::endl;
11330     if (obj->pMapEntries)
11331     {
11332         PRINT_SPACE
11333         _OUT << "[" << std::endl;
11334         for (unsigned int i = 0; i < obj->mapEntryCount; i++)
11335         {
11336             if (i + 1 == obj->mapEntryCount)
11337                 print_VkSpecializationMapEntry(obj->pMapEntries[i], "pMapEntries", 0);
11338             else
11339                 print_VkSpecializationMapEntry(obj->pMapEntries[i], "pMapEntries", 1);
11340         }
11341         PRINT_SPACE
11342         _OUT << "]," << std::endl;
11343     }
11344     else
11345     {
11346         PRINT_SPACE _OUT << "\"NULL\""
11347                          << "," << std::endl;
11348     }
11349 
11350     print_size_t(obj->dataSize, "dataSize", 1);
11351 
11352     print_void_data(obj->pData, int(obj->dataSize), "pData", 0);
11353 
11354     INDENT(-4);
11355     PRINT_SPACE
11356     if (commaNeeded)
11357         _OUT << "}," << std::endl;
11358     else
11359         _OUT << "}" << std::endl;
11360 }
11361 
print_VkPipelineShaderStageCreateInfo(VkPipelineShaderStageCreateInfo obj,const std::string & s,bool commaNeeded=true)11362 static void print_VkPipelineShaderStageCreateInfo(VkPipelineShaderStageCreateInfo obj, const std::string &s,
11363                                                   bool commaNeeded = true)
11364 {
11365     PRINT_SPACE
11366     _OUT << "{" << std::endl;
11367     INDENT(4);
11368 
11369     print_VkStructureType(obj.sType, "sType", 1);
11370 
11371     if (obj.pNext)
11372     {
11373         dumpPNextChain(obj.pNext);
11374     }
11375     else
11376     {
11377         PRINT_SPACE
11378         _OUT << "\"pNext\":"
11379              << "\"NULL\""
11380              << "," << std::endl;
11381     }
11382 
11383     print_VkPipelineShaderStageCreateFlags(obj.flags, "flags", 1);
11384 
11385     print_VkShaderStageFlagBits(obj.stage, "stage", 1);
11386 
11387     // CTS : required value
11388     PRINT_SPACE _OUT << "\""
11389                      << "module"
11390                      << "\""
11391                      << " : " << obj.module.getInternal() << "," << std::endl;
11392 
11393     print_char(obj.pName, "pName", 1);
11394 
11395     PRINT_SPACE
11396     _OUT << "\"pSpecializationInfo\": " << std::endl;
11397     if (obj.pSpecializationInfo)
11398     {
11399         print_VkSpecializationInfo(obj.pSpecializationInfo, "pSpecializationInfo", 0);
11400     }
11401     else
11402     {
11403         PRINT_SPACE _OUT << "\"NULL\""
11404                          << "" << std::endl;
11405     }
11406 
11407     INDENT(-4);
11408     PRINT_SPACE
11409     if (commaNeeded)
11410         _OUT << "}," << std::endl;
11411     else
11412         _OUT << "}" << std::endl;
11413 }
print_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo * obj,const std::string & s,bool commaNeeded=true)11414 static void print_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo *obj, const std::string &s,
11415                                                   bool commaNeeded = true)
11416 {
11417     PRINT_SPACE
11418     _OUT << "{" << std::endl;
11419     INDENT(4);
11420 
11421     print_VkStructureType(obj->sType, "sType", 1);
11422 
11423     if (obj->pNext)
11424     {
11425         dumpPNextChain(obj->pNext);
11426     }
11427     else
11428     {
11429         PRINT_SPACE
11430         _OUT << "\"pNext\":"
11431              << "\"NULL\""
11432              << "," << std::endl;
11433     }
11434 
11435     print_VkPipelineShaderStageCreateFlags(obj->flags, "flags", 1);
11436 
11437     print_VkShaderStageFlagBits(obj->stage, "stage", 1);
11438 
11439     // CTS : required value
11440     PRINT_SPACE _OUT << "\""
11441                      << "module"
11442                      << "\""
11443                      << " : " << obj->module.getInternal() << "," << std::endl;
11444 
11445     print_char(obj->pName, "pName", 1);
11446 
11447     PRINT_SPACE
11448     _OUT << "\"pSpecializationInfo\": " << std::endl;
11449     if (obj->pSpecializationInfo)
11450     {
11451         print_VkSpecializationInfo(obj->pSpecializationInfo, "pSpecializationInfo", 0);
11452     }
11453     else
11454     {
11455         PRINT_SPACE _OUT << "\"NULL\""
11456                          << "" << std::endl;
11457     }
11458 
11459     INDENT(-4);
11460     PRINT_SPACE
11461     if (commaNeeded)
11462         _OUT << "}," << std::endl;
11463     else
11464         _OUT << "}" << std::endl;
11465 }
11466 
print_VkComputePipelineCreateInfo(VkComputePipelineCreateInfo obj,const std::string & s,bool commaNeeded=true)11467 static void print_VkComputePipelineCreateInfo(VkComputePipelineCreateInfo obj, const std::string &s,
11468                                               bool commaNeeded = true)
11469 {
11470     PRINT_SPACE
11471     _OUT << "{" << std::endl;
11472     INDENT(4);
11473 
11474     print_VkStructureType(obj.sType, "sType", 1);
11475 
11476     if (obj.pNext)
11477     {
11478         dumpPNextChain(obj.pNext);
11479     }
11480     else
11481     {
11482         PRINT_SPACE
11483         _OUT << "\"pNext\":"
11484              << "\"NULL\""
11485              << "," << std::endl;
11486     }
11487 
11488     print_VkPipelineCreateFlags(obj.flags, "flags", 1);
11489 
11490     PRINT_SPACE
11491     _OUT << "\"stage\": " << std::endl;
11492     {
11493         print_VkPipelineShaderStageCreateInfo(obj.stage, "stage", 1);
11494     }
11495 
11496     // CTS : required value
11497     PRINT_SPACE _OUT << "\""
11498                      << "layout"
11499                      << "\""
11500                      << " : " << obj.layout.getInternal() << "," << std::endl;
11501 
11502     // CTS : required value
11503     PRINT_SPACE _OUT << "\""
11504                      << "basePipelineHandle"
11505                      << "\""
11506                      << " : "
11507                      << "\""
11508                      << "\"," << std::endl;
11509 
11510     print_int32_t(obj.basePipelineIndex, "basePipelineIndex", 0);
11511 
11512     INDENT(-4);
11513     PRINT_SPACE
11514     if (commaNeeded)
11515         _OUT << "}," << std::endl;
11516     else
11517         _OUT << "}" << std::endl;
11518 }
print_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo * obj,const std::string & s,bool commaNeeded=true)11519 static void print_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo *obj, const std::string &s,
11520                                               bool commaNeeded = true)
11521 {
11522     PRINT_SPACE
11523     _OUT << "{" << std::endl;
11524     INDENT(4);
11525 
11526     print_VkStructureType(obj->sType, "sType", 1);
11527 
11528     if (obj->pNext)
11529     {
11530         dumpPNextChain(obj->pNext);
11531     }
11532     else
11533     {
11534         PRINT_SPACE
11535         _OUT << "\"pNext\":"
11536              << "\"NULL\""
11537              << "," << std::endl;
11538     }
11539 
11540     print_VkPipelineCreateFlags(obj->flags, "flags", 1);
11541 
11542     PRINT_SPACE
11543     _OUT << "\"stage\": " << std::endl;
11544     {
11545         print_VkPipelineShaderStageCreateInfo(obj->stage, "stage", 1);
11546     }
11547 
11548     // CTS : required value
11549     PRINT_SPACE _OUT << "\""
11550                      << "layout"
11551                      << "\""
11552                      << " : " << obj->layout.getInternal() << "," << std::endl;
11553 
11554     // CTS : required value
11555     PRINT_SPACE _OUT << "\""
11556                      << "basePipelineHandle"
11557                      << "\""
11558                      << " : "
11559                      << "\""
11560                      << "\"," << std::endl;
11561 
11562     print_int32_t(obj->basePipelineIndex, "basePipelineIndex", 0);
11563 
11564     INDENT(-4);
11565     PRINT_SPACE
11566     if (commaNeeded)
11567         _OUT << "}," << std::endl;
11568     else
11569         _OUT << "}" << std::endl;
11570 }
11571 
print_VkVertexInputBindingDescription(VkVertexInputBindingDescription obj,const std::string & s,bool commaNeeded=true)11572 static void print_VkVertexInputBindingDescription(VkVertexInputBindingDescription obj, const std::string &s,
11573                                                   bool commaNeeded = true)
11574 {
11575     PRINT_SPACE
11576     _OUT << "{" << std::endl;
11577     INDENT(4);
11578 
11579     print_uint32_t(obj.binding, "binding", 1);
11580 
11581     print_uint32_t(obj.stride, "stride", 1);
11582 
11583     print_VkVertexInputRate(obj.inputRate, "inputRate", 0);
11584 
11585     INDENT(-4);
11586     PRINT_SPACE
11587     if (commaNeeded)
11588         _OUT << "}," << std::endl;
11589     else
11590         _OUT << "}" << std::endl;
11591 }
print_VkVertexInputBindingDescription(const VkVertexInputBindingDescription * obj,const std::string & s,bool commaNeeded=true)11592 static void print_VkVertexInputBindingDescription(const VkVertexInputBindingDescription *obj, const std::string &s,
11593                                                   bool commaNeeded = true)
11594 {
11595     PRINT_SPACE
11596     _OUT << "{" << std::endl;
11597     INDENT(4);
11598 
11599     print_uint32_t(obj->binding, "binding", 1);
11600 
11601     print_uint32_t(obj->stride, "stride", 1);
11602 
11603     print_VkVertexInputRate(obj->inputRate, "inputRate", 0);
11604 
11605     INDENT(-4);
11606     PRINT_SPACE
11607     if (commaNeeded)
11608         _OUT << "}," << std::endl;
11609     else
11610         _OUT << "}" << std::endl;
11611 }
11612 
print_VkVertexInputAttributeDescription(VkVertexInputAttributeDescription obj,const std::string & s,bool commaNeeded=true)11613 static void print_VkVertexInputAttributeDescription(VkVertexInputAttributeDescription obj, const std::string &s,
11614                                                     bool commaNeeded = true)
11615 {
11616     PRINT_SPACE
11617     _OUT << "{" << std::endl;
11618     INDENT(4);
11619 
11620     print_uint32_t(obj.location, "location", 1);
11621 
11622     print_uint32_t(obj.binding, "binding", 1);
11623 
11624     print_VkFormat(obj.format, "format", 1);
11625 
11626     print_uint32_t(obj.offset, "offset", 0);
11627 
11628     INDENT(-4);
11629     PRINT_SPACE
11630     if (commaNeeded)
11631         _OUT << "}," << std::endl;
11632     else
11633         _OUT << "}" << std::endl;
11634 }
print_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription * obj,const std::string & s,bool commaNeeded=true)11635 static void print_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription *obj, const std::string &s,
11636                                                     bool commaNeeded = true)
11637 {
11638     PRINT_SPACE
11639     _OUT << "{" << std::endl;
11640     INDENT(4);
11641 
11642     print_uint32_t(obj->location, "location", 1);
11643 
11644     print_uint32_t(obj->binding, "binding", 1);
11645 
11646     print_VkFormat(obj->format, "format", 1);
11647 
11648     print_uint32_t(obj->offset, "offset", 0);
11649 
11650     INDENT(-4);
11651     PRINT_SPACE
11652     if (commaNeeded)
11653         _OUT << "}," << std::endl;
11654     else
11655         _OUT << "}" << std::endl;
11656 }
11657 
print_VkPipelineVertexInputStateCreateInfo(VkPipelineVertexInputStateCreateInfo obj,const std::string & s,bool commaNeeded=true)11658 static void print_VkPipelineVertexInputStateCreateInfo(VkPipelineVertexInputStateCreateInfo obj, const std::string &s,
11659                                                        bool commaNeeded = true)
11660 {
11661     PRINT_SPACE
11662     _OUT << "{" << std::endl;
11663     INDENT(4);
11664 
11665     print_VkStructureType(obj.sType, "sType", 1);
11666 
11667     if (obj.pNext)
11668     {
11669         dumpPNextChain(obj.pNext);
11670     }
11671     else
11672     {
11673         PRINT_SPACE
11674         _OUT << "\"pNext\":"
11675              << "\"NULL\""
11676              << "," << std::endl;
11677     }
11678 
11679     print_VkPipelineVertexInputStateCreateFlags(obj.flags, "flags", 1);
11680 
11681     print_uint32_t(obj.vertexBindingDescriptionCount, "vertexBindingDescriptionCount", 1);
11682 
11683     PRINT_SPACE
11684     _OUT << "\"pVertexBindingDescriptions\": " << std::endl;
11685     if (obj.pVertexBindingDescriptions)
11686     {
11687         PRINT_SPACE
11688         _OUT << "[" << std::endl;
11689         for (unsigned int i = 0; i < obj.vertexBindingDescriptionCount; i++)
11690         {
11691             if (i + 1 == obj.vertexBindingDescriptionCount)
11692                 print_VkVertexInputBindingDescription(obj.pVertexBindingDescriptions[i], "pVertexBindingDescriptions",
11693                                                       0);
11694             else
11695                 print_VkVertexInputBindingDescription(obj.pVertexBindingDescriptions[i], "pVertexBindingDescriptions",
11696                                                       1);
11697         }
11698         PRINT_SPACE
11699         _OUT << "]," << std::endl;
11700     }
11701     else
11702     {
11703         PRINT_SPACE _OUT << "\"NULL\""
11704                          << "," << std::endl;
11705     }
11706 
11707     print_uint32_t(obj.vertexAttributeDescriptionCount, "vertexAttributeDescriptionCount", 1);
11708 
11709     PRINT_SPACE
11710     _OUT << "\"pVertexAttributeDescriptions\": " << std::endl;
11711     if (obj.pVertexAttributeDescriptions)
11712     {
11713         PRINT_SPACE
11714         _OUT << "[" << std::endl;
11715         for (unsigned int i = 0; i < obj.vertexAttributeDescriptionCount; i++)
11716         {
11717             if (i + 1 == obj.vertexAttributeDescriptionCount)
11718                 print_VkVertexInputAttributeDescription(obj.pVertexAttributeDescriptions[i],
11719                                                         "pVertexAttributeDescriptions", 0);
11720             else
11721                 print_VkVertexInputAttributeDescription(obj.pVertexAttributeDescriptions[i],
11722                                                         "pVertexAttributeDescriptions", 1);
11723         }
11724         PRINT_SPACE
11725         _OUT << "]" << std::endl;
11726     }
11727     else
11728     {
11729         PRINT_SPACE _OUT << "\"NULL\""
11730                          << "" << std::endl;
11731     }
11732 
11733     INDENT(-4);
11734     PRINT_SPACE
11735     if (commaNeeded)
11736         _OUT << "}," << std::endl;
11737     else
11738         _OUT << "}" << std::endl;
11739 }
print_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo * obj,const std::string & s,bool commaNeeded=true)11740 static void print_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo *obj,
11741                                                        const std::string &s, bool commaNeeded = true)
11742 {
11743     PRINT_SPACE
11744     _OUT << "{" << std::endl;
11745     INDENT(4);
11746 
11747     print_VkStructureType(obj->sType, "sType", 1);
11748 
11749     if (obj->pNext)
11750     {
11751         dumpPNextChain(obj->pNext);
11752     }
11753     else
11754     {
11755         PRINT_SPACE
11756         _OUT << "\"pNext\":"
11757              << "\"NULL\""
11758              << "," << std::endl;
11759     }
11760 
11761     print_VkPipelineVertexInputStateCreateFlags(obj->flags, "flags", 1);
11762 
11763     print_uint32_t(obj->vertexBindingDescriptionCount, "vertexBindingDescriptionCount", 1);
11764 
11765     PRINT_SPACE
11766     _OUT << "\"pVertexBindingDescriptions\": " << std::endl;
11767     if (obj->pVertexBindingDescriptions)
11768     {
11769         PRINT_SPACE
11770         _OUT << "[" << std::endl;
11771         for (unsigned int i = 0; i < obj->vertexBindingDescriptionCount; i++)
11772         {
11773             if (i + 1 == obj->vertexBindingDescriptionCount)
11774                 print_VkVertexInputBindingDescription(obj->pVertexBindingDescriptions[i], "pVertexBindingDescriptions",
11775                                                       0);
11776             else
11777                 print_VkVertexInputBindingDescription(obj->pVertexBindingDescriptions[i], "pVertexBindingDescriptions",
11778                                                       1);
11779         }
11780         PRINT_SPACE
11781         _OUT << "]," << std::endl;
11782     }
11783     else
11784     {
11785         PRINT_SPACE _OUT << "\"NULL\""
11786                          << "," << std::endl;
11787     }
11788 
11789     print_uint32_t(obj->vertexAttributeDescriptionCount, "vertexAttributeDescriptionCount", 1);
11790 
11791     PRINT_SPACE
11792     _OUT << "\"pVertexAttributeDescriptions\": " << std::endl;
11793     if (obj->pVertexAttributeDescriptions)
11794     {
11795         PRINT_SPACE
11796         _OUT << "[" << std::endl;
11797         for (unsigned int i = 0; i < obj->vertexAttributeDescriptionCount; i++)
11798         {
11799             if (i + 1 == obj->vertexAttributeDescriptionCount)
11800                 print_VkVertexInputAttributeDescription(obj->pVertexAttributeDescriptions[i],
11801                                                         "pVertexAttributeDescriptions", 0);
11802             else
11803                 print_VkVertexInputAttributeDescription(obj->pVertexAttributeDescriptions[i],
11804                                                         "pVertexAttributeDescriptions", 1);
11805         }
11806         PRINT_SPACE
11807         _OUT << "]" << std::endl;
11808     }
11809     else
11810     {
11811         PRINT_SPACE _OUT << "\"NULL\""
11812                          << "" << std::endl;
11813     }
11814 
11815     INDENT(-4);
11816     PRINT_SPACE
11817     if (commaNeeded)
11818         _OUT << "}," << std::endl;
11819     else
11820         _OUT << "}" << std::endl;
11821 }
11822 
print_VkPipelineInputAssemblyStateCreateInfo(VkPipelineInputAssemblyStateCreateInfo obj,const std::string & s,bool commaNeeded=true)11823 static void print_VkPipelineInputAssemblyStateCreateInfo(VkPipelineInputAssemblyStateCreateInfo obj,
11824                                                          const std::string &s, bool commaNeeded = true)
11825 {
11826     PRINT_SPACE
11827     _OUT << "{" << std::endl;
11828     INDENT(4);
11829 
11830     print_VkStructureType(obj.sType, "sType", 1);
11831 
11832     if (obj.pNext)
11833     {
11834         dumpPNextChain(obj.pNext);
11835     }
11836     else
11837     {
11838         PRINT_SPACE
11839         _OUT << "\"pNext\":"
11840              << "\"NULL\""
11841              << "," << std::endl;
11842     }
11843 
11844     print_VkPipelineInputAssemblyStateCreateFlags(obj.flags, "flags", 1);
11845 
11846     print_VkPrimitiveTopology(obj.topology, "topology", 1);
11847 
11848     print_VkBool32(obj.primitiveRestartEnable, "primitiveRestartEnable", 0);
11849 
11850     INDENT(-4);
11851     PRINT_SPACE
11852     if (commaNeeded)
11853         _OUT << "}," << std::endl;
11854     else
11855         _OUT << "}" << std::endl;
11856 }
print_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo * obj,const std::string & s,bool commaNeeded=true)11857 static void print_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo *obj,
11858                                                          const std::string &s, bool commaNeeded = true)
11859 {
11860     PRINT_SPACE
11861     _OUT << "{" << std::endl;
11862     INDENT(4);
11863 
11864     print_VkStructureType(obj->sType, "sType", 1);
11865 
11866     if (obj->pNext)
11867     {
11868         dumpPNextChain(obj->pNext);
11869     }
11870     else
11871     {
11872         PRINT_SPACE
11873         _OUT << "\"pNext\":"
11874              << "\"NULL\""
11875              << "," << std::endl;
11876     }
11877 
11878     print_VkPipelineInputAssemblyStateCreateFlags(obj->flags, "flags", 1);
11879 
11880     print_VkPrimitiveTopology(obj->topology, "topology", 1);
11881 
11882     print_VkBool32(obj->primitiveRestartEnable, "primitiveRestartEnable", 0);
11883 
11884     INDENT(-4);
11885     PRINT_SPACE
11886     if (commaNeeded)
11887         _OUT << "}," << std::endl;
11888     else
11889         _OUT << "}" << std::endl;
11890 }
11891 
print_VkPipelineTessellationStateCreateInfo(VkPipelineTessellationStateCreateInfo obj,const std::string & s,bool commaNeeded=true)11892 static void print_VkPipelineTessellationStateCreateInfo(VkPipelineTessellationStateCreateInfo obj, const std::string &s,
11893                                                         bool commaNeeded = true)
11894 {
11895     PRINT_SPACE
11896     _OUT << "{" << std::endl;
11897     INDENT(4);
11898 
11899     print_VkStructureType(obj.sType, "sType", 1);
11900 
11901     if (obj.pNext)
11902     {
11903         dumpPNextChain(obj.pNext);
11904     }
11905     else
11906     {
11907         PRINT_SPACE
11908         _OUT << "\"pNext\":"
11909              << "\"NULL\""
11910              << "," << std::endl;
11911     }
11912 
11913     print_VkPipelineTessellationStateCreateFlags(obj.flags, "flags", 1);
11914 
11915     print_uint32_t(obj.patchControlPoints, "patchControlPoints", 0);
11916 
11917     INDENT(-4);
11918     PRINT_SPACE
11919     if (commaNeeded)
11920         _OUT << "}," << std::endl;
11921     else
11922         _OUT << "}" << std::endl;
11923 }
print_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo * obj,const std::string & s,bool commaNeeded=true)11924 static void print_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo *obj,
11925                                                         const std::string &s, bool commaNeeded = true)
11926 {
11927     PRINT_SPACE
11928     _OUT << "{" << std::endl;
11929     INDENT(4);
11930 
11931     print_VkStructureType(obj->sType, "sType", 1);
11932 
11933     if (obj->pNext)
11934     {
11935         dumpPNextChain(obj->pNext);
11936     }
11937     else
11938     {
11939         PRINT_SPACE
11940         _OUT << "\"pNext\":"
11941              << "\"NULL\""
11942              << "," << std::endl;
11943     }
11944 
11945     print_VkPipelineTessellationStateCreateFlags(obj->flags, "flags", 1);
11946 
11947     print_uint32_t(obj->patchControlPoints, "patchControlPoints", 0);
11948 
11949     INDENT(-4);
11950     PRINT_SPACE
11951     if (commaNeeded)
11952         _OUT << "}," << std::endl;
11953     else
11954         _OUT << "}" << std::endl;
11955 }
11956 
print_VkViewport(VkViewport obj,const std::string & s,bool commaNeeded=true)11957 static void print_VkViewport(VkViewport obj, const std::string &s, bool commaNeeded = true)
11958 {
11959     PRINT_SPACE
11960     _OUT << "{" << std::endl;
11961     INDENT(4);
11962 
11963     print_float(obj.x, "x", 1);
11964 
11965     print_float(obj.y, "y", 1);
11966 
11967     print_float(obj.width, "width", 1);
11968 
11969     print_float(obj.height, "height", 1);
11970 
11971     print_float(obj.minDepth, "minDepth", 1);
11972 
11973     print_float(obj.maxDepth, "maxDepth", 0);
11974 
11975     INDENT(-4);
11976     PRINT_SPACE
11977     if (commaNeeded)
11978         _OUT << "}," << std::endl;
11979     else
11980         _OUT << "}" << std::endl;
11981 }
print_VkViewport(const VkViewport * obj,const std::string & s,bool commaNeeded=true)11982 static void print_VkViewport(const VkViewport *obj, const std::string &s, bool commaNeeded = true)
11983 {
11984     PRINT_SPACE
11985     _OUT << "{" << std::endl;
11986     INDENT(4);
11987 
11988     print_float(obj->x, "x", 1);
11989 
11990     print_float(obj->y, "y", 1);
11991 
11992     print_float(obj->width, "width", 1);
11993 
11994     print_float(obj->height, "height", 1);
11995 
11996     print_float(obj->minDepth, "minDepth", 1);
11997 
11998     print_float(obj->maxDepth, "maxDepth", 0);
11999 
12000     INDENT(-4);
12001     PRINT_SPACE
12002     if (commaNeeded)
12003         _OUT << "}," << std::endl;
12004     else
12005         _OUT << "}" << std::endl;
12006 }
12007 
print_VkPipelineViewportStateCreateInfo(VkPipelineViewportStateCreateInfo obj,const std::string & s,bool commaNeeded=true)12008 static void print_VkPipelineViewportStateCreateInfo(VkPipelineViewportStateCreateInfo obj, const std::string &s,
12009                                                     bool commaNeeded = true)
12010 {
12011     PRINT_SPACE
12012     _OUT << "{" << std::endl;
12013     INDENT(4);
12014 
12015     print_VkStructureType(obj.sType, "sType", 1);
12016 
12017     if (obj.pNext)
12018     {
12019         dumpPNextChain(obj.pNext);
12020     }
12021     else
12022     {
12023         PRINT_SPACE
12024         _OUT << "\"pNext\":"
12025              << "\"NULL\""
12026              << "," << std::endl;
12027     }
12028 
12029     print_VkPipelineViewportStateCreateFlags(obj.flags, "flags", 1);
12030 
12031     print_uint32_t(obj.viewportCount, "viewportCount", 1);
12032 
12033     PRINT_SPACE
12034     _OUT << "\"pViewports\": " << std::endl;
12035     if (obj.pViewports)
12036     {
12037         PRINT_SPACE
12038         _OUT << "[" << std::endl;
12039         for (unsigned int i = 0; i < obj.viewportCount; i++)
12040         {
12041             if (i + 1 == obj.viewportCount)
12042                 print_VkViewport(obj.pViewports[i], "pViewports", 0);
12043             else
12044                 print_VkViewport(obj.pViewports[i], "pViewports", 1);
12045         }
12046         PRINT_SPACE
12047         _OUT << "]," << std::endl;
12048     }
12049     else
12050     {
12051         PRINT_SPACE _OUT << "\"NULL\""
12052                          << "," << std::endl;
12053     }
12054 
12055     print_uint32_t(obj.scissorCount, "scissorCount", 1);
12056 
12057     PRINT_SPACE
12058     _OUT << "\"pScissors\": " << std::endl;
12059     if (obj.pScissors)
12060     {
12061         PRINT_SPACE
12062         _OUT << "[" << std::endl;
12063         for (unsigned int i = 0; i < obj.scissorCount; i++)
12064         {
12065             if (i + 1 == obj.scissorCount)
12066                 print_VkRect2D(obj.pScissors[i], "pScissors", 0);
12067             else
12068                 print_VkRect2D(obj.pScissors[i], "pScissors", 1);
12069         }
12070         PRINT_SPACE
12071         _OUT << "]" << std::endl;
12072     }
12073     else
12074     {
12075         PRINT_SPACE _OUT << "\"NULL\""
12076                          << "" << std::endl;
12077     }
12078 
12079     INDENT(-4);
12080     PRINT_SPACE
12081     if (commaNeeded)
12082         _OUT << "}," << std::endl;
12083     else
12084         _OUT << "}" << std::endl;
12085 }
print_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo * obj,const std::string & s,bool commaNeeded=true)12086 static void print_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo *obj, const std::string &s,
12087                                                     bool commaNeeded = true)
12088 {
12089     PRINT_SPACE
12090     _OUT << "{" << std::endl;
12091     INDENT(4);
12092 
12093     print_VkStructureType(obj->sType, "sType", 1);
12094 
12095     if (obj->pNext)
12096     {
12097         dumpPNextChain(obj->pNext);
12098     }
12099     else
12100     {
12101         PRINT_SPACE
12102         _OUT << "\"pNext\":"
12103              << "\"NULL\""
12104              << "," << std::endl;
12105     }
12106 
12107     print_VkPipelineViewportStateCreateFlags(obj->flags, "flags", 1);
12108 
12109     print_uint32_t(obj->viewportCount, "viewportCount", 1);
12110 
12111     PRINT_SPACE
12112     _OUT << "\"pViewports\": " << std::endl;
12113     if (obj->pViewports)
12114     {
12115         PRINT_SPACE
12116         _OUT << "[" << std::endl;
12117         for (unsigned int i = 0; i < obj->viewportCount; i++)
12118         {
12119             if (i + 1 == obj->viewportCount)
12120                 print_VkViewport(obj->pViewports[i], "pViewports", 0);
12121             else
12122                 print_VkViewport(obj->pViewports[i], "pViewports", 1);
12123         }
12124         PRINT_SPACE
12125         _OUT << "]," << std::endl;
12126     }
12127     else
12128     {
12129         PRINT_SPACE _OUT << "\"NULL\""
12130                          << "," << std::endl;
12131     }
12132 
12133     print_uint32_t(obj->scissorCount, "scissorCount", 1);
12134 
12135     PRINT_SPACE
12136     _OUT << "\"pScissors\": " << std::endl;
12137     if (obj->pScissors)
12138     {
12139         PRINT_SPACE
12140         _OUT << "[" << std::endl;
12141         for (unsigned int i = 0; i < obj->scissorCount; i++)
12142         {
12143             if (i + 1 == obj->scissorCount)
12144                 print_VkRect2D(obj->pScissors[i], "pScissors", 0);
12145             else
12146                 print_VkRect2D(obj->pScissors[i], "pScissors", 1);
12147         }
12148         PRINT_SPACE
12149         _OUT << "]" << std::endl;
12150     }
12151     else
12152     {
12153         PRINT_SPACE _OUT << "\"NULL\""
12154                          << "" << std::endl;
12155     }
12156 
12157     INDENT(-4);
12158     PRINT_SPACE
12159     if (commaNeeded)
12160         _OUT << "}," << std::endl;
12161     else
12162         _OUT << "}" << std::endl;
12163 }
12164 
print_VkPipelineRasterizationStateCreateInfo(VkPipelineRasterizationStateCreateInfo obj,const std::string & s,bool commaNeeded=true)12165 static void print_VkPipelineRasterizationStateCreateInfo(VkPipelineRasterizationStateCreateInfo obj,
12166                                                          const std::string &s, bool commaNeeded = true)
12167 {
12168     PRINT_SPACE
12169     _OUT << "{" << std::endl;
12170     INDENT(4);
12171 
12172     print_VkStructureType(obj.sType, "sType", 1);
12173 
12174     if (obj.pNext)
12175     {
12176         dumpPNextChain(obj.pNext);
12177     }
12178     else
12179     {
12180         PRINT_SPACE
12181         _OUT << "\"pNext\":"
12182              << "\"NULL\""
12183              << "," << std::endl;
12184     }
12185 
12186     print_VkPipelineRasterizationStateCreateFlags(obj.flags, "flags", 1);
12187 
12188     print_VkBool32(obj.depthClampEnable, "depthClampEnable", 1);
12189 
12190     print_VkBool32(obj.rasterizerDiscardEnable, "rasterizerDiscardEnable", 1);
12191 
12192     print_VkPolygonMode(obj.polygonMode, "polygonMode", 1);
12193 
12194     print_VkCullModeFlags(obj.cullMode, "cullMode", 1);
12195 
12196     print_VkFrontFace(obj.frontFace, "frontFace", 1);
12197 
12198     print_VkBool32(obj.depthBiasEnable, "depthBiasEnable", 1);
12199 
12200     print_float(obj.depthBiasConstantFactor, "depthBiasConstantFactor", 1);
12201 
12202     print_float(obj.depthBiasClamp, "depthBiasClamp", 1);
12203 
12204     print_float(obj.depthBiasSlopeFactor, "depthBiasSlopeFactor", 1);
12205 
12206     print_float(obj.lineWidth, "lineWidth", 0);
12207 
12208     INDENT(-4);
12209     PRINT_SPACE
12210     if (commaNeeded)
12211         _OUT << "}," << std::endl;
12212     else
12213         _OUT << "}" << std::endl;
12214 }
print_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo * obj,const std::string & s,bool commaNeeded=true)12215 static void print_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo *obj,
12216                                                          const std::string &s, bool commaNeeded = true)
12217 {
12218     PRINT_SPACE
12219     _OUT << "{" << std::endl;
12220     INDENT(4);
12221 
12222     print_VkStructureType(obj->sType, "sType", 1);
12223 
12224     if (obj->pNext)
12225     {
12226         dumpPNextChain(obj->pNext);
12227     }
12228     else
12229     {
12230         PRINT_SPACE
12231         _OUT << "\"pNext\":"
12232              << "\"NULL\""
12233              << "," << std::endl;
12234     }
12235 
12236     print_VkPipelineRasterizationStateCreateFlags(obj->flags, "flags", 1);
12237 
12238     print_VkBool32(obj->depthClampEnable, "depthClampEnable", 1);
12239 
12240     print_VkBool32(obj->rasterizerDiscardEnable, "rasterizerDiscardEnable", 1);
12241 
12242     print_VkPolygonMode(obj->polygonMode, "polygonMode", 1);
12243 
12244     print_VkCullModeFlags(obj->cullMode, "cullMode", 1);
12245 
12246     print_VkFrontFace(obj->frontFace, "frontFace", 1);
12247 
12248     print_VkBool32(obj->depthBiasEnable, "depthBiasEnable", 1);
12249 
12250     print_float(obj->depthBiasConstantFactor, "depthBiasConstantFactor", 1);
12251 
12252     print_float(obj->depthBiasClamp, "depthBiasClamp", 1);
12253 
12254     print_float(obj->depthBiasSlopeFactor, "depthBiasSlopeFactor", 1);
12255 
12256     print_float(obj->lineWidth, "lineWidth", 0);
12257 
12258     INDENT(-4);
12259     PRINT_SPACE
12260     if (commaNeeded)
12261         _OUT << "}," << std::endl;
12262     else
12263         _OUT << "}" << std::endl;
12264 }
12265 
print_VkPipelineMultisampleStateCreateInfo(VkPipelineMultisampleStateCreateInfo obj,const std::string & s,bool commaNeeded=true)12266 static void print_VkPipelineMultisampleStateCreateInfo(VkPipelineMultisampleStateCreateInfo obj, const std::string &s,
12267                                                        bool commaNeeded = true)
12268 {
12269     PRINT_SPACE
12270     _OUT << "{" << std::endl;
12271     INDENT(4);
12272 
12273     print_VkStructureType(obj.sType, "sType", 1);
12274 
12275     if (obj.pNext)
12276     {
12277         dumpPNextChain(obj.pNext);
12278     }
12279     else
12280     {
12281         PRINT_SPACE
12282         _OUT << "\"pNext\":"
12283              << "\"NULL\""
12284              << "," << std::endl;
12285     }
12286 
12287     print_VkPipelineMultisampleStateCreateFlags(obj.flags, "flags", 1);
12288 
12289     print_VkSampleCountFlagBits(obj.rasterizationSamples, "rasterizationSamples", 1);
12290 
12291     print_VkBool32(obj.sampleShadingEnable, "sampleShadingEnable", 1);
12292 
12293     print_float(obj.minSampleShading, "minSampleShading", 1);
12294 
12295     uint32_t sampleMaskSize = ((obj.rasterizationSamples + 31) / 32);
12296     PRINT_SPACE
12297     _OUT << "\"pSampleMask\":" << std::endl;
12298     PRINT_SPACE
12299     if (obj.pSampleMask)
12300     {
12301         _OUT << "[" << std::endl;
12302         for (unsigned int i = 0; i < sampleMaskSize; i++)
12303         {
12304             bool isCommaNeeded = (i + 1) != sampleMaskSize;
12305             print_uint32_t(obj.pSampleMask[i], "", isCommaNeeded);
12306         }
12307         PRINT_SPACE
12308         _OUT << "]"
12309              << "," << std::endl;
12310     }
12311     else
12312     {
12313         _OUT << "\"NULL\""
12314              << "," << std::endl;
12315     }
12316 
12317     print_VkBool32(obj.alphaToCoverageEnable, "alphaToCoverageEnable", 1);
12318 
12319     print_VkBool32(obj.alphaToOneEnable, "alphaToOneEnable", 0);
12320 
12321     INDENT(-4);
12322     PRINT_SPACE
12323     if (commaNeeded)
12324         _OUT << "}," << std::endl;
12325     else
12326         _OUT << "}" << std::endl;
12327 }
print_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo * obj,const std::string & s,bool commaNeeded=true)12328 static void print_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo *obj,
12329                                                        const std::string &s, bool commaNeeded = true)
12330 {
12331     PRINT_SPACE
12332     _OUT << "{" << std::endl;
12333     INDENT(4);
12334 
12335     print_VkStructureType(obj->sType, "sType", 1);
12336 
12337     if (obj->pNext)
12338     {
12339         dumpPNextChain(obj->pNext);
12340     }
12341     else
12342     {
12343         PRINT_SPACE
12344         _OUT << "\"pNext\":"
12345              << "\"NULL\""
12346              << "," << std::endl;
12347     }
12348 
12349     print_VkPipelineMultisampleStateCreateFlags(obj->flags, "flags", 1);
12350 
12351     print_VkSampleCountFlagBits(obj->rasterizationSamples, "rasterizationSamples", 1);
12352 
12353     print_VkBool32(obj->sampleShadingEnable, "sampleShadingEnable", 1);
12354 
12355     print_float(obj->minSampleShading, "minSampleShading", 1);
12356 
12357     uint32_t sampleMaskSize = ((obj->rasterizationSamples + 31) / 32);
12358     PRINT_SPACE
12359     _OUT << "\"pSampleMask\":" << std::endl;
12360     PRINT_SPACE
12361     if (obj->pSampleMask)
12362     {
12363         _OUT << "[" << std::endl;
12364         for (unsigned int i = 0; i < sampleMaskSize; i++)
12365         {
12366             bool isCommaNeeded = (i + 1) != sampleMaskSize;
12367             print_uint32_t(obj->pSampleMask[i], "", isCommaNeeded);
12368         }
12369         PRINT_SPACE
12370         _OUT << "]"
12371              << "," << std::endl;
12372     }
12373     else
12374     {
12375         _OUT << "\"NULL\""
12376              << "," << std::endl;
12377     }
12378 
12379     print_VkBool32(obj->alphaToCoverageEnable, "alphaToCoverageEnable", 1);
12380 
12381     print_VkBool32(obj->alphaToOneEnable, "alphaToOneEnable", 0);
12382 
12383     INDENT(-4);
12384     PRINT_SPACE
12385     if (commaNeeded)
12386         _OUT << "}," << std::endl;
12387     else
12388         _OUT << "}" << std::endl;
12389 }
12390 
print_VkStencilOpState(VkStencilOpState obj,const std::string & s,bool commaNeeded=true)12391 static void print_VkStencilOpState(VkStencilOpState obj, const std::string &s, bool commaNeeded = true)
12392 {
12393     PRINT_SPACE
12394     _OUT << "{" << std::endl;
12395     INDENT(4);
12396 
12397     print_VkStencilOp(obj.failOp, "failOp", 1);
12398 
12399     print_VkStencilOp(obj.passOp, "passOp", 1);
12400 
12401     print_VkStencilOp(obj.depthFailOp, "depthFailOp", 1);
12402 
12403     print_VkCompareOp(obj.compareOp, "compareOp", 1);
12404 
12405     print_uint32_t(obj.compareMask, "compareMask", 1);
12406 
12407     print_uint32_t(obj.writeMask, "writeMask", 1);
12408 
12409     print_uint32_t(obj.reference, "reference", 0);
12410 
12411     INDENT(-4);
12412     PRINT_SPACE
12413     if (commaNeeded)
12414         _OUT << "}," << std::endl;
12415     else
12416         _OUT << "}" << std::endl;
12417 }
print_VkStencilOpState(const VkStencilOpState * obj,const std::string & s,bool commaNeeded=true)12418 static void print_VkStencilOpState(const VkStencilOpState *obj, const std::string &s, bool commaNeeded = true)
12419 {
12420     PRINT_SPACE
12421     _OUT << "{" << std::endl;
12422     INDENT(4);
12423 
12424     print_VkStencilOp(obj->failOp, "failOp", 1);
12425 
12426     print_VkStencilOp(obj->passOp, "passOp", 1);
12427 
12428     print_VkStencilOp(obj->depthFailOp, "depthFailOp", 1);
12429 
12430     print_VkCompareOp(obj->compareOp, "compareOp", 1);
12431 
12432     print_uint32_t(obj->compareMask, "compareMask", 1);
12433 
12434     print_uint32_t(obj->writeMask, "writeMask", 1);
12435 
12436     print_uint32_t(obj->reference, "reference", 0);
12437 
12438     INDENT(-4);
12439     PRINT_SPACE
12440     if (commaNeeded)
12441         _OUT << "}," << std::endl;
12442     else
12443         _OUT << "}" << std::endl;
12444 }
12445 
print_VkPipelineDepthStencilStateCreateInfo(VkPipelineDepthStencilStateCreateInfo obj,const std::string & s,bool commaNeeded=true)12446 static void print_VkPipelineDepthStencilStateCreateInfo(VkPipelineDepthStencilStateCreateInfo obj, const std::string &s,
12447                                                         bool commaNeeded = true)
12448 {
12449     PRINT_SPACE
12450     _OUT << "{" << std::endl;
12451     INDENT(4);
12452 
12453     print_VkStructureType(obj.sType, "sType", 1);
12454 
12455     if (obj.pNext)
12456     {
12457         dumpPNextChain(obj.pNext);
12458     }
12459     else
12460     {
12461         PRINT_SPACE
12462         _OUT << "\"pNext\":"
12463              << "\"NULL\""
12464              << "," << std::endl;
12465     }
12466 
12467     print_VkPipelineDepthStencilStateCreateFlags(obj.flags, "flags", 1);
12468 
12469     print_VkBool32(obj.depthTestEnable, "depthTestEnable", 1);
12470 
12471     print_VkBool32(obj.depthWriteEnable, "depthWriteEnable", 1);
12472 
12473     print_VkCompareOp(obj.depthCompareOp, "depthCompareOp", 1);
12474 
12475     print_VkBool32(obj.depthBoundsTestEnable, "depthBoundsTestEnable", 1);
12476 
12477     print_VkBool32(obj.stencilTestEnable, "stencilTestEnable", 1);
12478 
12479     PRINT_SPACE
12480     _OUT << "\"front\": " << std::endl;
12481     {
12482         print_VkStencilOpState(obj.front, "front", 1);
12483     }
12484 
12485     PRINT_SPACE
12486     _OUT << "\"back\": " << std::endl;
12487     {
12488         print_VkStencilOpState(obj.back, "back", 1);
12489     }
12490 
12491     print_float(obj.minDepthBounds, "minDepthBounds", 1);
12492 
12493     print_float(obj.maxDepthBounds, "maxDepthBounds", 0);
12494 
12495     INDENT(-4);
12496     PRINT_SPACE
12497     if (commaNeeded)
12498         _OUT << "}," << std::endl;
12499     else
12500         _OUT << "}" << std::endl;
12501 }
print_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo * obj,const std::string & s,bool commaNeeded=true)12502 static void print_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo *obj,
12503                                                         const std::string &s, bool commaNeeded = true)
12504 {
12505     PRINT_SPACE
12506     _OUT << "{" << std::endl;
12507     INDENT(4);
12508 
12509     print_VkStructureType(obj->sType, "sType", 1);
12510 
12511     if (obj->pNext)
12512     {
12513         dumpPNextChain(obj->pNext);
12514     }
12515     else
12516     {
12517         PRINT_SPACE
12518         _OUT << "\"pNext\":"
12519              << "\"NULL\""
12520              << "," << std::endl;
12521     }
12522 
12523     print_VkPipelineDepthStencilStateCreateFlags(obj->flags, "flags", 1);
12524 
12525     print_VkBool32(obj->depthTestEnable, "depthTestEnable", 1);
12526 
12527     print_VkBool32(obj->depthWriteEnable, "depthWriteEnable", 1);
12528 
12529     print_VkCompareOp(obj->depthCompareOp, "depthCompareOp", 1);
12530 
12531     print_VkBool32(obj->depthBoundsTestEnable, "depthBoundsTestEnable", 1);
12532 
12533     print_VkBool32(obj->stencilTestEnable, "stencilTestEnable", 1);
12534 
12535     PRINT_SPACE
12536     _OUT << "\"front\": " << std::endl;
12537     {
12538         print_VkStencilOpState(obj->front, "front", 1);
12539     }
12540 
12541     PRINT_SPACE
12542     _OUT << "\"back\": " << std::endl;
12543     {
12544         print_VkStencilOpState(obj->back, "back", 1);
12545     }
12546 
12547     print_float(obj->minDepthBounds, "minDepthBounds", 1);
12548 
12549     print_float(obj->maxDepthBounds, "maxDepthBounds", 0);
12550 
12551     INDENT(-4);
12552     PRINT_SPACE
12553     if (commaNeeded)
12554         _OUT << "}," << std::endl;
12555     else
12556         _OUT << "}" << std::endl;
12557 }
12558 
print_VkPipelineColorBlendAttachmentState(VkPipelineColorBlendAttachmentState obj,const std::string & s,bool commaNeeded=true)12559 static void print_VkPipelineColorBlendAttachmentState(VkPipelineColorBlendAttachmentState obj, const std::string &s,
12560                                                       bool commaNeeded = true)
12561 {
12562     PRINT_SPACE
12563     _OUT << "{" << std::endl;
12564     INDENT(4);
12565 
12566     print_VkBool32(obj.blendEnable, "blendEnable", 1);
12567 
12568     print_VkBlendFactor(obj.srcColorBlendFactor, "srcColorBlendFactor", 1);
12569 
12570     print_VkBlendFactor(obj.dstColorBlendFactor, "dstColorBlendFactor", 1);
12571 
12572     print_VkBlendOp(obj.colorBlendOp, "colorBlendOp", 1);
12573 
12574     print_VkBlendFactor(obj.srcAlphaBlendFactor, "srcAlphaBlendFactor", 1);
12575 
12576     print_VkBlendFactor(obj.dstAlphaBlendFactor, "dstAlphaBlendFactor", 1);
12577 
12578     print_VkBlendOp(obj.alphaBlendOp, "alphaBlendOp", 1);
12579 
12580     print_VkColorComponentFlags(obj.colorWriteMask, "colorWriteMask", 0);
12581 
12582     INDENT(-4);
12583     PRINT_SPACE
12584     if (commaNeeded)
12585         _OUT << "}," << std::endl;
12586     else
12587         _OUT << "}" << std::endl;
12588 }
print_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState * obj,const std::string & s,bool commaNeeded=true)12589 static void print_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState *obj,
12590                                                       const std::string &s, bool commaNeeded = true)
12591 {
12592     PRINT_SPACE
12593     _OUT << "{" << std::endl;
12594     INDENT(4);
12595 
12596     print_VkBool32(obj->blendEnable, "blendEnable", 1);
12597 
12598     print_VkBlendFactor(obj->srcColorBlendFactor, "srcColorBlendFactor", 1);
12599 
12600     print_VkBlendFactor(obj->dstColorBlendFactor, "dstColorBlendFactor", 1);
12601 
12602     print_VkBlendOp(obj->colorBlendOp, "colorBlendOp", 1);
12603 
12604     print_VkBlendFactor(obj->srcAlphaBlendFactor, "srcAlphaBlendFactor", 1);
12605 
12606     print_VkBlendFactor(obj->dstAlphaBlendFactor, "dstAlphaBlendFactor", 1);
12607 
12608     print_VkBlendOp(obj->alphaBlendOp, "alphaBlendOp", 1);
12609 
12610     print_VkColorComponentFlags(obj->colorWriteMask, "colorWriteMask", 0);
12611 
12612     INDENT(-4);
12613     PRINT_SPACE
12614     if (commaNeeded)
12615         _OUT << "}," << std::endl;
12616     else
12617         _OUT << "}" << std::endl;
12618 }
12619 
print_VkPipelineColorBlendStateCreateInfo(VkPipelineColorBlendStateCreateInfo obj,const std::string & s,bool commaNeeded=true)12620 static void print_VkPipelineColorBlendStateCreateInfo(VkPipelineColorBlendStateCreateInfo obj, const std::string &s,
12621                                                       bool commaNeeded = true)
12622 {
12623     PRINT_SPACE
12624     _OUT << "{" << std::endl;
12625     INDENT(4);
12626 
12627     print_VkStructureType(obj.sType, "sType", 1);
12628 
12629     if (obj.pNext)
12630     {
12631         dumpPNextChain(obj.pNext);
12632     }
12633     else
12634     {
12635         PRINT_SPACE
12636         _OUT << "\"pNext\":"
12637              << "\"NULL\""
12638              << "," << std::endl;
12639     }
12640 
12641     print_VkPipelineColorBlendStateCreateFlags(obj.flags, "flags", 1);
12642 
12643     print_VkBool32(obj.logicOpEnable, "logicOpEnable", 1);
12644 
12645     print_VkLogicOp(obj.logicOp, "logicOp", 1);
12646 
12647     print_uint32_t(obj.attachmentCount, "attachmentCount", 1);
12648 
12649     PRINT_SPACE
12650     _OUT << "\"pAttachments\": " << std::endl;
12651     if (obj.pAttachments)
12652     {
12653         PRINT_SPACE
12654         _OUT << "[" << std::endl;
12655         for (unsigned int i = 0; i < obj.attachmentCount; i++)
12656         {
12657             if (i + 1 == obj.attachmentCount)
12658                 print_VkPipelineColorBlendAttachmentState(obj.pAttachments[i], "pAttachments", 0);
12659             else
12660                 print_VkPipelineColorBlendAttachmentState(obj.pAttachments[i], "pAttachments", 1);
12661         }
12662         PRINT_SPACE
12663         _OUT << "]," << std::endl;
12664     }
12665     else
12666     {
12667         PRINT_SPACE _OUT << "\"NULL\""
12668                          << "," << std::endl;
12669     }
12670 
12671     PRINT_SPACE
12672     _OUT << "\"blendConstants\":" << std::endl;
12673     PRINT_SPACE
12674     _OUT << "[" << std::endl;
12675     for (unsigned int i = 0; i < 4; i++)
12676     {
12677         bool isCommaNeeded = (i + 1) != 4;
12678         print_float(obj.blendConstants[i], "", isCommaNeeded);
12679     }
12680     PRINT_SPACE
12681     _OUT << "]"
12682          << "" << std::endl;
12683 
12684     INDENT(-4);
12685     PRINT_SPACE
12686     if (commaNeeded)
12687         _OUT << "}," << std::endl;
12688     else
12689         _OUT << "}" << std::endl;
12690 }
print_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo * obj,const std::string & s,bool commaNeeded=true)12691 static void print_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo *obj,
12692                                                       const std::string &s, bool commaNeeded = true)
12693 {
12694     PRINT_SPACE
12695     _OUT << "{" << std::endl;
12696     INDENT(4);
12697 
12698     print_VkStructureType(obj->sType, "sType", 1);
12699 
12700     if (obj->pNext)
12701     {
12702         dumpPNextChain(obj->pNext);
12703     }
12704     else
12705     {
12706         PRINT_SPACE
12707         _OUT << "\"pNext\":"
12708              << "\"NULL\""
12709              << "," << std::endl;
12710     }
12711 
12712     print_VkPipelineColorBlendStateCreateFlags(obj->flags, "flags", 1);
12713 
12714     print_VkBool32(obj->logicOpEnable, "logicOpEnable", 1);
12715 
12716     print_VkLogicOp(obj->logicOp, "logicOp", 1);
12717 
12718     print_uint32_t(obj->attachmentCount, "attachmentCount", 1);
12719 
12720     PRINT_SPACE
12721     _OUT << "\"pAttachments\": " << std::endl;
12722     if (obj->pAttachments)
12723     {
12724         PRINT_SPACE
12725         _OUT << "[" << std::endl;
12726         for (unsigned int i = 0; i < obj->attachmentCount; i++)
12727         {
12728             if (i + 1 == obj->attachmentCount)
12729                 print_VkPipelineColorBlendAttachmentState(obj->pAttachments[i], "pAttachments", 0);
12730             else
12731                 print_VkPipelineColorBlendAttachmentState(obj->pAttachments[i], "pAttachments", 1);
12732         }
12733         PRINT_SPACE
12734         _OUT << "]," << std::endl;
12735     }
12736     else
12737     {
12738         PRINT_SPACE _OUT << "\"NULL\""
12739                          << "," << std::endl;
12740     }
12741 
12742     PRINT_SPACE
12743     _OUT << "\"blendConstants\":" << std::endl;
12744     PRINT_SPACE
12745     _OUT << "[" << std::endl;
12746     for (unsigned int i = 0; i < 4; i++)
12747     {
12748         bool isCommaNeeded = (i + 1) != 4;
12749         print_float(obj->blendConstants[i], "", isCommaNeeded);
12750     }
12751     PRINT_SPACE
12752     _OUT << "]"
12753          << "" << std::endl;
12754 
12755     INDENT(-4);
12756     PRINT_SPACE
12757     if (commaNeeded)
12758         _OUT << "}," << std::endl;
12759     else
12760         _OUT << "}" << std::endl;
12761 }
12762 
print_VkPipelineDynamicStateCreateInfo(VkPipelineDynamicStateCreateInfo obj,const std::string & s,bool commaNeeded=true)12763 static void print_VkPipelineDynamicStateCreateInfo(VkPipelineDynamicStateCreateInfo obj, const std::string &s,
12764                                                    bool commaNeeded = true)
12765 {
12766     PRINT_SPACE
12767     _OUT << "{" << std::endl;
12768     INDENT(4);
12769 
12770     print_VkStructureType(obj.sType, "sType", 1);
12771 
12772     if (obj.pNext)
12773     {
12774         dumpPNextChain(obj.pNext);
12775     }
12776     else
12777     {
12778         PRINT_SPACE
12779         _OUT << "\"pNext\":"
12780              << "\"NULL\""
12781              << "," << std::endl;
12782     }
12783 
12784     print_VkPipelineDynamicStateCreateFlags(obj.flags, "flags", 1);
12785 
12786     print_uint32_t(obj.dynamicStateCount, "dynamicStateCount", 1);
12787 
12788     PRINT_SPACE
12789     _OUT << "\"pDynamicStates\":" << std::endl;
12790     PRINT_SPACE
12791     if (obj.pDynamicStates)
12792     {
12793         _OUT << "[" << std::endl;
12794         for (unsigned int i = 0; i < obj.dynamicStateCount; i++)
12795         {
12796             bool isCommaNeeded = (i + 1) != obj.dynamicStateCount;
12797             print_VkDynamicState(obj.pDynamicStates[i], "", isCommaNeeded);
12798         }
12799         PRINT_SPACE
12800         _OUT << "]"
12801              << "" << std::endl;
12802     }
12803     else
12804     {
12805         _OUT << "\"NULL\""
12806              << "" << std::endl;
12807     }
12808 
12809     INDENT(-4);
12810     PRINT_SPACE
12811     if (commaNeeded)
12812         _OUT << "}," << std::endl;
12813     else
12814         _OUT << "}" << std::endl;
12815 }
print_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo * obj,const std::string & s,bool commaNeeded=true)12816 static void print_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo *obj, const std::string &s,
12817                                                    bool commaNeeded = true)
12818 {
12819     PRINT_SPACE
12820     _OUT << "{" << std::endl;
12821     INDENT(4);
12822 
12823     print_VkStructureType(obj->sType, "sType", 1);
12824 
12825     if (obj->pNext)
12826     {
12827         dumpPNextChain(obj->pNext);
12828     }
12829     else
12830     {
12831         PRINT_SPACE
12832         _OUT << "\"pNext\":"
12833              << "\"NULL\""
12834              << "," << std::endl;
12835     }
12836 
12837     print_VkPipelineDynamicStateCreateFlags(obj->flags, "flags", 1);
12838 
12839     print_uint32_t(obj->dynamicStateCount, "dynamicStateCount", 1);
12840 
12841     PRINT_SPACE
12842     _OUT << "\"pDynamicStates\":" << std::endl;
12843     PRINT_SPACE
12844     if (obj->pDynamicStates)
12845     {
12846         _OUT << "[" << std::endl;
12847         for (unsigned int i = 0; i < obj->dynamicStateCount; i++)
12848         {
12849             bool isCommaNeeded = (i + 1) != obj->dynamicStateCount;
12850             print_VkDynamicState(obj->pDynamicStates[i], "", isCommaNeeded);
12851         }
12852         PRINT_SPACE
12853         _OUT << "]"
12854              << "" << std::endl;
12855     }
12856     else
12857     {
12858         _OUT << "\"NULL\""
12859              << "" << std::endl;
12860     }
12861 
12862     INDENT(-4);
12863     PRINT_SPACE
12864     if (commaNeeded)
12865         _OUT << "}," << std::endl;
12866     else
12867         _OUT << "}" << std::endl;
12868 }
12869 
print_VkGraphicsPipelineCreateInfo(VkGraphicsPipelineCreateInfo obj,const std::string & s,bool commaNeeded=true)12870 static void print_VkGraphicsPipelineCreateInfo(VkGraphicsPipelineCreateInfo obj, const std::string &s,
12871                                                bool commaNeeded = true)
12872 {
12873     PRINT_SPACE
12874     _OUT << "{" << std::endl;
12875     INDENT(4);
12876 
12877     print_VkStructureType(obj.sType, "sType", 1);
12878 
12879     if (obj.pNext)
12880     {
12881         dumpPNextChain(obj.pNext);
12882     }
12883     else
12884     {
12885         PRINT_SPACE
12886         _OUT << "\"pNext\":"
12887              << "\"NULL\""
12888              << "," << std::endl;
12889     }
12890 
12891     print_VkPipelineCreateFlags(obj.flags, "flags", 1);
12892 
12893     print_uint32_t(obj.stageCount, "stageCount", 1);
12894 
12895     PRINT_SPACE
12896     _OUT << "\"pStages\": " << std::endl;
12897     if (obj.pStages)
12898     {
12899         PRINT_SPACE
12900         _OUT << "[" << std::endl;
12901         for (unsigned int i = 0; i < obj.stageCount; i++)
12902         {
12903             if (i + 1 == obj.stageCount)
12904                 print_VkPipelineShaderStageCreateInfo(obj.pStages[i], "pStages", 0);
12905             else
12906                 print_VkPipelineShaderStageCreateInfo(obj.pStages[i], "pStages", 1);
12907         }
12908         PRINT_SPACE
12909         _OUT << "]," << std::endl;
12910     }
12911     else
12912     {
12913         PRINT_SPACE _OUT << "\"NULL\""
12914                          << "," << std::endl;
12915     }
12916 
12917     PRINT_SPACE
12918     _OUT << "\"pVertexInputState\": " << std::endl;
12919     if (obj.pVertexInputState)
12920     {
12921         print_VkPipelineVertexInputStateCreateInfo(obj.pVertexInputState, "pVertexInputState", 1);
12922     }
12923     else
12924     {
12925         PRINT_SPACE _OUT << "\"NULL\""
12926                          << "," << std::endl;
12927     }
12928 
12929     PRINT_SPACE
12930     _OUT << "\"pInputAssemblyState\": " << std::endl;
12931     if (obj.pInputAssemblyState)
12932     {
12933         print_VkPipelineInputAssemblyStateCreateInfo(obj.pInputAssemblyState, "pInputAssemblyState", 1);
12934     }
12935     else
12936     {
12937         PRINT_SPACE _OUT << "\"NULL\""
12938                          << "," << std::endl;
12939     }
12940 
12941     PRINT_SPACE
12942     _OUT << "\"pTessellationState\": " << std::endl;
12943     if (obj.pTessellationState)
12944     {
12945         print_VkPipelineTessellationStateCreateInfo(obj.pTessellationState, "pTessellationState", 1);
12946     }
12947     else
12948     {
12949         PRINT_SPACE _OUT << "\"NULL\""
12950                          << "," << std::endl;
12951     }
12952 
12953     PRINT_SPACE
12954     _OUT << "\"pViewportState\": " << std::endl;
12955     if (obj.pViewportState)
12956     {
12957         print_VkPipelineViewportStateCreateInfo(obj.pViewportState, "pViewportState", 1);
12958     }
12959     else
12960     {
12961         PRINT_SPACE _OUT << "\"NULL\""
12962                          << "," << std::endl;
12963     }
12964 
12965     PRINT_SPACE
12966     _OUT << "\"pRasterizationState\": " << std::endl;
12967     if (obj.pRasterizationState)
12968     {
12969         print_VkPipelineRasterizationStateCreateInfo(obj.pRasterizationState, "pRasterizationState", 1);
12970     }
12971     else
12972     {
12973         PRINT_SPACE _OUT << "\"NULL\""
12974                          << "," << std::endl;
12975     }
12976 
12977     PRINT_SPACE
12978     _OUT << "\"pMultisampleState\": " << std::endl;
12979     if (obj.pMultisampleState)
12980     {
12981         print_VkPipelineMultisampleStateCreateInfo(obj.pMultisampleState, "pMultisampleState", 1);
12982     }
12983     else
12984     {
12985         PRINT_SPACE _OUT << "\"NULL\""
12986                          << "," << std::endl;
12987     }
12988 
12989     PRINT_SPACE
12990     _OUT << "\"pDepthStencilState\": " << std::endl;
12991     if (obj.pDepthStencilState)
12992     {
12993         print_VkPipelineDepthStencilStateCreateInfo(obj.pDepthStencilState, "pDepthStencilState", 1);
12994     }
12995     else
12996     {
12997         PRINT_SPACE _OUT << "\"NULL\""
12998                          << "," << std::endl;
12999     }
13000 
13001     PRINT_SPACE
13002     _OUT << "\"pColorBlendState\": " << std::endl;
13003     if (obj.pColorBlendState)
13004     {
13005         print_VkPipelineColorBlendStateCreateInfo(obj.pColorBlendState, "pColorBlendState", 1);
13006     }
13007     else
13008     {
13009         PRINT_SPACE _OUT << "\"NULL\""
13010                          << "," << std::endl;
13011     }
13012 
13013     PRINT_SPACE
13014     _OUT << "\"pDynamicState\": " << std::endl;
13015     if (obj.pDynamicState)
13016     {
13017         print_VkPipelineDynamicStateCreateInfo(obj.pDynamicState, "pDynamicState", 1);
13018     }
13019     else
13020     {
13021         PRINT_SPACE _OUT << "\"NULL\""
13022                          << "," << std::endl;
13023     }
13024 
13025     // CTS : required value
13026     PRINT_SPACE _OUT << "\""
13027                      << "layout"
13028                      << "\""
13029                      << " : " << obj.layout.getInternal() << "," << std::endl;
13030 
13031     // CTS : required value
13032     PRINT_SPACE _OUT << "\""
13033                      << "renderPass"
13034                      << "\""
13035                      << " : " << obj.renderPass.getInternal() << "," << std::endl;
13036 
13037     print_uint32_t(obj.subpass, "subpass", 1);
13038 
13039     // CTS : required value
13040     PRINT_SPACE _OUT << "\""
13041                      << "basePipelineHandle"
13042                      << "\""
13043                      << " : "
13044                      << "\""
13045                      << "\"," << std::endl;
13046 
13047     print_int32_t(obj.basePipelineIndex, "basePipelineIndex", 0);
13048 
13049     INDENT(-4);
13050     PRINT_SPACE
13051     if (commaNeeded)
13052         _OUT << "}," << std::endl;
13053     else
13054         _OUT << "}" << std::endl;
13055 }
print_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo * obj,const std::string & s,bool commaNeeded=true)13056 static void print_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo *obj, const std::string &s,
13057                                                bool commaNeeded = true)
13058 {
13059     PRINT_SPACE
13060     _OUT << "{" << std::endl;
13061     INDENT(4);
13062 
13063     print_VkStructureType(obj->sType, "sType", 1);
13064 
13065     if (obj->pNext)
13066     {
13067         dumpPNextChain(obj->pNext);
13068     }
13069     else
13070     {
13071         PRINT_SPACE
13072         _OUT << "\"pNext\":"
13073              << "\"NULL\""
13074              << "," << std::endl;
13075     }
13076 
13077     print_VkPipelineCreateFlags(obj->flags, "flags", 1);
13078 
13079     print_uint32_t(obj->stageCount, "stageCount", 1);
13080 
13081     PRINT_SPACE
13082     _OUT << "\"pStages\": " << std::endl;
13083     if (obj->pStages)
13084     {
13085         PRINT_SPACE
13086         _OUT << "[" << std::endl;
13087         for (unsigned int i = 0; i < obj->stageCount; i++)
13088         {
13089             if (i + 1 == obj->stageCount)
13090                 print_VkPipelineShaderStageCreateInfo(obj->pStages[i], "pStages", 0);
13091             else
13092                 print_VkPipelineShaderStageCreateInfo(obj->pStages[i], "pStages", 1);
13093         }
13094         PRINT_SPACE
13095         _OUT << "]," << std::endl;
13096     }
13097     else
13098     {
13099         PRINT_SPACE _OUT << "\"NULL\""
13100                          << "," << std::endl;
13101     }
13102 
13103     PRINT_SPACE
13104     _OUT << "\"pVertexInputState\": " << std::endl;
13105     if (obj->pVertexInputState)
13106     {
13107         print_VkPipelineVertexInputStateCreateInfo(obj->pVertexInputState, "pVertexInputState", 1);
13108     }
13109     else
13110     {
13111         PRINT_SPACE _OUT << "\"NULL\""
13112                          << "," << std::endl;
13113     }
13114 
13115     PRINT_SPACE
13116     _OUT << "\"pInputAssemblyState\": " << std::endl;
13117     if (obj->pInputAssemblyState)
13118     {
13119         print_VkPipelineInputAssemblyStateCreateInfo(obj->pInputAssemblyState, "pInputAssemblyState", 1);
13120     }
13121     else
13122     {
13123         PRINT_SPACE _OUT << "\"NULL\""
13124                          << "," << std::endl;
13125     }
13126 
13127     PRINT_SPACE
13128     _OUT << "\"pTessellationState\": " << std::endl;
13129     if (obj->pTessellationState)
13130     {
13131         print_VkPipelineTessellationStateCreateInfo(obj->pTessellationState, "pTessellationState", 1);
13132     }
13133     else
13134     {
13135         PRINT_SPACE _OUT << "\"NULL\""
13136                          << "," << std::endl;
13137     }
13138 
13139     PRINT_SPACE
13140     _OUT << "\"pViewportState\": " << std::endl;
13141     if (obj->pViewportState)
13142     {
13143         print_VkPipelineViewportStateCreateInfo(obj->pViewportState, "pViewportState", 1);
13144     }
13145     else
13146     {
13147         PRINT_SPACE _OUT << "\"NULL\""
13148                          << "," << std::endl;
13149     }
13150 
13151     PRINT_SPACE
13152     _OUT << "\"pRasterizationState\": " << std::endl;
13153     if (obj->pRasterizationState)
13154     {
13155         print_VkPipelineRasterizationStateCreateInfo(obj->pRasterizationState, "pRasterizationState", 1);
13156     }
13157     else
13158     {
13159         PRINT_SPACE _OUT << "\"NULL\""
13160                          << "," << std::endl;
13161     }
13162 
13163     PRINT_SPACE
13164     _OUT << "\"pMultisampleState\": " << std::endl;
13165     if (obj->pMultisampleState)
13166     {
13167         print_VkPipelineMultisampleStateCreateInfo(obj->pMultisampleState, "pMultisampleState", 1);
13168     }
13169     else
13170     {
13171         PRINT_SPACE _OUT << "\"NULL\""
13172                          << "," << std::endl;
13173     }
13174 
13175     PRINT_SPACE
13176     _OUT << "\"pDepthStencilState\": " << std::endl;
13177     if (obj->pDepthStencilState)
13178     {
13179         print_VkPipelineDepthStencilStateCreateInfo(obj->pDepthStencilState, "pDepthStencilState", 1);
13180     }
13181     else
13182     {
13183         PRINT_SPACE _OUT << "\"NULL\""
13184                          << "," << std::endl;
13185     }
13186 
13187     PRINT_SPACE
13188     _OUT << "\"pColorBlendState\": " << std::endl;
13189     if (obj->pColorBlendState)
13190     {
13191         print_VkPipelineColorBlendStateCreateInfo(obj->pColorBlendState, "pColorBlendState", 1);
13192     }
13193     else
13194     {
13195         PRINT_SPACE _OUT << "\"NULL\""
13196                          << "," << std::endl;
13197     }
13198 
13199     PRINT_SPACE
13200     _OUT << "\"pDynamicState\": " << std::endl;
13201     if (obj->pDynamicState)
13202     {
13203         print_VkPipelineDynamicStateCreateInfo(obj->pDynamicState, "pDynamicState", 1);
13204     }
13205     else
13206     {
13207         PRINT_SPACE _OUT << "\"NULL\""
13208                          << "," << std::endl;
13209     }
13210 
13211     // CTS : required value
13212     PRINT_SPACE _OUT << "\""
13213                      << "layout"
13214                      << "\""
13215                      << " : " << obj->layout.getInternal() << "," << std::endl;
13216 
13217     // CTS : required value
13218     PRINT_SPACE _OUT << "\""
13219                      << "renderPass"
13220                      << "\""
13221                      << " : " << obj->renderPass.getInternal() << "," << std::endl;
13222 
13223     print_uint32_t(obj->subpass, "subpass", 1);
13224 
13225     // CTS : required value
13226     PRINT_SPACE _OUT << "\""
13227                      << "basePipelineHandle"
13228                      << "\""
13229                      << " : "
13230                      << "\""
13231                      << "\"," << std::endl;
13232 
13233     print_int32_t(obj->basePipelineIndex, "basePipelineIndex", 0);
13234 
13235     INDENT(-4);
13236     PRINT_SPACE
13237     if (commaNeeded)
13238         _OUT << "}," << std::endl;
13239     else
13240         _OUT << "}" << std::endl;
13241 }
13242 
print_VkPushConstantRange(VkPushConstantRange obj,const std::string & s,bool commaNeeded=true)13243 static void print_VkPushConstantRange(VkPushConstantRange obj, const std::string &s, bool commaNeeded = true)
13244 {
13245     PRINT_SPACE
13246     _OUT << "{" << std::endl;
13247     INDENT(4);
13248 
13249     print_VkShaderStageFlags(obj.stageFlags, "stageFlags", 1);
13250 
13251     print_uint32_t(obj.offset, "offset", 1);
13252 
13253     print_uint32_t(obj.size, "size", 0);
13254 
13255     INDENT(-4);
13256     PRINT_SPACE
13257     if (commaNeeded)
13258         _OUT << "}," << std::endl;
13259     else
13260         _OUT << "}" << std::endl;
13261 }
print_VkPushConstantRange(const VkPushConstantRange * obj,const std::string & s,bool commaNeeded=true)13262 static void print_VkPushConstantRange(const VkPushConstantRange *obj, const std::string &s, bool commaNeeded = true)
13263 {
13264     PRINT_SPACE
13265     _OUT << "{" << std::endl;
13266     INDENT(4);
13267 
13268     print_VkShaderStageFlags(obj->stageFlags, "stageFlags", 1);
13269 
13270     print_uint32_t(obj->offset, "offset", 1);
13271 
13272     print_uint32_t(obj->size, "size", 0);
13273 
13274     INDENT(-4);
13275     PRINT_SPACE
13276     if (commaNeeded)
13277         _OUT << "}," << std::endl;
13278     else
13279         _OUT << "}" << std::endl;
13280 }
13281 
print_VkPipelineLayoutCreateInfo(VkPipelineLayoutCreateInfo obj,const std::string & s,bool commaNeeded=true)13282 static void print_VkPipelineLayoutCreateInfo(VkPipelineLayoutCreateInfo obj, const std::string &s,
13283                                              bool commaNeeded = true)
13284 {
13285     PRINT_SPACE
13286     _OUT << "{" << std::endl;
13287     INDENT(4);
13288 
13289     print_VkStructureType(obj.sType, "sType", 1);
13290 
13291     if (obj.pNext)
13292     {
13293         dumpPNextChain(obj.pNext);
13294     }
13295     else
13296     {
13297         PRINT_SPACE
13298         _OUT << "\"pNext\":"
13299              << "\"NULL\""
13300              << "," << std::endl;
13301     }
13302 
13303     print_VkPipelineLayoutCreateFlags(obj.flags, "flags", 1);
13304 
13305     print_uint32_t(obj.setLayoutCount, "setLayoutCount", 1);
13306 
13307     PRINT_SPACE
13308     _OUT << "\"pSetLayouts\":" << std::endl;
13309     PRINT_SPACE
13310     if (obj.pSetLayouts)
13311     {
13312         _OUT << "[" << std::endl;
13313         for (unsigned int i = 0; i < obj.setLayoutCount; i++)
13314         {
13315             bool isCommaNeeded = (i + 1) != obj.setLayoutCount;
13316             if (isCommaNeeded)
13317             {
13318                 PRINT_SPACE
13319                 _OUT << obj.pSetLayouts[i].getInternal() << "," << std::endl;
13320             }
13321             else
13322             {
13323                 PRINT_SPACE
13324                 _OUT << obj.pSetLayouts[i].getInternal() << std::endl;
13325             }
13326         }
13327         PRINT_SPACE
13328         _OUT << "]"
13329              << "," << std::endl;
13330     }
13331     else
13332     {
13333         _OUT << "\"NULL\""
13334              << "," << std::endl;
13335     }
13336 
13337     print_uint32_t(obj.pushConstantRangeCount, "pushConstantRangeCount", 1);
13338 
13339     PRINT_SPACE
13340     _OUT << "\"pPushConstantRanges\": " << std::endl;
13341     if (obj.pPushConstantRanges)
13342     {
13343         PRINT_SPACE
13344         _OUT << "[" << std::endl;
13345         for (unsigned int i = 0; i < obj.pushConstantRangeCount; i++)
13346         {
13347             if (i + 1 == obj.pushConstantRangeCount)
13348                 print_VkPushConstantRange(obj.pPushConstantRanges[i], "pPushConstantRanges", 0);
13349             else
13350                 print_VkPushConstantRange(obj.pPushConstantRanges[i], "pPushConstantRanges", 1);
13351         }
13352         PRINT_SPACE
13353         _OUT << "]" << std::endl;
13354     }
13355     else
13356     {
13357         PRINT_SPACE _OUT << "\"NULL\""
13358                          << "" << std::endl;
13359     }
13360 
13361     INDENT(-4);
13362     PRINT_SPACE
13363     if (commaNeeded)
13364         _OUT << "}," << std::endl;
13365     else
13366         _OUT << "}" << std::endl;
13367 }
print_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo * obj,const std::string & s,bool commaNeeded=true)13368 static void print_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo *obj, const std::string &s,
13369                                              bool commaNeeded = true)
13370 {
13371     PRINT_SPACE
13372     _OUT << "{" << std::endl;
13373     INDENT(4);
13374 
13375     print_VkStructureType(obj->sType, "sType", 1);
13376 
13377     if (obj->pNext)
13378     {
13379         dumpPNextChain(obj->pNext);
13380     }
13381     else
13382     {
13383         PRINT_SPACE
13384         _OUT << "\"pNext\":"
13385              << "\"NULL\""
13386              << "," << std::endl;
13387     }
13388 
13389     print_VkPipelineLayoutCreateFlags(obj->flags, "flags", 1);
13390 
13391     print_uint32_t(obj->setLayoutCount, "setLayoutCount", 1);
13392 
13393     PRINT_SPACE
13394     _OUT << "\"pSetLayouts\":" << std::endl;
13395     PRINT_SPACE
13396     if (obj->pSetLayouts)
13397     {
13398         _OUT << "[" << std::endl;
13399         for (unsigned int i = 0; i < obj->setLayoutCount; i++)
13400         {
13401             bool isCommaNeeded = (i + 1) != obj->setLayoutCount;
13402             if (isCommaNeeded)
13403             {
13404                 PRINT_SPACE
13405                 _OUT << obj->pSetLayouts[i].getInternal() << "," << std::endl;
13406             }
13407             else
13408             {
13409                 PRINT_SPACE
13410                 _OUT << obj->pSetLayouts[i].getInternal() << std::endl;
13411             }
13412         }
13413         PRINT_SPACE
13414         _OUT << "]"
13415              << "," << std::endl;
13416     }
13417     else
13418     {
13419         _OUT << "\"NULL\""
13420              << "," << std::endl;
13421     }
13422 
13423     print_uint32_t(obj->pushConstantRangeCount, "pushConstantRangeCount", 1);
13424 
13425     PRINT_SPACE
13426     _OUT << "\"pPushConstantRanges\": " << std::endl;
13427     if (obj->pPushConstantRanges)
13428     {
13429         PRINT_SPACE
13430         _OUT << "[" << std::endl;
13431         for (unsigned int i = 0; i < obj->pushConstantRangeCount; i++)
13432         {
13433             if (i + 1 == obj->pushConstantRangeCount)
13434                 print_VkPushConstantRange(obj->pPushConstantRanges[i], "pPushConstantRanges", 0);
13435             else
13436                 print_VkPushConstantRange(obj->pPushConstantRanges[i], "pPushConstantRanges", 1);
13437         }
13438         PRINT_SPACE
13439         _OUT << "]" << std::endl;
13440     }
13441     else
13442     {
13443         PRINT_SPACE _OUT << "\"NULL\""
13444                          << "" << std::endl;
13445     }
13446 
13447     INDENT(-4);
13448     PRINT_SPACE
13449     if (commaNeeded)
13450         _OUT << "}," << std::endl;
13451     else
13452         _OUT << "}" << std::endl;
13453 }
13454 
print_VkSamplerCreateInfo(VkSamplerCreateInfo obj,const std::string & s,bool commaNeeded=true)13455 static void print_VkSamplerCreateInfo(VkSamplerCreateInfo obj, const std::string &s, bool commaNeeded = true)
13456 {
13457     PRINT_SPACE
13458     _OUT << "{" << std::endl;
13459     INDENT(4);
13460 
13461     print_VkStructureType(obj.sType, "sType", 1);
13462 
13463     if (obj.pNext)
13464     {
13465         dumpPNextChain(obj.pNext);
13466     }
13467     else
13468     {
13469         PRINT_SPACE
13470         _OUT << "\"pNext\":"
13471              << "\"NULL\""
13472              << "," << std::endl;
13473     }
13474 
13475     print_VkSamplerCreateFlags(obj.flags, "flags", 1);
13476 
13477     print_VkFilter(obj.magFilter, "magFilter", 1);
13478 
13479     print_VkFilter(obj.minFilter, "minFilter", 1);
13480 
13481     print_VkSamplerMipmapMode(obj.mipmapMode, "mipmapMode", 1);
13482 
13483     print_VkSamplerAddressMode(obj.addressModeU, "addressModeU", 1);
13484 
13485     print_VkSamplerAddressMode(obj.addressModeV, "addressModeV", 1);
13486 
13487     print_VkSamplerAddressMode(obj.addressModeW, "addressModeW", 1);
13488 
13489     print_float(obj.mipLodBias, "mipLodBias", 1);
13490 
13491     print_VkBool32(obj.anisotropyEnable, "anisotropyEnable", 1);
13492 
13493     print_float(obj.maxAnisotropy, "maxAnisotropy", 1);
13494 
13495     print_VkBool32(obj.compareEnable, "compareEnable", 1);
13496 
13497     print_VkCompareOp(obj.compareOp, "compareOp", 1);
13498 
13499     print_float(obj.minLod, "minLod", 1);
13500 
13501     print_float(obj.maxLod, "maxLod", 1);
13502 
13503     print_VkBorderColor(obj.borderColor, "borderColor", 1);
13504 
13505     print_VkBool32(obj.unnormalizedCoordinates, "unnormalizedCoordinates", 0);
13506 
13507     INDENT(-4);
13508     PRINT_SPACE
13509     if (commaNeeded)
13510         _OUT << "}," << std::endl;
13511     else
13512         _OUT << "}" << std::endl;
13513 }
print_VkSamplerCreateInfo(const VkSamplerCreateInfo * obj,const std::string & s,bool commaNeeded=true)13514 static void print_VkSamplerCreateInfo(const VkSamplerCreateInfo *obj, const std::string &s, bool commaNeeded = true)
13515 {
13516     PRINT_SPACE
13517     _OUT << "{" << std::endl;
13518     INDENT(4);
13519 
13520     print_VkStructureType(obj->sType, "sType", 1);
13521 
13522     if (obj->pNext)
13523     {
13524         dumpPNextChain(obj->pNext);
13525     }
13526     else
13527     {
13528         PRINT_SPACE
13529         _OUT << "\"pNext\":"
13530              << "\"NULL\""
13531              << "," << std::endl;
13532     }
13533 
13534     print_VkSamplerCreateFlags(obj->flags, "flags", 1);
13535 
13536     print_VkFilter(obj->magFilter, "magFilter", 1);
13537 
13538     print_VkFilter(obj->minFilter, "minFilter", 1);
13539 
13540     print_VkSamplerMipmapMode(obj->mipmapMode, "mipmapMode", 1);
13541 
13542     print_VkSamplerAddressMode(obj->addressModeU, "addressModeU", 1);
13543 
13544     print_VkSamplerAddressMode(obj->addressModeV, "addressModeV", 1);
13545 
13546     print_VkSamplerAddressMode(obj->addressModeW, "addressModeW", 1);
13547 
13548     print_float(obj->mipLodBias, "mipLodBias", 1);
13549 
13550     print_VkBool32(obj->anisotropyEnable, "anisotropyEnable", 1);
13551 
13552     print_float(obj->maxAnisotropy, "maxAnisotropy", 1);
13553 
13554     print_VkBool32(obj->compareEnable, "compareEnable", 1);
13555 
13556     print_VkCompareOp(obj->compareOp, "compareOp", 1);
13557 
13558     print_float(obj->minLod, "minLod", 1);
13559 
13560     print_float(obj->maxLod, "maxLod", 1);
13561 
13562     print_VkBorderColor(obj->borderColor, "borderColor", 1);
13563 
13564     print_VkBool32(obj->unnormalizedCoordinates, "unnormalizedCoordinates", 0);
13565 
13566     INDENT(-4);
13567     PRINT_SPACE
13568     if (commaNeeded)
13569         _OUT << "}," << std::endl;
13570     else
13571         _OUT << "}" << std::endl;
13572 }
13573 
print_VkCopyDescriptorSet(VkCopyDescriptorSet obj,const std::string & s,bool commaNeeded=true)13574 static void print_VkCopyDescriptorSet(VkCopyDescriptorSet obj, const std::string &s, bool commaNeeded = true)
13575 {
13576     PRINT_SPACE
13577     _OUT << "{" << std::endl;
13578     INDENT(4);
13579 
13580     print_VkStructureType(obj.sType, "sType", 1);
13581 
13582     if (obj.pNext)
13583     {
13584         dumpPNextChain(obj.pNext);
13585     }
13586     else
13587     {
13588         PRINT_SPACE
13589         _OUT << "\"pNext\":"
13590              << "\"NULL\""
13591              << "," << std::endl;
13592     }
13593 
13594     // CTS : required value
13595     PRINT_SPACE _OUT << "\""
13596                      << "srcSet"
13597                      << "\""
13598                      << " : "
13599                      << "\""
13600                      << "\"," << std::endl;
13601 
13602     print_uint32_t(obj.srcBinding, "srcBinding", 1);
13603 
13604     print_uint32_t(obj.srcArrayElement, "srcArrayElement", 1);
13605 
13606     // CTS : required value
13607     PRINT_SPACE _OUT << "\""
13608                      << "dstSet"
13609                      << "\""
13610                      << " : "
13611                      << "\""
13612                      << "\"," << std::endl;
13613 
13614     print_uint32_t(obj.dstBinding, "dstBinding", 1);
13615 
13616     print_uint32_t(obj.dstArrayElement, "dstArrayElement", 1);
13617 
13618     print_uint32_t(obj.descriptorCount, "descriptorCount", 0);
13619 
13620     INDENT(-4);
13621     PRINT_SPACE
13622     if (commaNeeded)
13623         _OUT << "}," << std::endl;
13624     else
13625         _OUT << "}" << std::endl;
13626 }
print_VkCopyDescriptorSet(const VkCopyDescriptorSet * obj,const std::string & s,bool commaNeeded=true)13627 static void print_VkCopyDescriptorSet(const VkCopyDescriptorSet *obj, const std::string &s, bool commaNeeded = true)
13628 {
13629     PRINT_SPACE
13630     _OUT << "{" << std::endl;
13631     INDENT(4);
13632 
13633     print_VkStructureType(obj->sType, "sType", 1);
13634 
13635     if (obj->pNext)
13636     {
13637         dumpPNextChain(obj->pNext);
13638     }
13639     else
13640     {
13641         PRINT_SPACE
13642         _OUT << "\"pNext\":"
13643              << "\"NULL\""
13644              << "," << std::endl;
13645     }
13646 
13647     // CTS : required value
13648     PRINT_SPACE _OUT << "\""
13649                      << "srcSet"
13650                      << "\""
13651                      << " : "
13652                      << "\""
13653                      << "\"," << std::endl;
13654 
13655     print_uint32_t(obj->srcBinding, "srcBinding", 1);
13656 
13657     print_uint32_t(obj->srcArrayElement, "srcArrayElement", 1);
13658 
13659     // CTS : required value
13660     PRINT_SPACE _OUT << "\""
13661                      << "dstSet"
13662                      << "\""
13663                      << " : "
13664                      << "\""
13665                      << "\"," << std::endl;
13666 
13667     print_uint32_t(obj->dstBinding, "dstBinding", 1);
13668 
13669     print_uint32_t(obj->dstArrayElement, "dstArrayElement", 1);
13670 
13671     print_uint32_t(obj->descriptorCount, "descriptorCount", 0);
13672 
13673     INDENT(-4);
13674     PRINT_SPACE
13675     if (commaNeeded)
13676         _OUT << "}," << std::endl;
13677     else
13678         _OUT << "}" << std::endl;
13679 }
13680 
print_VkDescriptorBufferInfo(VkDescriptorBufferInfo obj,const std::string & s,bool commaNeeded=true)13681 static void print_VkDescriptorBufferInfo(VkDescriptorBufferInfo obj, const std::string &s, bool commaNeeded = true)
13682 {
13683     PRINT_SPACE
13684     _OUT << "{" << std::endl;
13685     INDENT(4);
13686 
13687     // CTS : required value
13688     PRINT_SPACE _OUT << "\""
13689                      << "buffer"
13690                      << "\""
13691                      << " : "
13692                      << "\""
13693                      << "\"," << std::endl;
13694 
13695     print_VkDeviceSize(obj.offset, "offset", 1);
13696 
13697     print_VkDeviceSize(obj.range, "range", 0);
13698 
13699     INDENT(-4);
13700     PRINT_SPACE
13701     if (commaNeeded)
13702         _OUT << "}," << std::endl;
13703     else
13704         _OUT << "}" << std::endl;
13705 }
print_VkDescriptorBufferInfo(const VkDescriptorBufferInfo * obj,const std::string & s,bool commaNeeded=true)13706 static void print_VkDescriptorBufferInfo(const VkDescriptorBufferInfo *obj, const std::string &s,
13707                                          bool commaNeeded = true)
13708 {
13709     PRINT_SPACE
13710     _OUT << "{" << std::endl;
13711     INDENT(4);
13712 
13713     // CTS : required value
13714     PRINT_SPACE _OUT << "\""
13715                      << "buffer"
13716                      << "\""
13717                      << " : "
13718                      << "\""
13719                      << "\"," << std::endl;
13720 
13721     print_VkDeviceSize(obj->offset, "offset", 1);
13722 
13723     print_VkDeviceSize(obj->range, "range", 0);
13724 
13725     INDENT(-4);
13726     PRINT_SPACE
13727     if (commaNeeded)
13728         _OUT << "}," << std::endl;
13729     else
13730         _OUT << "}" << std::endl;
13731 }
13732 
print_VkDescriptorImageInfo(VkDescriptorImageInfo obj,const std::string & s,bool commaNeeded=true)13733 static void print_VkDescriptorImageInfo(VkDescriptorImageInfo obj, const std::string &s, bool commaNeeded = true)
13734 {
13735     PRINT_SPACE
13736     _OUT << "{" << std::endl;
13737     INDENT(4);
13738 
13739     // CTS : required value
13740     PRINT_SPACE _OUT << "\""
13741                      << "sampler"
13742                      << "\""
13743                      << " : "
13744                      << "\""
13745                      << "\"," << std::endl;
13746 
13747     // CTS : required value
13748     PRINT_SPACE _OUT << "\""
13749                      << "imageView"
13750                      << "\""
13751                      << " : "
13752                      << "\""
13753                      << "\"," << std::endl;
13754 
13755     print_VkImageLayout(obj.imageLayout, "imageLayout", 0);
13756 
13757     INDENT(-4);
13758     PRINT_SPACE
13759     if (commaNeeded)
13760         _OUT << "}," << std::endl;
13761     else
13762         _OUT << "}" << std::endl;
13763 }
print_VkDescriptorImageInfo(const VkDescriptorImageInfo * obj,const std::string & s,bool commaNeeded=true)13764 static void print_VkDescriptorImageInfo(const VkDescriptorImageInfo *obj, const std::string &s, bool commaNeeded = true)
13765 {
13766     PRINT_SPACE
13767     _OUT << "{" << std::endl;
13768     INDENT(4);
13769 
13770     // CTS : required value
13771     PRINT_SPACE _OUT << "\""
13772                      << "sampler"
13773                      << "\""
13774                      << " : "
13775                      << "\""
13776                      << "\"," << std::endl;
13777 
13778     // CTS : required value
13779     PRINT_SPACE _OUT << "\""
13780                      << "imageView"
13781                      << "\""
13782                      << " : "
13783                      << "\""
13784                      << "\"," << std::endl;
13785 
13786     print_VkImageLayout(obj->imageLayout, "imageLayout", 0);
13787 
13788     INDENT(-4);
13789     PRINT_SPACE
13790     if (commaNeeded)
13791         _OUT << "}," << std::endl;
13792     else
13793         _OUT << "}" << std::endl;
13794 }
13795 
print_VkDescriptorPoolSize(VkDescriptorPoolSize obj,const std::string & s,bool commaNeeded=true)13796 static void print_VkDescriptorPoolSize(VkDescriptorPoolSize obj, const std::string &s, bool commaNeeded = true)
13797 {
13798     PRINT_SPACE
13799     _OUT << "{" << std::endl;
13800     INDENT(4);
13801 
13802     print_VkDescriptorType(obj.type, "type", 1);
13803 
13804     print_uint32_t(obj.descriptorCount, "descriptorCount", 0);
13805 
13806     INDENT(-4);
13807     PRINT_SPACE
13808     if (commaNeeded)
13809         _OUT << "}," << std::endl;
13810     else
13811         _OUT << "}" << std::endl;
13812 }
print_VkDescriptorPoolSize(const VkDescriptorPoolSize * obj,const std::string & s,bool commaNeeded=true)13813 static void print_VkDescriptorPoolSize(const VkDescriptorPoolSize *obj, const std::string &s, bool commaNeeded = true)
13814 {
13815     PRINT_SPACE
13816     _OUT << "{" << std::endl;
13817     INDENT(4);
13818 
13819     print_VkDescriptorType(obj->type, "type", 1);
13820 
13821     print_uint32_t(obj->descriptorCount, "descriptorCount", 0);
13822 
13823     INDENT(-4);
13824     PRINT_SPACE
13825     if (commaNeeded)
13826         _OUT << "}," << std::endl;
13827     else
13828         _OUT << "}" << std::endl;
13829 }
13830 
print_VkDescriptorPoolCreateInfo(VkDescriptorPoolCreateInfo obj,const std::string & s,bool commaNeeded=true)13831 static void print_VkDescriptorPoolCreateInfo(VkDescriptorPoolCreateInfo obj, const std::string &s,
13832                                              bool commaNeeded = true)
13833 {
13834     PRINT_SPACE
13835     _OUT << "{" << std::endl;
13836     INDENT(4);
13837 
13838     print_VkStructureType(obj.sType, "sType", 1);
13839 
13840     if (obj.pNext)
13841     {
13842         dumpPNextChain(obj.pNext);
13843     }
13844     else
13845     {
13846         PRINT_SPACE
13847         _OUT << "\"pNext\":"
13848              << "\"NULL\""
13849              << "," << std::endl;
13850     }
13851 
13852     print_VkDescriptorPoolCreateFlags(obj.flags, "flags", 1);
13853 
13854     print_uint32_t(obj.maxSets, "maxSets", 1);
13855 
13856     print_uint32_t(obj.poolSizeCount, "poolSizeCount", 1);
13857 
13858     PRINT_SPACE
13859     _OUT << "\"pPoolSizes\": " << std::endl;
13860     if (obj.pPoolSizes)
13861     {
13862         PRINT_SPACE
13863         _OUT << "[" << std::endl;
13864         for (unsigned int i = 0; i < obj.poolSizeCount; i++)
13865         {
13866             if (i + 1 == obj.poolSizeCount)
13867                 print_VkDescriptorPoolSize(obj.pPoolSizes[i], "pPoolSizes", 0);
13868             else
13869                 print_VkDescriptorPoolSize(obj.pPoolSizes[i], "pPoolSizes", 1);
13870         }
13871         PRINT_SPACE
13872         _OUT << "]" << std::endl;
13873     }
13874     else
13875     {
13876         PRINT_SPACE _OUT << "\"NULL\""
13877                          << "" << std::endl;
13878     }
13879 
13880     INDENT(-4);
13881     PRINT_SPACE
13882     if (commaNeeded)
13883         _OUT << "}," << std::endl;
13884     else
13885         _OUT << "}" << std::endl;
13886 }
print_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo * obj,const std::string & s,bool commaNeeded=true)13887 static void print_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo *obj, const std::string &s,
13888                                              bool commaNeeded = true)
13889 {
13890     PRINT_SPACE
13891     _OUT << "{" << std::endl;
13892     INDENT(4);
13893 
13894     print_VkStructureType(obj->sType, "sType", 1);
13895 
13896     if (obj->pNext)
13897     {
13898         dumpPNextChain(obj->pNext);
13899     }
13900     else
13901     {
13902         PRINT_SPACE
13903         _OUT << "\"pNext\":"
13904              << "\"NULL\""
13905              << "," << std::endl;
13906     }
13907 
13908     print_VkDescriptorPoolCreateFlags(obj->flags, "flags", 1);
13909 
13910     print_uint32_t(obj->maxSets, "maxSets", 1);
13911 
13912     print_uint32_t(obj->poolSizeCount, "poolSizeCount", 1);
13913 
13914     PRINT_SPACE
13915     _OUT << "\"pPoolSizes\": " << std::endl;
13916     if (obj->pPoolSizes)
13917     {
13918         PRINT_SPACE
13919         _OUT << "[" << std::endl;
13920         for (unsigned int i = 0; i < obj->poolSizeCount; i++)
13921         {
13922             if (i + 1 == obj->poolSizeCount)
13923                 print_VkDescriptorPoolSize(obj->pPoolSizes[i], "pPoolSizes", 0);
13924             else
13925                 print_VkDescriptorPoolSize(obj->pPoolSizes[i], "pPoolSizes", 1);
13926         }
13927         PRINT_SPACE
13928         _OUT << "]" << std::endl;
13929     }
13930     else
13931     {
13932         PRINT_SPACE _OUT << "\"NULL\""
13933                          << "" << std::endl;
13934     }
13935 
13936     INDENT(-4);
13937     PRINT_SPACE
13938     if (commaNeeded)
13939         _OUT << "}," << std::endl;
13940     else
13941         _OUT << "}" << std::endl;
13942 }
13943 
print_VkDescriptorSetAllocateInfo(VkDescriptorSetAllocateInfo obj,const std::string & s,bool commaNeeded=true)13944 static void print_VkDescriptorSetAllocateInfo(VkDescriptorSetAllocateInfo obj, const std::string &s,
13945                                               bool commaNeeded = true)
13946 {
13947     PRINT_SPACE
13948     _OUT << "{" << std::endl;
13949     INDENT(4);
13950 
13951     print_VkStructureType(obj.sType, "sType", 1);
13952 
13953     if (obj.pNext)
13954     {
13955         dumpPNextChain(obj.pNext);
13956     }
13957     else
13958     {
13959         PRINT_SPACE
13960         _OUT << "\"pNext\":"
13961              << "\"NULL\""
13962              << "," << std::endl;
13963     }
13964 
13965     // CTS : required value
13966     PRINT_SPACE _OUT << "\""
13967                      << "descriptorPool"
13968                      << "\""
13969                      << " : "
13970                      << "\""
13971                      << "\"," << std::endl;
13972 
13973     print_uint32_t(obj.descriptorSetCount, "descriptorSetCount", 1);
13974 
13975     PRINT_SPACE
13976     _OUT << "\"pSetLayouts\":" << std::endl;
13977     PRINT_SPACE
13978     if (obj.pSetLayouts)
13979     {
13980         _OUT << "[" << std::endl;
13981         for (unsigned int i = 0; i < obj.descriptorSetCount; i++)
13982         {
13983             std::stringstream tmp;
13984             tmp << "pSetLayouts"
13985                 << "_" << i;
13986             bool isCommaNeeded = (i + 1) != obj.descriptorSetCount;
13987             print_VkDescriptorSetLayout(obj.pSetLayouts[i], tmp.str(), isCommaNeeded);
13988         }
13989         PRINT_SPACE
13990         _OUT << "]"
13991              << "" << std::endl;
13992     }
13993     else
13994     {
13995         _OUT << "\"NULL\""
13996              << "" << std::endl;
13997     }
13998 
13999     INDENT(-4);
14000     PRINT_SPACE
14001     if (commaNeeded)
14002         _OUT << "}," << std::endl;
14003     else
14004         _OUT << "}" << std::endl;
14005 }
print_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo * obj,const std::string & s,bool commaNeeded=true)14006 static void print_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo *obj, const std::string &s,
14007                                               bool commaNeeded = true)
14008 {
14009     PRINT_SPACE
14010     _OUT << "{" << std::endl;
14011     INDENT(4);
14012 
14013     print_VkStructureType(obj->sType, "sType", 1);
14014 
14015     if (obj->pNext)
14016     {
14017         dumpPNextChain(obj->pNext);
14018     }
14019     else
14020     {
14021         PRINT_SPACE
14022         _OUT << "\"pNext\":"
14023              << "\"NULL\""
14024              << "," << std::endl;
14025     }
14026 
14027     // CTS : required value
14028     PRINT_SPACE _OUT << "\""
14029                      << "descriptorPool"
14030                      << "\""
14031                      << " : "
14032                      << "\""
14033                      << "\"," << std::endl;
14034 
14035     print_uint32_t(obj->descriptorSetCount, "descriptorSetCount", 1);
14036 
14037     PRINT_SPACE
14038     _OUT << "\"pSetLayouts\":" << std::endl;
14039     PRINT_SPACE
14040     if (obj->pSetLayouts)
14041     {
14042         _OUT << "[" << std::endl;
14043         for (unsigned int i = 0; i < obj->descriptorSetCount; i++)
14044         {
14045             std::stringstream tmp;
14046             tmp << "pSetLayouts"
14047                 << "_" << i;
14048             bool isCommaNeeded = (i + 1) != obj->descriptorSetCount;
14049             print_VkDescriptorSetLayout(obj->pSetLayouts[i], tmp.str(), isCommaNeeded);
14050         }
14051         PRINT_SPACE
14052         _OUT << "]"
14053              << "" << std::endl;
14054     }
14055     else
14056     {
14057         _OUT << "\"NULL\""
14058              << "" << std::endl;
14059     }
14060 
14061     INDENT(-4);
14062     PRINT_SPACE
14063     if (commaNeeded)
14064         _OUT << "}," << std::endl;
14065     else
14066         _OUT << "}" << std::endl;
14067 }
14068 
print_VkDescriptorSetLayoutBinding(VkDescriptorSetLayoutBinding obj,const std::string & s,bool commaNeeded=true)14069 static void print_VkDescriptorSetLayoutBinding(VkDescriptorSetLayoutBinding obj, const std::string &s,
14070                                                bool commaNeeded = true)
14071 {
14072     PRINT_SPACE
14073     _OUT << "{" << std::endl;
14074     INDENT(4);
14075 
14076     print_uint32_t(obj.binding, "binding", 1);
14077 
14078     print_VkDescriptorType(obj.descriptorType, "descriptorType", 1);
14079 
14080     print_uint32_t(obj.descriptorCount, "descriptorCount", 1);
14081 
14082     print_VkShaderStageFlags(obj.stageFlags, "stageFlags", 1);
14083 
14084     PRINT_SPACE
14085     _OUT << "\"pImmutableSamplers\":" << std::endl;
14086     PRINT_SPACE
14087     if (obj.pImmutableSamplers)
14088     {
14089         _OUT << "[" << std::endl;
14090         for (unsigned int i = 0; i < obj.descriptorCount; i++)
14091         {
14092             bool isCommaNeeded = (i + 1) != obj.descriptorCount;
14093             if (isCommaNeeded)
14094             {
14095                 PRINT_SPACE
14096                 _OUT << obj.pImmutableSamplers[i].getInternal() << "," << std::endl;
14097             }
14098             else
14099             {
14100                 PRINT_SPACE
14101                 _OUT << obj.pImmutableSamplers[i].getInternal() << std::endl;
14102             }
14103         }
14104         PRINT_SPACE
14105         _OUT << "]"
14106              << "" << std::endl;
14107     }
14108     else
14109     {
14110         _OUT << "\"NULL\""
14111              << "" << std::endl;
14112     }
14113 
14114     INDENT(-4);
14115     PRINT_SPACE
14116     if (commaNeeded)
14117         _OUT << "}," << std::endl;
14118     else
14119         _OUT << "}" << std::endl;
14120 }
print_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding * obj,const std::string & s,bool commaNeeded=true)14121 static void print_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding *obj, const std::string &s,
14122                                                bool commaNeeded = true)
14123 {
14124     PRINT_SPACE
14125     _OUT << "{" << std::endl;
14126     INDENT(4);
14127 
14128     print_uint32_t(obj->binding, "binding", 1);
14129 
14130     print_VkDescriptorType(obj->descriptorType, "descriptorType", 1);
14131 
14132     print_uint32_t(obj->descriptorCount, "descriptorCount", 1);
14133 
14134     print_VkShaderStageFlags(obj->stageFlags, "stageFlags", 1);
14135 
14136     PRINT_SPACE
14137     _OUT << "\"pImmutableSamplers\":" << std::endl;
14138     PRINT_SPACE
14139     if (obj->pImmutableSamplers)
14140     {
14141         _OUT << "[" << std::endl;
14142         for (unsigned int i = 0; i < obj->descriptorCount; i++)
14143         {
14144             bool isCommaNeeded = (i + 1) != obj->descriptorCount;
14145             if (isCommaNeeded)
14146             {
14147                 PRINT_SPACE
14148                 _OUT << obj->pImmutableSamplers[i].getInternal() << "," << std::endl;
14149             }
14150             else
14151             {
14152                 PRINT_SPACE
14153                 _OUT << obj->pImmutableSamplers[i].getInternal() << std::endl;
14154             }
14155         }
14156         PRINT_SPACE
14157         _OUT << "]"
14158              << "" << std::endl;
14159     }
14160     else
14161     {
14162         _OUT << "\"NULL\""
14163              << "" << std::endl;
14164     }
14165 
14166     INDENT(-4);
14167     PRINT_SPACE
14168     if (commaNeeded)
14169         _OUT << "}," << std::endl;
14170     else
14171         _OUT << "}" << std::endl;
14172 }
14173 
print_VkDescriptorSetLayoutCreateInfo(VkDescriptorSetLayoutCreateInfo obj,const std::string & s,bool commaNeeded=true)14174 static void print_VkDescriptorSetLayoutCreateInfo(VkDescriptorSetLayoutCreateInfo obj, const std::string &s,
14175                                                   bool commaNeeded = true)
14176 {
14177     PRINT_SPACE
14178     _OUT << "{" << std::endl;
14179     INDENT(4);
14180 
14181     print_VkStructureType(obj.sType, "sType", 1);
14182 
14183     if (obj.pNext)
14184     {
14185         dumpPNextChain(obj.pNext);
14186     }
14187     else
14188     {
14189         PRINT_SPACE
14190         _OUT << "\"pNext\":"
14191              << "\"NULL\""
14192              << "," << std::endl;
14193     }
14194 
14195     print_VkDescriptorSetLayoutCreateFlags(obj.flags, "flags", 1);
14196 
14197     print_uint32_t(obj.bindingCount, "bindingCount", 1);
14198 
14199     PRINT_SPACE
14200     _OUT << "\"pBindings\": " << std::endl;
14201     if (obj.pBindings)
14202     {
14203         PRINT_SPACE
14204         _OUT << "[" << std::endl;
14205         for (unsigned int i = 0; i < obj.bindingCount; i++)
14206         {
14207             if (i + 1 == obj.bindingCount)
14208                 print_VkDescriptorSetLayoutBinding(obj.pBindings[i], "pBindings", 0);
14209             else
14210                 print_VkDescriptorSetLayoutBinding(obj.pBindings[i], "pBindings", 1);
14211         }
14212         PRINT_SPACE
14213         _OUT << "]" << std::endl;
14214     }
14215     else
14216     {
14217         PRINT_SPACE _OUT << "\"NULL\""
14218                          << "" << std::endl;
14219     }
14220 
14221     INDENT(-4);
14222     PRINT_SPACE
14223     if (commaNeeded)
14224         _OUT << "}," << std::endl;
14225     else
14226         _OUT << "}" << std::endl;
14227 }
print_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo * obj,const std::string & s,bool commaNeeded=true)14228 static void print_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo *obj, const std::string &s,
14229                                                   bool commaNeeded = true)
14230 {
14231     PRINT_SPACE
14232     _OUT << "{" << std::endl;
14233     INDENT(4);
14234 
14235     print_VkStructureType(obj->sType, "sType", 1);
14236 
14237     if (obj->pNext)
14238     {
14239         dumpPNextChain(obj->pNext);
14240     }
14241     else
14242     {
14243         PRINT_SPACE
14244         _OUT << "\"pNext\":"
14245              << "\"NULL\""
14246              << "," << std::endl;
14247     }
14248 
14249     print_VkDescriptorSetLayoutCreateFlags(obj->flags, "flags", 1);
14250 
14251     print_uint32_t(obj->bindingCount, "bindingCount", 1);
14252 
14253     PRINT_SPACE
14254     _OUT << "\"pBindings\": " << std::endl;
14255     if (obj->pBindings)
14256     {
14257         PRINT_SPACE
14258         _OUT << "[" << std::endl;
14259         for (unsigned int i = 0; i < obj->bindingCount; i++)
14260         {
14261             if (i + 1 == obj->bindingCount)
14262                 print_VkDescriptorSetLayoutBinding(obj->pBindings[i], "pBindings", 0);
14263             else
14264                 print_VkDescriptorSetLayoutBinding(obj->pBindings[i], "pBindings", 1);
14265         }
14266         PRINT_SPACE
14267         _OUT << "]" << std::endl;
14268     }
14269     else
14270     {
14271         PRINT_SPACE _OUT << "\"NULL\""
14272                          << "" << std::endl;
14273     }
14274 
14275     INDENT(-4);
14276     PRINT_SPACE
14277     if (commaNeeded)
14278         _OUT << "}," << std::endl;
14279     else
14280         _OUT << "}" << std::endl;
14281 }
14282 
print_VkWriteDescriptorSet(VkWriteDescriptorSet obj,const std::string & s,bool commaNeeded=true)14283 static void print_VkWriteDescriptorSet(VkWriteDescriptorSet obj, const std::string &s, bool commaNeeded = true)
14284 {
14285     PRINT_SPACE
14286     _OUT << "{" << std::endl;
14287     INDENT(4);
14288 
14289     print_VkStructureType(obj.sType, "sType", 1);
14290 
14291     if (obj.pNext)
14292     {
14293         dumpPNextChain(obj.pNext);
14294     }
14295     else
14296     {
14297         PRINT_SPACE
14298         _OUT << "\"pNext\":"
14299              << "\"NULL\""
14300              << "," << std::endl;
14301     }
14302 
14303     // CTS : required value
14304     PRINT_SPACE _OUT << "\""
14305                      << "dstSet"
14306                      << "\""
14307                      << " : "
14308                      << "\""
14309                      << "\"," << std::endl;
14310 
14311     print_uint32_t(obj.dstBinding, "dstBinding", 1);
14312 
14313     print_uint32_t(obj.dstArrayElement, "dstArrayElement", 1);
14314 
14315     print_uint32_t(obj.descriptorCount, "descriptorCount", 1);
14316 
14317     print_VkDescriptorType(obj.descriptorType, "descriptorType", 1);
14318 
14319     PRINT_SPACE
14320     _OUT << "\"pImageInfo\": " << std::endl;
14321     if (obj.pImageInfo)
14322     {
14323         PRINT_SPACE
14324         _OUT << "[" << std::endl;
14325         for (unsigned int i = 0; i < obj.descriptorCount; i++)
14326         {
14327             if (i + 1 == obj.descriptorCount)
14328                 print_VkDescriptorImageInfo(obj.pImageInfo[i], "pImageInfo", 0);
14329             else
14330                 print_VkDescriptorImageInfo(obj.pImageInfo[i], "pImageInfo", 1);
14331         }
14332         PRINT_SPACE
14333         _OUT << "]," << std::endl;
14334     }
14335     else
14336     {
14337         PRINT_SPACE _OUT << "\"NULL\""
14338                          << "," << std::endl;
14339     }
14340 
14341     PRINT_SPACE
14342     _OUT << "\"pBufferInfo\": " << std::endl;
14343     if (obj.pBufferInfo)
14344     {
14345         PRINT_SPACE
14346         _OUT << "[" << std::endl;
14347         for (unsigned int i = 0; i < obj.descriptorCount; i++)
14348         {
14349             if (i + 1 == obj.descriptorCount)
14350                 print_VkDescriptorBufferInfo(obj.pBufferInfo[i], "pBufferInfo", 0);
14351             else
14352                 print_VkDescriptorBufferInfo(obj.pBufferInfo[i], "pBufferInfo", 1);
14353         }
14354         PRINT_SPACE
14355         _OUT << "]," << std::endl;
14356     }
14357     else
14358     {
14359         PRINT_SPACE _OUT << "\"NULL\""
14360                          << "," << std::endl;
14361     }
14362 
14363     PRINT_SPACE
14364     _OUT << "\"pTexelBufferView\":" << std::endl;
14365     PRINT_SPACE
14366     if (obj.pTexelBufferView)
14367     {
14368         _OUT << "[" << std::endl;
14369         for (unsigned int i = 0; i < obj.descriptorCount; i++)
14370         {
14371             std::stringstream tmp;
14372             tmp << "pTexelBufferView"
14373                 << "_" << i;
14374             bool isCommaNeeded = (i + 1) != obj.descriptorCount;
14375             print_VkBufferView(obj.pTexelBufferView[i], tmp.str(), isCommaNeeded);
14376         }
14377         PRINT_SPACE
14378         _OUT << "]"
14379              << "" << std::endl;
14380     }
14381     else
14382     {
14383         _OUT << "\"NULL\""
14384              << "" << std::endl;
14385     }
14386 
14387     INDENT(-4);
14388     PRINT_SPACE
14389     if (commaNeeded)
14390         _OUT << "}," << std::endl;
14391     else
14392         _OUT << "}" << std::endl;
14393 }
print_VkWriteDescriptorSet(const VkWriteDescriptorSet * obj,const std::string & s,bool commaNeeded=true)14394 static void print_VkWriteDescriptorSet(const VkWriteDescriptorSet *obj, const std::string &s, bool commaNeeded = true)
14395 {
14396     PRINT_SPACE
14397     _OUT << "{" << std::endl;
14398     INDENT(4);
14399 
14400     print_VkStructureType(obj->sType, "sType", 1);
14401 
14402     if (obj->pNext)
14403     {
14404         dumpPNextChain(obj->pNext);
14405     }
14406     else
14407     {
14408         PRINT_SPACE
14409         _OUT << "\"pNext\":"
14410              << "\"NULL\""
14411              << "," << std::endl;
14412     }
14413 
14414     // CTS : required value
14415     PRINT_SPACE _OUT << "\""
14416                      << "dstSet"
14417                      << "\""
14418                      << " : "
14419                      << "\""
14420                      << "\"," << std::endl;
14421 
14422     print_uint32_t(obj->dstBinding, "dstBinding", 1);
14423 
14424     print_uint32_t(obj->dstArrayElement, "dstArrayElement", 1);
14425 
14426     print_uint32_t(obj->descriptorCount, "descriptorCount", 1);
14427 
14428     print_VkDescriptorType(obj->descriptorType, "descriptorType", 1);
14429 
14430     PRINT_SPACE
14431     _OUT << "\"pImageInfo\": " << std::endl;
14432     if (obj->pImageInfo)
14433     {
14434         PRINT_SPACE
14435         _OUT << "[" << std::endl;
14436         for (unsigned int i = 0; i < obj->descriptorCount; i++)
14437         {
14438             if (i + 1 == obj->descriptorCount)
14439                 print_VkDescriptorImageInfo(obj->pImageInfo[i], "pImageInfo", 0);
14440             else
14441                 print_VkDescriptorImageInfo(obj->pImageInfo[i], "pImageInfo", 1);
14442         }
14443         PRINT_SPACE
14444         _OUT << "]," << std::endl;
14445     }
14446     else
14447     {
14448         PRINT_SPACE _OUT << "\"NULL\""
14449                          << "," << std::endl;
14450     }
14451 
14452     PRINT_SPACE
14453     _OUT << "\"pBufferInfo\": " << std::endl;
14454     if (obj->pBufferInfo)
14455     {
14456         PRINT_SPACE
14457         _OUT << "[" << std::endl;
14458         for (unsigned int i = 0; i < obj->descriptorCount; i++)
14459         {
14460             if (i + 1 == obj->descriptorCount)
14461                 print_VkDescriptorBufferInfo(obj->pBufferInfo[i], "pBufferInfo", 0);
14462             else
14463                 print_VkDescriptorBufferInfo(obj->pBufferInfo[i], "pBufferInfo", 1);
14464         }
14465         PRINT_SPACE
14466         _OUT << "]," << std::endl;
14467     }
14468     else
14469     {
14470         PRINT_SPACE _OUT << "\"NULL\""
14471                          << "," << std::endl;
14472     }
14473 
14474     PRINT_SPACE
14475     _OUT << "\"pTexelBufferView\":" << std::endl;
14476     PRINT_SPACE
14477     if (obj->pTexelBufferView)
14478     {
14479         _OUT << "[" << std::endl;
14480         for (unsigned int i = 0; i < obj->descriptorCount; i++)
14481         {
14482             std::stringstream tmp;
14483             tmp << "pTexelBufferView"
14484                 << "_" << i;
14485             bool isCommaNeeded = (i + 1) != obj->descriptorCount;
14486             print_VkBufferView(obj->pTexelBufferView[i], tmp.str(), isCommaNeeded);
14487         }
14488         PRINT_SPACE
14489         _OUT << "]"
14490              << "" << std::endl;
14491     }
14492     else
14493     {
14494         _OUT << "\"NULL\""
14495              << "" << std::endl;
14496     }
14497 
14498     INDENT(-4);
14499     PRINT_SPACE
14500     if (commaNeeded)
14501         _OUT << "}," << std::endl;
14502     else
14503         _OUT << "}" << std::endl;
14504 }
14505 
print_VkAttachmentDescription(VkAttachmentDescription obj,const std::string & s,bool commaNeeded=true)14506 static void print_VkAttachmentDescription(VkAttachmentDescription obj, const std::string &s, bool commaNeeded = true)
14507 {
14508     PRINT_SPACE
14509     _OUT << "{" << std::endl;
14510     INDENT(4);
14511 
14512     print_VkAttachmentDescriptionFlags(obj.flags, "flags", 1);
14513 
14514     print_VkFormat(obj.format, "format", 1);
14515 
14516     print_VkSampleCountFlagBits(obj.samples, "samples", 1);
14517 
14518     print_VkAttachmentLoadOp(obj.loadOp, "loadOp", 1);
14519 
14520     print_VkAttachmentStoreOp(obj.storeOp, "storeOp", 1);
14521 
14522     print_VkAttachmentLoadOp(obj.stencilLoadOp, "stencilLoadOp", 1);
14523 
14524     print_VkAttachmentStoreOp(obj.stencilStoreOp, "stencilStoreOp", 1);
14525 
14526     print_VkImageLayout(obj.initialLayout, "initialLayout", 1);
14527 
14528     print_VkImageLayout(obj.finalLayout, "finalLayout", 0);
14529 
14530     INDENT(-4);
14531     PRINT_SPACE
14532     if (commaNeeded)
14533         _OUT << "}," << std::endl;
14534     else
14535         _OUT << "}" << std::endl;
14536 }
print_VkAttachmentDescription(const VkAttachmentDescription * obj,const std::string & s,bool commaNeeded=true)14537 static void print_VkAttachmentDescription(const VkAttachmentDescription *obj, const std::string &s,
14538                                           bool commaNeeded = true)
14539 {
14540     PRINT_SPACE
14541     _OUT << "{" << std::endl;
14542     INDENT(4);
14543 
14544     print_VkAttachmentDescriptionFlags(obj->flags, "flags", 1);
14545 
14546     print_VkFormat(obj->format, "format", 1);
14547 
14548     print_VkSampleCountFlagBits(obj->samples, "samples", 1);
14549 
14550     print_VkAttachmentLoadOp(obj->loadOp, "loadOp", 1);
14551 
14552     print_VkAttachmentStoreOp(obj->storeOp, "storeOp", 1);
14553 
14554     print_VkAttachmentLoadOp(obj->stencilLoadOp, "stencilLoadOp", 1);
14555 
14556     print_VkAttachmentStoreOp(obj->stencilStoreOp, "stencilStoreOp", 1);
14557 
14558     print_VkImageLayout(obj->initialLayout, "initialLayout", 1);
14559 
14560     print_VkImageLayout(obj->finalLayout, "finalLayout", 0);
14561 
14562     INDENT(-4);
14563     PRINT_SPACE
14564     if (commaNeeded)
14565         _OUT << "}," << std::endl;
14566     else
14567         _OUT << "}" << std::endl;
14568 }
14569 
print_VkAttachmentReference(VkAttachmentReference obj,const std::string & s,bool commaNeeded=true)14570 static void print_VkAttachmentReference(VkAttachmentReference obj, const std::string &s, bool commaNeeded = true)
14571 {
14572     PRINT_SPACE
14573     _OUT << "{" << std::endl;
14574     INDENT(4);
14575 
14576     print_uint32_t(obj.attachment, "attachment", 1);
14577 
14578     print_VkImageLayout(obj.layout, "layout", 0);
14579 
14580     INDENT(-4);
14581     PRINT_SPACE
14582     if (commaNeeded)
14583         _OUT << "}," << std::endl;
14584     else
14585         _OUT << "}" << std::endl;
14586 }
print_VkAttachmentReference(const VkAttachmentReference * obj,const std::string & s,bool commaNeeded=true)14587 static void print_VkAttachmentReference(const VkAttachmentReference *obj, const std::string &s, bool commaNeeded = true)
14588 {
14589     PRINT_SPACE
14590     _OUT << "{" << std::endl;
14591     INDENT(4);
14592 
14593     print_uint32_t(obj->attachment, "attachment", 1);
14594 
14595     print_VkImageLayout(obj->layout, "layout", 0);
14596 
14597     INDENT(-4);
14598     PRINT_SPACE
14599     if (commaNeeded)
14600         _OUT << "}," << std::endl;
14601     else
14602         _OUT << "}" << std::endl;
14603 }
14604 
print_VkFramebufferCreateInfo(VkFramebufferCreateInfo obj,const std::string & s,bool commaNeeded=true)14605 static void print_VkFramebufferCreateInfo(VkFramebufferCreateInfo obj, const std::string &s, bool commaNeeded = true)
14606 {
14607     PRINT_SPACE
14608     _OUT << "{" << std::endl;
14609     INDENT(4);
14610 
14611     print_VkStructureType(obj.sType, "sType", 1);
14612 
14613     if (obj.pNext)
14614     {
14615         dumpPNextChain(obj.pNext);
14616     }
14617     else
14618     {
14619         PRINT_SPACE
14620         _OUT << "\"pNext\":"
14621              << "\"NULL\""
14622              << "," << std::endl;
14623     }
14624 
14625     print_VkFramebufferCreateFlags(obj.flags, "flags", 1);
14626 
14627     // CTS : required value
14628     PRINT_SPACE _OUT << "\""
14629                      << "renderPass"
14630                      << "\""
14631                      << " : " << obj.renderPass.getInternal() << "," << std::endl;
14632 
14633     print_uint32_t(obj.attachmentCount, "attachmentCount", 1);
14634 
14635     PRINT_SPACE
14636     _OUT << "\"pAttachments\":" << std::endl;
14637     PRINT_SPACE
14638     if (obj.pAttachments)
14639     {
14640         _OUT << "[" << std::endl;
14641         for (unsigned int i = 0; i < obj.attachmentCount; i++)
14642         {
14643             std::stringstream tmp;
14644             tmp << "pAttachments"
14645                 << "_" << i;
14646             bool isCommaNeeded = (i + 1) != obj.attachmentCount;
14647             print_VkImageView(obj.pAttachments[i], tmp.str(), isCommaNeeded);
14648         }
14649         PRINT_SPACE
14650         _OUT << "]"
14651              << "," << std::endl;
14652     }
14653     else
14654     {
14655         _OUT << "\"NULL\""
14656              << "," << std::endl;
14657     }
14658 
14659     print_uint32_t(obj.width, "width", 1);
14660 
14661     print_uint32_t(obj.height, "height", 1);
14662 
14663     print_uint32_t(obj.layers, "layers", 0);
14664 
14665     INDENT(-4);
14666     PRINT_SPACE
14667     if (commaNeeded)
14668         _OUT << "}," << std::endl;
14669     else
14670         _OUT << "}" << std::endl;
14671 }
print_VkFramebufferCreateInfo(const VkFramebufferCreateInfo * obj,const std::string & s,bool commaNeeded=true)14672 static void print_VkFramebufferCreateInfo(const VkFramebufferCreateInfo *obj, const std::string &s,
14673                                           bool commaNeeded = true)
14674 {
14675     PRINT_SPACE
14676     _OUT << "{" << std::endl;
14677     INDENT(4);
14678 
14679     print_VkStructureType(obj->sType, "sType", 1);
14680 
14681     if (obj->pNext)
14682     {
14683         dumpPNextChain(obj->pNext);
14684     }
14685     else
14686     {
14687         PRINT_SPACE
14688         _OUT << "\"pNext\":"
14689              << "\"NULL\""
14690              << "," << std::endl;
14691     }
14692 
14693     print_VkFramebufferCreateFlags(obj->flags, "flags", 1);
14694 
14695     // CTS : required value
14696     PRINT_SPACE _OUT << "\""
14697                      << "renderPass"
14698                      << "\""
14699                      << " : " << obj->renderPass.getInternal() << "," << std::endl;
14700 
14701     print_uint32_t(obj->attachmentCount, "attachmentCount", 1);
14702 
14703     PRINT_SPACE
14704     _OUT << "\"pAttachments\":" << std::endl;
14705     PRINT_SPACE
14706     if (obj->pAttachments)
14707     {
14708         _OUT << "[" << std::endl;
14709         for (unsigned int i = 0; i < obj->attachmentCount; i++)
14710         {
14711             std::stringstream tmp;
14712             tmp << "pAttachments"
14713                 << "_" << i;
14714             bool isCommaNeeded = (i + 1) != obj->attachmentCount;
14715             print_VkImageView(obj->pAttachments[i], tmp.str(), isCommaNeeded);
14716         }
14717         PRINT_SPACE
14718         _OUT << "]"
14719              << "," << std::endl;
14720     }
14721     else
14722     {
14723         _OUT << "\"NULL\""
14724              << "," << std::endl;
14725     }
14726 
14727     print_uint32_t(obj->width, "width", 1);
14728 
14729     print_uint32_t(obj->height, "height", 1);
14730 
14731     print_uint32_t(obj->layers, "layers", 0);
14732 
14733     INDENT(-4);
14734     PRINT_SPACE
14735     if (commaNeeded)
14736         _OUT << "}," << std::endl;
14737     else
14738         _OUT << "}" << std::endl;
14739 }
14740 
print_VkSubpassDescription(VkSubpassDescription obj,const std::string & s,bool commaNeeded=true)14741 static void print_VkSubpassDescription(VkSubpassDescription obj, const std::string &s, bool commaNeeded = true)
14742 {
14743     PRINT_SPACE
14744     _OUT << "{" << std::endl;
14745     INDENT(4);
14746 
14747     print_VkSubpassDescriptionFlags(obj.flags, "flags", 1);
14748 
14749     print_VkPipelineBindPoint(obj.pipelineBindPoint, "pipelineBindPoint", 1);
14750 
14751     print_uint32_t(obj.inputAttachmentCount, "inputAttachmentCount", 1);
14752 
14753     PRINT_SPACE
14754     _OUT << "\"pInputAttachments\": " << std::endl;
14755     if (obj.pInputAttachments)
14756     {
14757         PRINT_SPACE
14758         _OUT << "[" << std::endl;
14759         for (unsigned int i = 0; i < obj.inputAttachmentCount; i++)
14760         {
14761             if (i + 1 == obj.inputAttachmentCount)
14762                 print_VkAttachmentReference(obj.pInputAttachments[i], "pInputAttachments", 0);
14763             else
14764                 print_VkAttachmentReference(obj.pInputAttachments[i], "pInputAttachments", 1);
14765         }
14766         PRINT_SPACE
14767         _OUT << "]," << std::endl;
14768     }
14769     else
14770     {
14771         PRINT_SPACE _OUT << "\"NULL\""
14772                          << "," << std::endl;
14773     }
14774 
14775     print_uint32_t(obj.colorAttachmentCount, "colorAttachmentCount", 1);
14776 
14777     PRINT_SPACE
14778     _OUT << "\"pColorAttachments\": " << std::endl;
14779     if (obj.pColorAttachments)
14780     {
14781         PRINT_SPACE
14782         _OUT << "[" << std::endl;
14783         for (unsigned int i = 0; i < obj.colorAttachmentCount; i++)
14784         {
14785             if (i + 1 == obj.colorAttachmentCount)
14786                 print_VkAttachmentReference(obj.pColorAttachments[i], "pColorAttachments", 0);
14787             else
14788                 print_VkAttachmentReference(obj.pColorAttachments[i], "pColorAttachments", 1);
14789         }
14790         PRINT_SPACE
14791         _OUT << "]," << std::endl;
14792     }
14793     else
14794     {
14795         PRINT_SPACE _OUT << "\"NULL\""
14796                          << "," << std::endl;
14797     }
14798 
14799     PRINT_SPACE
14800     _OUT << "\"pResolveAttachments\": " << std::endl;
14801     if (obj.pResolveAttachments)
14802     {
14803         PRINT_SPACE
14804         _OUT << "[" << std::endl;
14805         for (unsigned int i = 0; i < obj.colorAttachmentCount; i++)
14806         {
14807             if (i + 1 == obj.colorAttachmentCount)
14808                 print_VkAttachmentReference(obj.pResolveAttachments[i], "pResolveAttachments", 0);
14809             else
14810                 print_VkAttachmentReference(obj.pResolveAttachments[i], "pResolveAttachments", 1);
14811         }
14812         PRINT_SPACE
14813         _OUT << "]," << std::endl;
14814     }
14815     else
14816     {
14817         PRINT_SPACE _OUT << "\"NULL\""
14818                          << "," << std::endl;
14819     }
14820 
14821     PRINT_SPACE
14822     _OUT << "\"pDepthStencilAttachment\": " << std::endl;
14823     if (obj.pDepthStencilAttachment)
14824     {
14825         print_VkAttachmentReference(obj.pDepthStencilAttachment, "pDepthStencilAttachment", 1);
14826     }
14827     else
14828     {
14829         PRINT_SPACE _OUT << "\"NULL\""
14830                          << "," << std::endl;
14831     }
14832 
14833     print_uint32_t(obj.preserveAttachmentCount, "preserveAttachmentCount", 1);
14834 
14835     PRINT_SPACE
14836     _OUT << "\"pPreserveAttachments\":" << std::endl;
14837     PRINT_SPACE
14838     if (obj.pPreserveAttachments)
14839     {
14840         _OUT << "[" << std::endl;
14841         for (unsigned int i = 0; i < obj.preserveAttachmentCount; i++)
14842         {
14843             bool isCommaNeeded = (i + 1) != obj.preserveAttachmentCount;
14844             print_uint32_t(obj.pPreserveAttachments[i], "", isCommaNeeded);
14845         }
14846         PRINT_SPACE
14847         _OUT << "]"
14848              << "" << std::endl;
14849     }
14850     else
14851     {
14852         _OUT << "\"NULL\""
14853              << "" << std::endl;
14854     }
14855 
14856     INDENT(-4);
14857     PRINT_SPACE
14858     if (commaNeeded)
14859         _OUT << "}," << std::endl;
14860     else
14861         _OUT << "}" << std::endl;
14862 }
print_VkSubpassDescription(const VkSubpassDescription * obj,const std::string & s,bool commaNeeded=true)14863 static void print_VkSubpassDescription(const VkSubpassDescription *obj, const std::string &s, bool commaNeeded = true)
14864 {
14865     PRINT_SPACE
14866     _OUT << "{" << std::endl;
14867     INDENT(4);
14868 
14869     print_VkSubpassDescriptionFlags(obj->flags, "flags", 1);
14870 
14871     print_VkPipelineBindPoint(obj->pipelineBindPoint, "pipelineBindPoint", 1);
14872 
14873     print_uint32_t(obj->inputAttachmentCount, "inputAttachmentCount", 1);
14874 
14875     PRINT_SPACE
14876     _OUT << "\"pInputAttachments\": " << std::endl;
14877     if (obj->pInputAttachments)
14878     {
14879         PRINT_SPACE
14880         _OUT << "[" << std::endl;
14881         for (unsigned int i = 0; i < obj->inputAttachmentCount; i++)
14882         {
14883             if (i + 1 == obj->inputAttachmentCount)
14884                 print_VkAttachmentReference(obj->pInputAttachments[i], "pInputAttachments", 0);
14885             else
14886                 print_VkAttachmentReference(obj->pInputAttachments[i], "pInputAttachments", 1);
14887         }
14888         PRINT_SPACE
14889         _OUT << "]," << std::endl;
14890     }
14891     else
14892     {
14893         PRINT_SPACE _OUT << "\"NULL\""
14894                          << "," << std::endl;
14895     }
14896 
14897     print_uint32_t(obj->colorAttachmentCount, "colorAttachmentCount", 1);
14898 
14899     PRINT_SPACE
14900     _OUT << "\"pColorAttachments\": " << std::endl;
14901     if (obj->pColorAttachments)
14902     {
14903         PRINT_SPACE
14904         _OUT << "[" << std::endl;
14905         for (unsigned int i = 0; i < obj->colorAttachmentCount; i++)
14906         {
14907             if (i + 1 == obj->colorAttachmentCount)
14908                 print_VkAttachmentReference(obj->pColorAttachments[i], "pColorAttachments", 0);
14909             else
14910                 print_VkAttachmentReference(obj->pColorAttachments[i], "pColorAttachments", 1);
14911         }
14912         PRINT_SPACE
14913         _OUT << "]," << std::endl;
14914     }
14915     else
14916     {
14917         PRINT_SPACE _OUT << "\"NULL\""
14918                          << "," << std::endl;
14919     }
14920 
14921     PRINT_SPACE
14922     _OUT << "\"pResolveAttachments\": " << std::endl;
14923     if (obj->pResolveAttachments)
14924     {
14925         PRINT_SPACE
14926         _OUT << "[" << std::endl;
14927         for (unsigned int i = 0; i < obj->colorAttachmentCount; i++)
14928         {
14929             if (i + 1 == obj->colorAttachmentCount)
14930                 print_VkAttachmentReference(obj->pResolveAttachments[i], "pResolveAttachments", 0);
14931             else
14932                 print_VkAttachmentReference(obj->pResolveAttachments[i], "pResolveAttachments", 1);
14933         }
14934         PRINT_SPACE
14935         _OUT << "]," << std::endl;
14936     }
14937     else
14938     {
14939         PRINT_SPACE _OUT << "\"NULL\""
14940                          << "," << std::endl;
14941     }
14942 
14943     PRINT_SPACE
14944     _OUT << "\"pDepthStencilAttachment\": " << std::endl;
14945     if (obj->pDepthStencilAttachment)
14946     {
14947         print_VkAttachmentReference(obj->pDepthStencilAttachment, "pDepthStencilAttachment", 1);
14948     }
14949     else
14950     {
14951         PRINT_SPACE _OUT << "\"NULL\""
14952                          << "," << std::endl;
14953     }
14954 
14955     print_uint32_t(obj->preserveAttachmentCount, "preserveAttachmentCount", 1);
14956 
14957     PRINT_SPACE
14958     _OUT << "\"pPreserveAttachments\":" << std::endl;
14959     PRINT_SPACE
14960     if (obj->pPreserveAttachments)
14961     {
14962         _OUT << "[" << std::endl;
14963         for (unsigned int i = 0; i < obj->preserveAttachmentCount; i++)
14964         {
14965             bool isCommaNeeded = (i + 1) != obj->preserveAttachmentCount;
14966             print_uint32_t(obj->pPreserveAttachments[i], "", isCommaNeeded);
14967         }
14968         PRINT_SPACE
14969         _OUT << "]"
14970              << "" << std::endl;
14971     }
14972     else
14973     {
14974         _OUT << "\"NULL\""
14975              << "" << std::endl;
14976     }
14977 
14978     INDENT(-4);
14979     PRINT_SPACE
14980     if (commaNeeded)
14981         _OUT << "}," << std::endl;
14982     else
14983         _OUT << "}" << std::endl;
14984 }
14985 
print_VkSubpassDependency(VkSubpassDependency obj,const std::string & s,bool commaNeeded=true)14986 static void print_VkSubpassDependency(VkSubpassDependency obj, const std::string &s, bool commaNeeded = true)
14987 {
14988     PRINT_SPACE
14989     _OUT << "{" << std::endl;
14990     INDENT(4);
14991 
14992     print_uint32_t(obj.srcSubpass, "srcSubpass", 1);
14993 
14994     print_uint32_t(obj.dstSubpass, "dstSubpass", 1);
14995 
14996     print_VkPipelineStageFlags(obj.srcStageMask, "srcStageMask", 1);
14997 
14998     print_VkPipelineStageFlags(obj.dstStageMask, "dstStageMask", 1);
14999 
15000     print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1);
15001 
15002     print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 1);
15003 
15004     print_VkDependencyFlags(obj.dependencyFlags, "dependencyFlags", 0);
15005 
15006     INDENT(-4);
15007     PRINT_SPACE
15008     if (commaNeeded)
15009         _OUT << "}," << std::endl;
15010     else
15011         _OUT << "}" << std::endl;
15012 }
print_VkSubpassDependency(const VkSubpassDependency * obj,const std::string & s,bool commaNeeded=true)15013 static void print_VkSubpassDependency(const VkSubpassDependency *obj, const std::string &s, bool commaNeeded = true)
15014 {
15015     PRINT_SPACE
15016     _OUT << "{" << std::endl;
15017     INDENT(4);
15018 
15019     print_uint32_t(obj->srcSubpass, "srcSubpass", 1);
15020 
15021     print_uint32_t(obj->dstSubpass, "dstSubpass", 1);
15022 
15023     print_VkPipelineStageFlags(obj->srcStageMask, "srcStageMask", 1);
15024 
15025     print_VkPipelineStageFlags(obj->dstStageMask, "dstStageMask", 1);
15026 
15027     print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1);
15028 
15029     print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 1);
15030 
15031     print_VkDependencyFlags(obj->dependencyFlags, "dependencyFlags", 0);
15032 
15033     INDENT(-4);
15034     PRINT_SPACE
15035     if (commaNeeded)
15036         _OUT << "}," << std::endl;
15037     else
15038         _OUT << "}" << std::endl;
15039 }
15040 
print_VkRenderPassCreateInfo(VkRenderPassCreateInfo obj,const std::string & s,bool commaNeeded=true)15041 static void print_VkRenderPassCreateInfo(VkRenderPassCreateInfo obj, const std::string &s, bool commaNeeded = true)
15042 {
15043     PRINT_SPACE
15044     _OUT << "{" << std::endl;
15045     INDENT(4);
15046 
15047     print_VkStructureType(obj.sType, "sType", 1);
15048 
15049     if (obj.pNext)
15050     {
15051         dumpPNextChain(obj.pNext);
15052     }
15053     else
15054     {
15055         PRINT_SPACE
15056         _OUT << "\"pNext\":"
15057              << "\"NULL\""
15058              << "," << std::endl;
15059     }
15060 
15061     print_VkRenderPassCreateFlags(obj.flags, "flags", 1);
15062 
15063     print_uint32_t(obj.attachmentCount, "attachmentCount", 1);
15064 
15065     PRINT_SPACE
15066     _OUT << "\"pAttachments\": " << std::endl;
15067     if (obj.pAttachments)
15068     {
15069         PRINT_SPACE
15070         _OUT << "[" << std::endl;
15071         for (unsigned int i = 0; i < obj.attachmentCount; i++)
15072         {
15073             if (i + 1 == obj.attachmentCount)
15074                 print_VkAttachmentDescription(obj.pAttachments[i], "pAttachments", 0);
15075             else
15076                 print_VkAttachmentDescription(obj.pAttachments[i], "pAttachments", 1);
15077         }
15078         PRINT_SPACE
15079         _OUT << "]," << std::endl;
15080     }
15081     else
15082     {
15083         PRINT_SPACE _OUT << "\"NULL\""
15084                          << "," << std::endl;
15085     }
15086 
15087     print_uint32_t(obj.subpassCount, "subpassCount", 1);
15088 
15089     PRINT_SPACE
15090     _OUT << "\"pSubpasses\": " << std::endl;
15091     if (obj.pSubpasses)
15092     {
15093         PRINT_SPACE
15094         _OUT << "[" << std::endl;
15095         for (unsigned int i = 0; i < obj.subpassCount; i++)
15096         {
15097             if (i + 1 == obj.subpassCount)
15098                 print_VkSubpassDescription(obj.pSubpasses[i], "pSubpasses", 0);
15099             else
15100                 print_VkSubpassDescription(obj.pSubpasses[i], "pSubpasses", 1);
15101         }
15102         PRINT_SPACE
15103         _OUT << "]," << std::endl;
15104     }
15105     else
15106     {
15107         PRINT_SPACE _OUT << "\"NULL\""
15108                          << "," << std::endl;
15109     }
15110 
15111     print_uint32_t(obj.dependencyCount, "dependencyCount", 1);
15112 
15113     PRINT_SPACE
15114     _OUT << "\"pDependencies\": " << std::endl;
15115     if (obj.pDependencies)
15116     {
15117         PRINT_SPACE
15118         _OUT << "[" << std::endl;
15119         for (unsigned int i = 0; i < obj.dependencyCount; i++)
15120         {
15121             if (i + 1 == obj.dependencyCount)
15122                 print_VkSubpassDependency(obj.pDependencies[i], "pDependencies", 0);
15123             else
15124                 print_VkSubpassDependency(obj.pDependencies[i], "pDependencies", 1);
15125         }
15126         PRINT_SPACE
15127         _OUT << "]" << std::endl;
15128     }
15129     else
15130     {
15131         PRINT_SPACE _OUT << "\"NULL\""
15132                          << "" << std::endl;
15133     }
15134 
15135     INDENT(-4);
15136     PRINT_SPACE
15137     if (commaNeeded)
15138         _OUT << "}," << std::endl;
15139     else
15140         _OUT << "}" << std::endl;
15141 }
print_VkRenderPassCreateInfo(const VkRenderPassCreateInfo * obj,const std::string & s,bool commaNeeded=true)15142 static void print_VkRenderPassCreateInfo(const VkRenderPassCreateInfo *obj, const std::string &s,
15143                                          bool commaNeeded = true)
15144 {
15145     PRINT_SPACE
15146     _OUT << "{" << std::endl;
15147     INDENT(4);
15148 
15149     print_VkStructureType(obj->sType, "sType", 1);
15150 
15151     if (obj->pNext)
15152     {
15153         dumpPNextChain(obj->pNext);
15154     }
15155     else
15156     {
15157         PRINT_SPACE
15158         _OUT << "\"pNext\":"
15159              << "\"NULL\""
15160              << "," << std::endl;
15161     }
15162 
15163     print_VkRenderPassCreateFlags(obj->flags, "flags", 1);
15164 
15165     print_uint32_t(obj->attachmentCount, "attachmentCount", 1);
15166 
15167     PRINT_SPACE
15168     _OUT << "\"pAttachments\": " << std::endl;
15169     if (obj->pAttachments)
15170     {
15171         PRINT_SPACE
15172         _OUT << "[" << std::endl;
15173         for (unsigned int i = 0; i < obj->attachmentCount; i++)
15174         {
15175             if (i + 1 == obj->attachmentCount)
15176                 print_VkAttachmentDescription(obj->pAttachments[i], "pAttachments", 0);
15177             else
15178                 print_VkAttachmentDescription(obj->pAttachments[i], "pAttachments", 1);
15179         }
15180         PRINT_SPACE
15181         _OUT << "]," << std::endl;
15182     }
15183     else
15184     {
15185         PRINT_SPACE _OUT << "\"NULL\""
15186                          << "," << std::endl;
15187     }
15188 
15189     print_uint32_t(obj->subpassCount, "subpassCount", 1);
15190 
15191     PRINT_SPACE
15192     _OUT << "\"pSubpasses\": " << std::endl;
15193     if (obj->pSubpasses)
15194     {
15195         PRINT_SPACE
15196         _OUT << "[" << std::endl;
15197         for (unsigned int i = 0; i < obj->subpassCount; i++)
15198         {
15199             if (i + 1 == obj->subpassCount)
15200                 print_VkSubpassDescription(obj->pSubpasses[i], "pSubpasses", 0);
15201             else
15202                 print_VkSubpassDescription(obj->pSubpasses[i], "pSubpasses", 1);
15203         }
15204         PRINT_SPACE
15205         _OUT << "]," << std::endl;
15206     }
15207     else
15208     {
15209         PRINT_SPACE _OUT << "\"NULL\""
15210                          << "," << std::endl;
15211     }
15212 
15213     print_uint32_t(obj->dependencyCount, "dependencyCount", 1);
15214 
15215     PRINT_SPACE
15216     _OUT << "\"pDependencies\": " << std::endl;
15217     if (obj->pDependencies)
15218     {
15219         PRINT_SPACE
15220         _OUT << "[" << std::endl;
15221         for (unsigned int i = 0; i < obj->dependencyCount; i++)
15222         {
15223             if (i + 1 == obj->dependencyCount)
15224                 print_VkSubpassDependency(obj->pDependencies[i], "pDependencies", 0);
15225             else
15226                 print_VkSubpassDependency(obj->pDependencies[i], "pDependencies", 1);
15227         }
15228         PRINT_SPACE
15229         _OUT << "]" << std::endl;
15230     }
15231     else
15232     {
15233         PRINT_SPACE _OUT << "\"NULL\""
15234                          << "" << std::endl;
15235     }
15236 
15237     INDENT(-4);
15238     PRINT_SPACE
15239     if (commaNeeded)
15240         _OUT << "}," << std::endl;
15241     else
15242         _OUT << "}" << std::endl;
15243 }
15244 
print_VkCommandPoolCreateInfo(VkCommandPoolCreateInfo obj,const std::string & s,bool commaNeeded=true)15245 static void print_VkCommandPoolCreateInfo(VkCommandPoolCreateInfo obj, const std::string &s, bool commaNeeded = true)
15246 {
15247     PRINT_SPACE
15248     _OUT << "{" << std::endl;
15249     INDENT(4);
15250 
15251     print_VkStructureType(obj.sType, "sType", 1);
15252 
15253     if (obj.pNext)
15254     {
15255         dumpPNextChain(obj.pNext);
15256     }
15257     else
15258     {
15259         PRINT_SPACE
15260         _OUT << "\"pNext\":"
15261              << "\"NULL\""
15262              << "," << std::endl;
15263     }
15264 
15265     print_VkCommandPoolCreateFlags(obj.flags, "flags", 1);
15266 
15267     print_uint32_t(obj.queueFamilyIndex, "queueFamilyIndex", 0);
15268 
15269     INDENT(-4);
15270     PRINT_SPACE
15271     if (commaNeeded)
15272         _OUT << "}," << std::endl;
15273     else
15274         _OUT << "}" << std::endl;
15275 }
print_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo * obj,const std::string & s,bool commaNeeded=true)15276 static void print_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo *obj, const std::string &s,
15277                                           bool commaNeeded = true)
15278 {
15279     PRINT_SPACE
15280     _OUT << "{" << std::endl;
15281     INDENT(4);
15282 
15283     print_VkStructureType(obj->sType, "sType", 1);
15284 
15285     if (obj->pNext)
15286     {
15287         dumpPNextChain(obj->pNext);
15288     }
15289     else
15290     {
15291         PRINT_SPACE
15292         _OUT << "\"pNext\":"
15293              << "\"NULL\""
15294              << "," << std::endl;
15295     }
15296 
15297     print_VkCommandPoolCreateFlags(obj->flags, "flags", 1);
15298 
15299     print_uint32_t(obj->queueFamilyIndex, "queueFamilyIndex", 0);
15300 
15301     INDENT(-4);
15302     PRINT_SPACE
15303     if (commaNeeded)
15304         _OUT << "}," << std::endl;
15305     else
15306         _OUT << "}" << std::endl;
15307 }
15308 
print_VkCommandBufferAllocateInfo(VkCommandBufferAllocateInfo obj,const std::string & s,bool commaNeeded=true)15309 static void print_VkCommandBufferAllocateInfo(VkCommandBufferAllocateInfo obj, const std::string &s,
15310                                               bool commaNeeded = true)
15311 {
15312     PRINT_SPACE
15313     _OUT << "{" << std::endl;
15314     INDENT(4);
15315 
15316     print_VkStructureType(obj.sType, "sType", 1);
15317 
15318     if (obj.pNext)
15319     {
15320         dumpPNextChain(obj.pNext);
15321     }
15322     else
15323     {
15324         PRINT_SPACE
15325         _OUT << "\"pNext\":"
15326              << "\"NULL\""
15327              << "," << std::endl;
15328     }
15329 
15330     // CTS : required value
15331     PRINT_SPACE _OUT << "\""
15332                      << "commandPool"
15333                      << "\""
15334                      << " : "
15335                      << "\""
15336                      << "\"," << std::endl;
15337 
15338     print_VkCommandBufferLevel(obj.level, "level", 1);
15339 
15340     print_uint32_t(obj.commandBufferCount, "commandBufferCount", 0);
15341 
15342     INDENT(-4);
15343     PRINT_SPACE
15344     if (commaNeeded)
15345         _OUT << "}," << std::endl;
15346     else
15347         _OUT << "}" << std::endl;
15348 }
print_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo * obj,const std::string & s,bool commaNeeded=true)15349 static void print_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo *obj, const std::string &s,
15350                                               bool commaNeeded = true)
15351 {
15352     PRINT_SPACE
15353     _OUT << "{" << std::endl;
15354     INDENT(4);
15355 
15356     print_VkStructureType(obj->sType, "sType", 1);
15357 
15358     if (obj->pNext)
15359     {
15360         dumpPNextChain(obj->pNext);
15361     }
15362     else
15363     {
15364         PRINT_SPACE
15365         _OUT << "\"pNext\":"
15366              << "\"NULL\""
15367              << "," << std::endl;
15368     }
15369 
15370     // CTS : required value
15371     PRINT_SPACE _OUT << "\""
15372                      << "commandPool"
15373                      << "\""
15374                      << " : "
15375                      << "\""
15376                      << "\"," << std::endl;
15377 
15378     print_VkCommandBufferLevel(obj->level, "level", 1);
15379 
15380     print_uint32_t(obj->commandBufferCount, "commandBufferCount", 0);
15381 
15382     INDENT(-4);
15383     PRINT_SPACE
15384     if (commaNeeded)
15385         _OUT << "}," << std::endl;
15386     else
15387         _OUT << "}" << std::endl;
15388 }
15389 
print_VkCommandBufferInheritanceInfo(VkCommandBufferInheritanceInfo obj,const std::string & s,bool commaNeeded=true)15390 static void print_VkCommandBufferInheritanceInfo(VkCommandBufferInheritanceInfo obj, const std::string &s,
15391                                                  bool commaNeeded = true)
15392 {
15393     PRINT_SPACE
15394     _OUT << "{" << std::endl;
15395     INDENT(4);
15396 
15397     print_VkStructureType(obj.sType, "sType", 1);
15398 
15399     if (obj.pNext)
15400     {
15401         dumpPNextChain(obj.pNext);
15402     }
15403     else
15404     {
15405         PRINT_SPACE
15406         _OUT << "\"pNext\":"
15407              << "\"NULL\""
15408              << "," << std::endl;
15409     }
15410 
15411     // CTS : required value
15412     PRINT_SPACE _OUT << "\""
15413                      << "renderPass"
15414                      << "\""
15415                      << " : " << obj.renderPass.getInternal() << "," << std::endl;
15416 
15417     print_uint32_t(obj.subpass, "subpass", 1);
15418 
15419     // CTS : required value
15420     PRINT_SPACE _OUT << "\""
15421                      << "framebuffer"
15422                      << "\""
15423                      << " : "
15424                      << "\""
15425                      << "\"," << std::endl;
15426 
15427     print_VkBool32(obj.occlusionQueryEnable, "occlusionQueryEnable", 1);
15428 
15429     print_VkQueryControlFlags(obj.queryFlags, "queryFlags", 1);
15430 
15431     print_VkQueryPipelineStatisticFlags(obj.pipelineStatistics, "pipelineStatistics", 0);
15432 
15433     INDENT(-4);
15434     PRINT_SPACE
15435     if (commaNeeded)
15436         _OUT << "}," << std::endl;
15437     else
15438         _OUT << "}" << std::endl;
15439 }
print_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo * obj,const std::string & s,bool commaNeeded=true)15440 static void print_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo *obj, const std::string &s,
15441                                                  bool commaNeeded = true)
15442 {
15443     PRINT_SPACE
15444     _OUT << "{" << std::endl;
15445     INDENT(4);
15446 
15447     print_VkStructureType(obj->sType, "sType", 1);
15448 
15449     if (obj->pNext)
15450     {
15451         dumpPNextChain(obj->pNext);
15452     }
15453     else
15454     {
15455         PRINT_SPACE
15456         _OUT << "\"pNext\":"
15457              << "\"NULL\""
15458              << "," << std::endl;
15459     }
15460 
15461     // CTS : required value
15462     PRINT_SPACE _OUT << "\""
15463                      << "renderPass"
15464                      << "\""
15465                      << " : " << obj->renderPass.getInternal() << "," << std::endl;
15466 
15467     print_uint32_t(obj->subpass, "subpass", 1);
15468 
15469     // CTS : required value
15470     PRINT_SPACE _OUT << "\""
15471                      << "framebuffer"
15472                      << "\""
15473                      << " : "
15474                      << "\""
15475                      << "\"," << std::endl;
15476 
15477     print_VkBool32(obj->occlusionQueryEnable, "occlusionQueryEnable", 1);
15478 
15479     print_VkQueryControlFlags(obj->queryFlags, "queryFlags", 1);
15480 
15481     print_VkQueryPipelineStatisticFlags(obj->pipelineStatistics, "pipelineStatistics", 0);
15482 
15483     INDENT(-4);
15484     PRINT_SPACE
15485     if (commaNeeded)
15486         _OUT << "}," << std::endl;
15487     else
15488         _OUT << "}" << std::endl;
15489 }
15490 
print_VkCommandBufferBeginInfo(VkCommandBufferBeginInfo obj,const std::string & s,bool commaNeeded=true)15491 static void print_VkCommandBufferBeginInfo(VkCommandBufferBeginInfo obj, const std::string &s, bool commaNeeded = true)
15492 {
15493     PRINT_SPACE
15494     _OUT << "{" << std::endl;
15495     INDENT(4);
15496 
15497     print_VkStructureType(obj.sType, "sType", 1);
15498 
15499     if (obj.pNext)
15500     {
15501         dumpPNextChain(obj.pNext);
15502     }
15503     else
15504     {
15505         PRINT_SPACE
15506         _OUT << "\"pNext\":"
15507              << "\"NULL\""
15508              << "," << std::endl;
15509     }
15510 
15511     print_VkCommandBufferUsageFlags(obj.flags, "flags", 1);
15512 
15513     PRINT_SPACE
15514     _OUT << "\"pInheritanceInfo\": " << std::endl;
15515     if (obj.pInheritanceInfo)
15516     {
15517         print_VkCommandBufferInheritanceInfo(obj.pInheritanceInfo, "pInheritanceInfo", 0);
15518     }
15519     else
15520     {
15521         PRINT_SPACE _OUT << "\"NULL\""
15522                          << "" << std::endl;
15523     }
15524 
15525     INDENT(-4);
15526     PRINT_SPACE
15527     if (commaNeeded)
15528         _OUT << "}," << std::endl;
15529     else
15530         _OUT << "}" << std::endl;
15531 }
print_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo * obj,const std::string & s,bool commaNeeded=true)15532 static void print_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo *obj, const std::string &s,
15533                                            bool commaNeeded = true)
15534 {
15535     PRINT_SPACE
15536     _OUT << "{" << std::endl;
15537     INDENT(4);
15538 
15539     print_VkStructureType(obj->sType, "sType", 1);
15540 
15541     if (obj->pNext)
15542     {
15543         dumpPNextChain(obj->pNext);
15544     }
15545     else
15546     {
15547         PRINT_SPACE
15548         _OUT << "\"pNext\":"
15549              << "\"NULL\""
15550              << "," << std::endl;
15551     }
15552 
15553     print_VkCommandBufferUsageFlags(obj->flags, "flags", 1);
15554 
15555     PRINT_SPACE
15556     _OUT << "\"pInheritanceInfo\": " << std::endl;
15557     if (obj->pInheritanceInfo)
15558     {
15559         print_VkCommandBufferInheritanceInfo(obj->pInheritanceInfo, "pInheritanceInfo", 0);
15560     }
15561     else
15562     {
15563         PRINT_SPACE _OUT << "\"NULL\""
15564                          << "" << std::endl;
15565     }
15566 
15567     INDENT(-4);
15568     PRINT_SPACE
15569     if (commaNeeded)
15570         _OUT << "}," << std::endl;
15571     else
15572         _OUT << "}" << std::endl;
15573 }
15574 
print_VkBufferCopy(VkBufferCopy obj,const std::string & s,bool commaNeeded=true)15575 static void print_VkBufferCopy(VkBufferCopy obj, const std::string &s, bool commaNeeded = true)
15576 {
15577     PRINT_SPACE
15578     _OUT << "{" << std::endl;
15579     INDENT(4);
15580 
15581     print_VkDeviceSize(obj.srcOffset, "srcOffset", 1);
15582 
15583     print_VkDeviceSize(obj.dstOffset, "dstOffset", 1);
15584 
15585     print_VkDeviceSize(obj.size, "size", 0);
15586 
15587     INDENT(-4);
15588     PRINT_SPACE
15589     if (commaNeeded)
15590         _OUT << "}," << std::endl;
15591     else
15592         _OUT << "}" << std::endl;
15593 }
print_VkBufferCopy(const VkBufferCopy * obj,const std::string & s,bool commaNeeded=true)15594 static void print_VkBufferCopy(const VkBufferCopy *obj, const std::string &s, bool commaNeeded = true)
15595 {
15596     PRINT_SPACE
15597     _OUT << "{" << std::endl;
15598     INDENT(4);
15599 
15600     print_VkDeviceSize(obj->srcOffset, "srcOffset", 1);
15601 
15602     print_VkDeviceSize(obj->dstOffset, "dstOffset", 1);
15603 
15604     print_VkDeviceSize(obj->size, "size", 0);
15605 
15606     INDENT(-4);
15607     PRINT_SPACE
15608     if (commaNeeded)
15609         _OUT << "}," << std::endl;
15610     else
15611         _OUT << "}" << std::endl;
15612 }
15613 
print_VkImageSubresourceLayers(VkImageSubresourceLayers obj,const std::string & s,bool commaNeeded=true)15614 static void print_VkImageSubresourceLayers(VkImageSubresourceLayers obj, const std::string &s, bool commaNeeded = true)
15615 {
15616     PRINT_SPACE
15617     _OUT << "{" << std::endl;
15618     INDENT(4);
15619 
15620     print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 1);
15621 
15622     print_uint32_t(obj.mipLevel, "mipLevel", 1);
15623 
15624     print_uint32_t(obj.baseArrayLayer, "baseArrayLayer", 1);
15625 
15626     print_uint32_t(obj.layerCount, "layerCount", 0);
15627 
15628     INDENT(-4);
15629     PRINT_SPACE
15630     if (commaNeeded)
15631         _OUT << "}," << std::endl;
15632     else
15633         _OUT << "}" << std::endl;
15634 }
print_VkImageSubresourceLayers(const VkImageSubresourceLayers * obj,const std::string & s,bool commaNeeded=true)15635 static void print_VkImageSubresourceLayers(const VkImageSubresourceLayers *obj, const std::string &s,
15636                                            bool commaNeeded = true)
15637 {
15638     PRINT_SPACE
15639     _OUT << "{" << std::endl;
15640     INDENT(4);
15641 
15642     print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 1);
15643 
15644     print_uint32_t(obj->mipLevel, "mipLevel", 1);
15645 
15646     print_uint32_t(obj->baseArrayLayer, "baseArrayLayer", 1);
15647 
15648     print_uint32_t(obj->layerCount, "layerCount", 0);
15649 
15650     INDENT(-4);
15651     PRINT_SPACE
15652     if (commaNeeded)
15653         _OUT << "}," << std::endl;
15654     else
15655         _OUT << "}" << std::endl;
15656 }
15657 
print_VkBufferImageCopy(VkBufferImageCopy obj,const std::string & s,bool commaNeeded=true)15658 static void print_VkBufferImageCopy(VkBufferImageCopy obj, const std::string &s, bool commaNeeded = true)
15659 {
15660     PRINT_SPACE
15661     _OUT << "{" << std::endl;
15662     INDENT(4);
15663 
15664     print_VkDeviceSize(obj.bufferOffset, "bufferOffset", 1);
15665 
15666     print_uint32_t(obj.bufferRowLength, "bufferRowLength", 1);
15667 
15668     print_uint32_t(obj.bufferImageHeight, "bufferImageHeight", 1);
15669 
15670     PRINT_SPACE
15671     _OUT << "\"imageSubresource\": " << std::endl;
15672     {
15673         print_VkImageSubresourceLayers(obj.imageSubresource, "imageSubresource", 1);
15674     }
15675 
15676     PRINT_SPACE
15677     _OUT << "\"imageOffset\": " << std::endl;
15678     {
15679         print_VkOffset3D(obj.imageOffset, "imageOffset", 1);
15680     }
15681 
15682     PRINT_SPACE
15683     _OUT << "\"imageExtent\": " << std::endl;
15684     {
15685         print_VkExtent3D(obj.imageExtent, "imageExtent", 0);
15686     }
15687 
15688     INDENT(-4);
15689     PRINT_SPACE
15690     if (commaNeeded)
15691         _OUT << "}," << std::endl;
15692     else
15693         _OUT << "}" << std::endl;
15694 }
print_VkBufferImageCopy(const VkBufferImageCopy * obj,const std::string & s,bool commaNeeded=true)15695 static void print_VkBufferImageCopy(const VkBufferImageCopy *obj, const std::string &s, bool commaNeeded = true)
15696 {
15697     PRINT_SPACE
15698     _OUT << "{" << std::endl;
15699     INDENT(4);
15700 
15701     print_VkDeviceSize(obj->bufferOffset, "bufferOffset", 1);
15702 
15703     print_uint32_t(obj->bufferRowLength, "bufferRowLength", 1);
15704 
15705     print_uint32_t(obj->bufferImageHeight, "bufferImageHeight", 1);
15706 
15707     PRINT_SPACE
15708     _OUT << "\"imageSubresource\": " << std::endl;
15709     {
15710         print_VkImageSubresourceLayers(obj->imageSubresource, "imageSubresource", 1);
15711     }
15712 
15713     PRINT_SPACE
15714     _OUT << "\"imageOffset\": " << std::endl;
15715     {
15716         print_VkOffset3D(obj->imageOffset, "imageOffset", 1);
15717     }
15718 
15719     PRINT_SPACE
15720     _OUT << "\"imageExtent\": " << std::endl;
15721     {
15722         print_VkExtent3D(obj->imageExtent, "imageExtent", 0);
15723     }
15724 
15725     INDENT(-4);
15726     PRINT_SPACE
15727     if (commaNeeded)
15728         _OUT << "}," << std::endl;
15729     else
15730         _OUT << "}" << std::endl;
15731 }
15732 
print_VkClearColorValue(VkClearColorValue obj,const std::string & s,bool commaNeeded=true)15733 static void print_VkClearColorValue(VkClearColorValue obj, const std::string &s, bool commaNeeded = true)
15734 {
15735     PRINT_SPACE
15736     _OUT << "{" << std::endl;
15737     INDENT(4);
15738 
15739     PRINT_SPACE
15740     _OUT << "\"float32\":" << std::endl;
15741     PRINT_SPACE
15742     _OUT << "[" << std::endl;
15743     for (unsigned int i = 0; i < 4; i++)
15744     {
15745         bool isCommaNeeded = (i + 1) != 4;
15746         print_float(obj.float32[i], "", isCommaNeeded);
15747     }
15748     PRINT_SPACE
15749     _OUT << "]"
15750          << "," << std::endl;
15751 
15752     PRINT_SPACE
15753     _OUT << "\"int32\":" << std::endl;
15754     PRINT_SPACE
15755     _OUT << "[" << std::endl;
15756     for (unsigned int i = 0; i < 4; i++)
15757     {
15758         bool isCommaNeeded = (i + 1) != 4;
15759         print_int32_t(obj.int32[i], "", isCommaNeeded);
15760     }
15761     PRINT_SPACE
15762     _OUT << "]"
15763          << "," << std::endl;
15764 
15765     PRINT_SPACE
15766     _OUT << "\"uint32\":" << std::endl;
15767     PRINT_SPACE
15768     _OUT << "[" << std::endl;
15769     for (unsigned int i = 0; i < 4; i++)
15770     {
15771         bool isCommaNeeded = (i + 1) != 4;
15772         print_uint32_t(obj.uint32[i], "", isCommaNeeded);
15773     }
15774     PRINT_SPACE
15775     _OUT << "]"
15776          << "" << std::endl;
15777 
15778     INDENT(-4);
15779     PRINT_SPACE
15780     if (commaNeeded)
15781         _OUT << "}," << std::endl;
15782     else
15783         _OUT << "}" << std::endl;
15784 }
print_VkClearColorValue(const VkClearColorValue * obj,const std::string & s,bool commaNeeded=true)15785 static void print_VkClearColorValue(const VkClearColorValue *obj, const std::string &s, bool commaNeeded = true)
15786 {
15787     PRINT_SPACE
15788     _OUT << "{" << std::endl;
15789     INDENT(4);
15790 
15791     PRINT_SPACE
15792     _OUT << "\"float32\":" << std::endl;
15793     PRINT_SPACE
15794     _OUT << "[" << std::endl;
15795     for (unsigned int i = 0; i < 4; i++)
15796     {
15797         bool isCommaNeeded = (i + 1) != 4;
15798         print_float(obj->float32[i], "", isCommaNeeded);
15799     }
15800     PRINT_SPACE
15801     _OUT << "]"
15802          << "," << std::endl;
15803 
15804     PRINT_SPACE
15805     _OUT << "\"int32\":" << std::endl;
15806     PRINT_SPACE
15807     _OUT << "[" << std::endl;
15808     for (unsigned int i = 0; i < 4; i++)
15809     {
15810         bool isCommaNeeded = (i + 1) != 4;
15811         print_int32_t(obj->int32[i], "", isCommaNeeded);
15812     }
15813     PRINT_SPACE
15814     _OUT << "]"
15815          << "," << std::endl;
15816 
15817     PRINT_SPACE
15818     _OUT << "\"uint32\":" << std::endl;
15819     PRINT_SPACE
15820     _OUT << "[" << std::endl;
15821     for (unsigned int i = 0; i < 4; i++)
15822     {
15823         bool isCommaNeeded = (i + 1) != 4;
15824         print_uint32_t(obj->uint32[i], "", isCommaNeeded);
15825     }
15826     PRINT_SPACE
15827     _OUT << "]"
15828          << "" << std::endl;
15829 
15830     INDENT(-4);
15831     PRINT_SPACE
15832     if (commaNeeded)
15833         _OUT << "}," << std::endl;
15834     else
15835         _OUT << "}" << std::endl;
15836 }
15837 
print_VkClearDepthStencilValue(VkClearDepthStencilValue obj,const std::string & s,bool commaNeeded=true)15838 static void print_VkClearDepthStencilValue(VkClearDepthStencilValue obj, const std::string &s, bool commaNeeded = true)
15839 {
15840     PRINT_SPACE
15841     _OUT << "{" << std::endl;
15842     INDENT(4);
15843 
15844     print_float(obj.depth, "depth", 1);
15845 
15846     print_uint32_t(obj.stencil, "stencil", 0);
15847 
15848     INDENT(-4);
15849     PRINT_SPACE
15850     if (commaNeeded)
15851         _OUT << "}," << std::endl;
15852     else
15853         _OUT << "}" << std::endl;
15854 }
print_VkClearDepthStencilValue(const VkClearDepthStencilValue * obj,const std::string & s,bool commaNeeded=true)15855 static void print_VkClearDepthStencilValue(const VkClearDepthStencilValue *obj, const std::string &s,
15856                                            bool commaNeeded = true)
15857 {
15858     PRINT_SPACE
15859     _OUT << "{" << std::endl;
15860     INDENT(4);
15861 
15862     print_float(obj->depth, "depth", 1);
15863 
15864     print_uint32_t(obj->stencil, "stencil", 0);
15865 
15866     INDENT(-4);
15867     PRINT_SPACE
15868     if (commaNeeded)
15869         _OUT << "}," << std::endl;
15870     else
15871         _OUT << "}" << std::endl;
15872 }
15873 
print_VkClearValue(VkClearValue obj,const std::string & s,bool commaNeeded=true)15874 static void print_VkClearValue(VkClearValue obj, const std::string &s, bool commaNeeded = true)
15875 {
15876     PRINT_SPACE
15877     _OUT << "{" << std::endl;
15878     INDENT(4);
15879 
15880     print_VkClearColorValue(obj.color, "color", 1);
15881 
15882     PRINT_SPACE
15883     _OUT << "\"depthStencil\": " << std::endl;
15884     {
15885         print_VkClearDepthStencilValue(obj.depthStencil, "depthStencil", 0);
15886     }
15887 
15888     INDENT(-4);
15889     PRINT_SPACE
15890     if (commaNeeded)
15891         _OUT << "}," << std::endl;
15892     else
15893         _OUT << "}" << std::endl;
15894 }
print_VkClearValue(const VkClearValue * obj,const std::string & s,bool commaNeeded=true)15895 static void print_VkClearValue(const VkClearValue *obj, const std::string &s, bool commaNeeded = true)
15896 {
15897     PRINT_SPACE
15898     _OUT << "{" << std::endl;
15899     INDENT(4);
15900 
15901     print_VkClearColorValue(obj->color, "color", 1);
15902 
15903     PRINT_SPACE
15904     _OUT << "\"depthStencil\": " << std::endl;
15905     {
15906         print_VkClearDepthStencilValue(obj->depthStencil, "depthStencil", 0);
15907     }
15908 
15909     INDENT(-4);
15910     PRINT_SPACE
15911     if (commaNeeded)
15912         _OUT << "}," << std::endl;
15913     else
15914         _OUT << "}" << std::endl;
15915 }
15916 
print_VkClearAttachment(VkClearAttachment obj,const std::string & s,bool commaNeeded=true)15917 static void print_VkClearAttachment(VkClearAttachment obj, const std::string &s, bool commaNeeded = true)
15918 {
15919     PRINT_SPACE
15920     _OUT << "{" << std::endl;
15921     INDENT(4);
15922 
15923     print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 1);
15924 
15925     print_uint32_t(obj.colorAttachment, "colorAttachment", 1);
15926 
15927     print_VkClearValue(obj.clearValue, "clearValue", 0);
15928 
15929     INDENT(-4);
15930     PRINT_SPACE
15931     if (commaNeeded)
15932         _OUT << "}," << std::endl;
15933     else
15934         _OUT << "}" << std::endl;
15935 }
print_VkClearAttachment(const VkClearAttachment * obj,const std::string & s,bool commaNeeded=true)15936 static void print_VkClearAttachment(const VkClearAttachment *obj, const std::string &s, bool commaNeeded = true)
15937 {
15938     PRINT_SPACE
15939     _OUT << "{" << std::endl;
15940     INDENT(4);
15941 
15942     print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 1);
15943 
15944     print_uint32_t(obj->colorAttachment, "colorAttachment", 1);
15945 
15946     print_VkClearValue(obj->clearValue, "clearValue", 0);
15947 
15948     INDENT(-4);
15949     PRINT_SPACE
15950     if (commaNeeded)
15951         _OUT << "}," << std::endl;
15952     else
15953         _OUT << "}" << std::endl;
15954 }
15955 
print_VkClearRect(VkClearRect obj,const std::string & s,bool commaNeeded=true)15956 static void print_VkClearRect(VkClearRect obj, const std::string &s, bool commaNeeded = true)
15957 {
15958     PRINT_SPACE
15959     _OUT << "{" << std::endl;
15960     INDENT(4);
15961 
15962     PRINT_SPACE
15963     _OUT << "\"rect\": " << std::endl;
15964     {
15965         print_VkRect2D(obj.rect, "rect", 1);
15966     }
15967 
15968     print_uint32_t(obj.baseArrayLayer, "baseArrayLayer", 1);
15969 
15970     print_uint32_t(obj.layerCount, "layerCount", 0);
15971 
15972     INDENT(-4);
15973     PRINT_SPACE
15974     if (commaNeeded)
15975         _OUT << "}," << std::endl;
15976     else
15977         _OUT << "}" << std::endl;
15978 }
print_VkClearRect(const VkClearRect * obj,const std::string & s,bool commaNeeded=true)15979 static void print_VkClearRect(const VkClearRect *obj, const std::string &s, bool commaNeeded = true)
15980 {
15981     PRINT_SPACE
15982     _OUT << "{" << std::endl;
15983     INDENT(4);
15984 
15985     PRINT_SPACE
15986     _OUT << "\"rect\": " << std::endl;
15987     {
15988         print_VkRect2D(obj->rect, "rect", 1);
15989     }
15990 
15991     print_uint32_t(obj->baseArrayLayer, "baseArrayLayer", 1);
15992 
15993     print_uint32_t(obj->layerCount, "layerCount", 0);
15994 
15995     INDENT(-4);
15996     PRINT_SPACE
15997     if (commaNeeded)
15998         _OUT << "}," << std::endl;
15999     else
16000         _OUT << "}" << std::endl;
16001 }
16002 
print_VkImageBlit(VkImageBlit obj,const std::string & s,bool commaNeeded=true)16003 static void print_VkImageBlit(VkImageBlit obj, const std::string &s, bool commaNeeded = true)
16004 {
16005     PRINT_SPACE
16006     _OUT << "{" << std::endl;
16007     INDENT(4);
16008 
16009     PRINT_SPACE
16010     _OUT << "\"srcSubresource\": " << std::endl;
16011     {
16012         print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1);
16013     }
16014 
16015     PRINT_SPACE
16016     _OUT << "\"srcOffsets\":" << std::endl;
16017     PRINT_SPACE
16018     _OUT << "[" << std::endl;
16019     for (unsigned int i = 0; i < 2; i++)
16020     {
16021         bool isCommaNeeded = (i + 1) != 2;
16022         print_VkOffset3D(obj.srcOffsets[i], "", isCommaNeeded);
16023     }
16024     PRINT_SPACE
16025     _OUT << "]"
16026          << "," << std::endl;
16027 
16028     PRINT_SPACE
16029     _OUT << "\"dstSubresource\": " << std::endl;
16030     {
16031         print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1);
16032     }
16033 
16034     PRINT_SPACE
16035     _OUT << "\"dstOffsets\":" << std::endl;
16036     PRINT_SPACE
16037     _OUT << "[" << std::endl;
16038     for (unsigned int i = 0; i < 2; i++)
16039     {
16040         bool isCommaNeeded = (i + 1) != 2;
16041         print_VkOffset3D(obj.dstOffsets[i], "", isCommaNeeded);
16042     }
16043     PRINT_SPACE
16044     _OUT << "]"
16045          << "" << std::endl;
16046 
16047     INDENT(-4);
16048     PRINT_SPACE
16049     if (commaNeeded)
16050         _OUT << "}," << std::endl;
16051     else
16052         _OUT << "}" << std::endl;
16053 }
print_VkImageBlit(const VkImageBlit * obj,const std::string & s,bool commaNeeded=true)16054 static void print_VkImageBlit(const VkImageBlit *obj, const std::string &s, bool commaNeeded = true)
16055 {
16056     PRINT_SPACE
16057     _OUT << "{" << std::endl;
16058     INDENT(4);
16059 
16060     PRINT_SPACE
16061     _OUT << "\"srcSubresource\": " << std::endl;
16062     {
16063         print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1);
16064     }
16065 
16066     PRINT_SPACE
16067     _OUT << "\"srcOffsets\":" << std::endl;
16068     PRINT_SPACE
16069     _OUT << "[" << std::endl;
16070     for (unsigned int i = 0; i < 2; i++)
16071     {
16072         bool isCommaNeeded = (i + 1) != 2;
16073         print_VkOffset3D(obj->srcOffsets[i], "", isCommaNeeded);
16074     }
16075     PRINT_SPACE
16076     _OUT << "]"
16077          << "," << std::endl;
16078 
16079     PRINT_SPACE
16080     _OUT << "\"dstSubresource\": " << std::endl;
16081     {
16082         print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1);
16083     }
16084 
16085     PRINT_SPACE
16086     _OUT << "\"dstOffsets\":" << std::endl;
16087     PRINT_SPACE
16088     _OUT << "[" << std::endl;
16089     for (unsigned int i = 0; i < 2; i++)
16090     {
16091         bool isCommaNeeded = (i + 1) != 2;
16092         print_VkOffset3D(obj->dstOffsets[i], "", isCommaNeeded);
16093     }
16094     PRINT_SPACE
16095     _OUT << "]"
16096          << "" << std::endl;
16097 
16098     INDENT(-4);
16099     PRINT_SPACE
16100     if (commaNeeded)
16101         _OUT << "}," << std::endl;
16102     else
16103         _OUT << "}" << std::endl;
16104 }
16105 
print_VkImageCopy(VkImageCopy obj,const std::string & s,bool commaNeeded=true)16106 static void print_VkImageCopy(VkImageCopy obj, const std::string &s, bool commaNeeded = true)
16107 {
16108     PRINT_SPACE
16109     _OUT << "{" << std::endl;
16110     INDENT(4);
16111 
16112     PRINT_SPACE
16113     _OUT << "\"srcSubresource\": " << std::endl;
16114     {
16115         print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1);
16116     }
16117 
16118     PRINT_SPACE
16119     _OUT << "\"srcOffset\": " << std::endl;
16120     {
16121         print_VkOffset3D(obj.srcOffset, "srcOffset", 1);
16122     }
16123 
16124     PRINT_SPACE
16125     _OUT << "\"dstSubresource\": " << std::endl;
16126     {
16127         print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1);
16128     }
16129 
16130     PRINT_SPACE
16131     _OUT << "\"dstOffset\": " << std::endl;
16132     {
16133         print_VkOffset3D(obj.dstOffset, "dstOffset", 1);
16134     }
16135 
16136     PRINT_SPACE
16137     _OUT << "\"extent\": " << std::endl;
16138     {
16139         print_VkExtent3D(obj.extent, "extent", 0);
16140     }
16141 
16142     INDENT(-4);
16143     PRINT_SPACE
16144     if (commaNeeded)
16145         _OUT << "}," << std::endl;
16146     else
16147         _OUT << "}" << std::endl;
16148 }
print_VkImageCopy(const VkImageCopy * obj,const std::string & s,bool commaNeeded=true)16149 static void print_VkImageCopy(const VkImageCopy *obj, const std::string &s, bool commaNeeded = true)
16150 {
16151     PRINT_SPACE
16152     _OUT << "{" << std::endl;
16153     INDENT(4);
16154 
16155     PRINT_SPACE
16156     _OUT << "\"srcSubresource\": " << std::endl;
16157     {
16158         print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1);
16159     }
16160 
16161     PRINT_SPACE
16162     _OUT << "\"srcOffset\": " << std::endl;
16163     {
16164         print_VkOffset3D(obj->srcOffset, "srcOffset", 1);
16165     }
16166 
16167     PRINT_SPACE
16168     _OUT << "\"dstSubresource\": " << std::endl;
16169     {
16170         print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1);
16171     }
16172 
16173     PRINT_SPACE
16174     _OUT << "\"dstOffset\": " << std::endl;
16175     {
16176         print_VkOffset3D(obj->dstOffset, "dstOffset", 1);
16177     }
16178 
16179     PRINT_SPACE
16180     _OUT << "\"extent\": " << std::endl;
16181     {
16182         print_VkExtent3D(obj->extent, "extent", 0);
16183     }
16184 
16185     INDENT(-4);
16186     PRINT_SPACE
16187     if (commaNeeded)
16188         _OUT << "}," << std::endl;
16189     else
16190         _OUT << "}" << std::endl;
16191 }
16192 
print_VkImageResolve(VkImageResolve obj,const std::string & s,bool commaNeeded=true)16193 static void print_VkImageResolve(VkImageResolve obj, const std::string &s, bool commaNeeded = true)
16194 {
16195     PRINT_SPACE
16196     _OUT << "{" << std::endl;
16197     INDENT(4);
16198 
16199     PRINT_SPACE
16200     _OUT << "\"srcSubresource\": " << std::endl;
16201     {
16202         print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1);
16203     }
16204 
16205     PRINT_SPACE
16206     _OUT << "\"srcOffset\": " << std::endl;
16207     {
16208         print_VkOffset3D(obj.srcOffset, "srcOffset", 1);
16209     }
16210 
16211     PRINT_SPACE
16212     _OUT << "\"dstSubresource\": " << std::endl;
16213     {
16214         print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1);
16215     }
16216 
16217     PRINT_SPACE
16218     _OUT << "\"dstOffset\": " << std::endl;
16219     {
16220         print_VkOffset3D(obj.dstOffset, "dstOffset", 1);
16221     }
16222 
16223     PRINT_SPACE
16224     _OUT << "\"extent\": " << std::endl;
16225     {
16226         print_VkExtent3D(obj.extent, "extent", 0);
16227     }
16228 
16229     INDENT(-4);
16230     PRINT_SPACE
16231     if (commaNeeded)
16232         _OUT << "}," << std::endl;
16233     else
16234         _OUT << "}" << std::endl;
16235 }
print_VkImageResolve(const VkImageResolve * obj,const std::string & s,bool commaNeeded=true)16236 static void print_VkImageResolve(const VkImageResolve *obj, const std::string &s, bool commaNeeded = true)
16237 {
16238     PRINT_SPACE
16239     _OUT << "{" << std::endl;
16240     INDENT(4);
16241 
16242     PRINT_SPACE
16243     _OUT << "\"srcSubresource\": " << std::endl;
16244     {
16245         print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1);
16246     }
16247 
16248     PRINT_SPACE
16249     _OUT << "\"srcOffset\": " << std::endl;
16250     {
16251         print_VkOffset3D(obj->srcOffset, "srcOffset", 1);
16252     }
16253 
16254     PRINT_SPACE
16255     _OUT << "\"dstSubresource\": " << std::endl;
16256     {
16257         print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1);
16258     }
16259 
16260     PRINT_SPACE
16261     _OUT << "\"dstOffset\": " << std::endl;
16262     {
16263         print_VkOffset3D(obj->dstOffset, "dstOffset", 1);
16264     }
16265 
16266     PRINT_SPACE
16267     _OUT << "\"extent\": " << std::endl;
16268     {
16269         print_VkExtent3D(obj->extent, "extent", 0);
16270     }
16271 
16272     INDENT(-4);
16273     PRINT_SPACE
16274     if (commaNeeded)
16275         _OUT << "}," << std::endl;
16276     else
16277         _OUT << "}" << std::endl;
16278 }
16279 
print_VkRenderPassBeginInfo(VkRenderPassBeginInfo obj,const std::string & s,bool commaNeeded=true)16280 static void print_VkRenderPassBeginInfo(VkRenderPassBeginInfo obj, const std::string &s, bool commaNeeded = true)
16281 {
16282     PRINT_SPACE
16283     _OUT << "{" << std::endl;
16284     INDENT(4);
16285 
16286     print_VkStructureType(obj.sType, "sType", 1);
16287 
16288     if (obj.pNext)
16289     {
16290         dumpPNextChain(obj.pNext);
16291     }
16292     else
16293     {
16294         PRINT_SPACE
16295         _OUT << "\"pNext\":"
16296              << "\"NULL\""
16297              << "," << std::endl;
16298     }
16299 
16300     // CTS : required value
16301     PRINT_SPACE _OUT << "\""
16302                      << "renderPass"
16303                      << "\""
16304                      << " : " << obj.renderPass.getInternal() << "," << std::endl;
16305 
16306     // CTS : required value
16307     PRINT_SPACE _OUT << "\""
16308                      << "framebuffer"
16309                      << "\""
16310                      << " : "
16311                      << "\""
16312                      << "\"," << std::endl;
16313 
16314     PRINT_SPACE
16315     _OUT << "\"renderArea\": " << std::endl;
16316     {
16317         print_VkRect2D(obj.renderArea, "renderArea", 1);
16318     }
16319 
16320     print_uint32_t(obj.clearValueCount, "clearValueCount", 1);
16321 
16322     PRINT_SPACE
16323     _OUT << "\"pClearValues\":" << std::endl;
16324     PRINT_SPACE
16325     if (obj.pClearValues)
16326     {
16327         _OUT << "[" << std::endl;
16328         for (unsigned int i = 0; i < obj.clearValueCount; i++)
16329         {
16330             bool isCommaNeeded = (i + 1) != obj.clearValueCount;
16331             print_VkClearValue(obj.pClearValues[i], "", isCommaNeeded);
16332         }
16333         PRINT_SPACE
16334         _OUT << "]"
16335              << "" << std::endl;
16336     }
16337     else
16338     {
16339         _OUT << "\"NULL\""
16340              << "" << std::endl;
16341     }
16342 
16343     INDENT(-4);
16344     PRINT_SPACE
16345     if (commaNeeded)
16346         _OUT << "}," << std::endl;
16347     else
16348         _OUT << "}" << std::endl;
16349 }
print_VkRenderPassBeginInfo(const VkRenderPassBeginInfo * obj,const std::string & s,bool commaNeeded=true)16350 static void print_VkRenderPassBeginInfo(const VkRenderPassBeginInfo *obj, const std::string &s, bool commaNeeded = true)
16351 {
16352     PRINT_SPACE
16353     _OUT << "{" << std::endl;
16354     INDENT(4);
16355 
16356     print_VkStructureType(obj->sType, "sType", 1);
16357 
16358     if (obj->pNext)
16359     {
16360         dumpPNextChain(obj->pNext);
16361     }
16362     else
16363     {
16364         PRINT_SPACE
16365         _OUT << "\"pNext\":"
16366              << "\"NULL\""
16367              << "," << std::endl;
16368     }
16369 
16370     // CTS : required value
16371     PRINT_SPACE _OUT << "\""
16372                      << "renderPass"
16373                      << "\""
16374                      << " : " << obj->renderPass.getInternal() << "," << std::endl;
16375 
16376     // CTS : required value
16377     PRINT_SPACE _OUT << "\""
16378                      << "framebuffer"
16379                      << "\""
16380                      << " : "
16381                      << "\""
16382                      << "\"," << std::endl;
16383 
16384     PRINT_SPACE
16385     _OUT << "\"renderArea\": " << std::endl;
16386     {
16387         print_VkRect2D(obj->renderArea, "renderArea", 1);
16388     }
16389 
16390     print_uint32_t(obj->clearValueCount, "clearValueCount", 1);
16391 
16392     PRINT_SPACE
16393     _OUT << "\"pClearValues\":" << std::endl;
16394     PRINT_SPACE
16395     if (obj->pClearValues)
16396     {
16397         _OUT << "[" << std::endl;
16398         for (unsigned int i = 0; i < obj->clearValueCount; i++)
16399         {
16400             bool isCommaNeeded = (i + 1) != obj->clearValueCount;
16401             print_VkClearValue(obj->pClearValues[i], "", isCommaNeeded);
16402         }
16403         PRINT_SPACE
16404         _OUT << "]"
16405              << "" << std::endl;
16406     }
16407     else
16408     {
16409         _OUT << "\"NULL\""
16410              << "" << std::endl;
16411     }
16412 
16413     INDENT(-4);
16414     PRINT_SPACE
16415     if (commaNeeded)
16416         _OUT << "}," << std::endl;
16417     else
16418         _OUT << "}" << std::endl;
16419 }
16420 
print_VkSamplerYcbcrConversion(VkSamplerYcbcrConversion obj,const std::string & str,bool commaNeeded=true)16421 static void print_VkSamplerYcbcrConversion(VkSamplerYcbcrConversion obj, const std::string &str,
16422                                            bool commaNeeded = true)
16423 {
16424     PRINT_SPACE
16425     if (commaNeeded)
16426         _OUT << "\"" << str << "\""
16427              << "," << std::endl;
16428     else
16429         _OUT << "\"" << str << "\"" << std::endl;
16430 }
print_VkSamplerYcbcrConversion(const VkSamplerYcbcrConversion * obj,const std::string & str,bool commaNeeded=true)16431 static void print_VkSamplerYcbcrConversion(const VkSamplerYcbcrConversion *obj, const std::string &str,
16432                                            bool commaNeeded = true)
16433 {
16434     PRINT_SPACE
16435     if (commaNeeded)
16436         _OUT << "\"" << str << "\""
16437              << "," << std::endl;
16438     else
16439         _OUT << "\"" << str << "\"" << std::endl;
16440 }
16441 
16442 static std::map<uint64_t, std::string> VkSubgroupFeatureFlagBits_map = {
16443     std::make_pair(1ULL << 0, "VK_SUBGROUP_FEATURE_BASIC_BIT"),
16444     std::make_pair(1ULL << 1, "VK_SUBGROUP_FEATURE_VOTE_BIT"),
16445     std::make_pair(1ULL << 2, "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT"),
16446     std::make_pair(1ULL << 3, "VK_SUBGROUP_FEATURE_BALLOT_BIT"),
16447     std::make_pair(1ULL << 4, "VK_SUBGROUP_FEATURE_SHUFFLE_BIT"),
16448     std::make_pair(1ULL << 5, "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT"),
16449     std::make_pair(1ULL << 6, "VK_SUBGROUP_FEATURE_CLUSTERED_BIT"),
16450     std::make_pair(1ULL << 7, "VK_SUBGROUP_FEATURE_QUAD_BIT"),
16451     std::make_pair(1ULL << 8, "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV"),
16452 };
print_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlagBits obj,const std::string & str,bool commaNeeded=true)16453 static void print_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlagBits obj, const std::string &str,
16454                                             bool commaNeeded = true)
16455 {
16456     PRINT_SPACE
16457     if (str != "")
16458         _OUT << "\"" << str << "\""
16459              << " : ";
16460     if (commaNeeded)
16461         _OUT << "\"" << VkSubgroupFeatureFlagBits_map[obj] << "\"," << std::endl;
16462     else
16463         _OUT << "\"" << VkSubgroupFeatureFlagBits_map[obj] << "\"" << std::endl;
16464 }
print_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits * obj,const std::string & str,bool commaNeeded=true)16465 static void print_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits *obj, const std::string &str,
16466                                             bool commaNeeded = true)
16467 {
16468     PRINT_SPACE
16469     if (str != "")
16470         _OUT << "\"" << str << "\""
16471              << " : ";
16472     if (commaNeeded)
16473         _OUT << "\"" << VkSubgroupFeatureFlagBits_map[*obj] << "\"," << std::endl;
16474     else
16475         _OUT << "\"" << VkSubgroupFeatureFlagBits_map[*obj] << "\"" << std::endl;
16476 }
16477 
16478 static std::map<uint64_t, std::string> VkPeerMemoryFeatureFlagBits_map = {
16479     std::make_pair(1ULL << 0, "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT"),
16480     std::make_pair(1ULL << 1, "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT"),
16481     std::make_pair(1ULL << 2, "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT"),
16482     std::make_pair(1ULL << 3, "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT"),
16483 };
print_VkPeerMemoryFeatureFlagBits(VkPeerMemoryFeatureFlagBits obj,const std::string & str,bool commaNeeded=true)16484 static void print_VkPeerMemoryFeatureFlagBits(VkPeerMemoryFeatureFlagBits obj, const std::string &str,
16485                                               bool commaNeeded = true)
16486 {
16487     PRINT_SPACE
16488     if (str != "")
16489         _OUT << "\"" << str << "\""
16490              << " : ";
16491     if (commaNeeded)
16492         _OUT << "\"" << VkPeerMemoryFeatureFlagBits_map[obj] << "\"," << std::endl;
16493     else
16494         _OUT << "\"" << VkPeerMemoryFeatureFlagBits_map[obj] << "\"" << std::endl;
16495 }
print_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits * obj,const std::string & str,bool commaNeeded=true)16496 static void print_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits *obj, const std::string &str,
16497                                               bool commaNeeded = true)
16498 {
16499     PRINT_SPACE
16500     if (str != "")
16501         _OUT << "\"" << str << "\""
16502              << " : ";
16503     if (commaNeeded)
16504         _OUT << "\"" << VkPeerMemoryFeatureFlagBits_map[*obj] << "\"," << std::endl;
16505     else
16506         _OUT << "\"" << VkPeerMemoryFeatureFlagBits_map[*obj] << "\"" << std::endl;
16507 }
16508 
16509 static std::map<uint64_t, std::string> VkMemoryAllocateFlagBits_map = {
16510     std::make_pair(1ULL << 0, "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT"),
16511     std::make_pair(1ULL << 1, "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT"),
16512     std::make_pair(1ULL << 2, "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"),
16513 };
print_VkMemoryAllocateFlagBits(VkMemoryAllocateFlagBits obj,const std::string & str,bool commaNeeded=true)16514 static void print_VkMemoryAllocateFlagBits(VkMemoryAllocateFlagBits obj, const std::string &str,
16515                                            bool commaNeeded = true)
16516 {
16517     PRINT_SPACE
16518     if (str != "")
16519         _OUT << "\"" << str << "\""
16520              << " : ";
16521     if (commaNeeded)
16522         _OUT << "\"" << VkMemoryAllocateFlagBits_map[obj] << "\"," << std::endl;
16523     else
16524         _OUT << "\"" << VkMemoryAllocateFlagBits_map[obj] << "\"" << std::endl;
16525 }
print_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits * obj,const std::string & str,bool commaNeeded=true)16526 static void print_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits *obj, const std::string &str,
16527                                            bool commaNeeded = true)
16528 {
16529     PRINT_SPACE
16530     if (str != "")
16531         _OUT << "\"" << str << "\""
16532              << " : ";
16533     if (commaNeeded)
16534         _OUT << "\"" << VkMemoryAllocateFlagBits_map[*obj] << "\"," << std::endl;
16535     else
16536         _OUT << "\"" << VkMemoryAllocateFlagBits_map[*obj] << "\"" << std::endl;
16537 }
16538 
16539 static std::map<uint64_t, std::string> VkPointClippingBehavior_map = {
16540     std::make_pair(0, "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES"),
16541     std::make_pair(1, "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY"),
16542 };
print_VkPointClippingBehavior(VkPointClippingBehavior obj,const std::string & str,bool commaNeeded=true)16543 static void print_VkPointClippingBehavior(VkPointClippingBehavior obj, const std::string &str, bool commaNeeded = true)
16544 {
16545     PRINT_SPACE
16546     if (str != "")
16547         _OUT << "\"" << str << "\""
16548              << " : ";
16549     if (commaNeeded)
16550         _OUT << "\"" << VkPointClippingBehavior_map[obj] << "\"," << std::endl;
16551     else
16552         _OUT << "\"" << VkPointClippingBehavior_map[obj] << "\"" << std::endl;
16553 }
print_VkPointClippingBehavior(const VkPointClippingBehavior * obj,const std::string & str,bool commaNeeded=true)16554 static void print_VkPointClippingBehavior(const VkPointClippingBehavior *obj, const std::string &str,
16555                                           bool commaNeeded = true)
16556 {
16557     PRINT_SPACE
16558     if (str != "")
16559         _OUT << "\"" << str << "\""
16560              << " : ";
16561     if (commaNeeded)
16562         _OUT << "\"" << VkPointClippingBehavior_map[*obj] << "\"," << std::endl;
16563     else
16564         _OUT << "\"" << VkPointClippingBehavior_map[*obj] << "\"" << std::endl;
16565 }
16566 
16567 static std::map<uint64_t, std::string> VkTessellationDomainOrigin_map = {
16568     std::make_pair(0, "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT"),
16569     std::make_pair(1, "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT"),
16570 };
print_VkTessellationDomainOrigin(VkTessellationDomainOrigin obj,const std::string & str,bool commaNeeded=true)16571 static void print_VkTessellationDomainOrigin(VkTessellationDomainOrigin obj, const std::string &str,
16572                                              bool commaNeeded = true)
16573 {
16574     PRINT_SPACE
16575     if (str != "")
16576         _OUT << "\"" << str << "\""
16577              << " : ";
16578     if (commaNeeded)
16579         _OUT << "\"" << VkTessellationDomainOrigin_map[obj] << "\"," << std::endl;
16580     else
16581         _OUT << "\"" << VkTessellationDomainOrigin_map[obj] << "\"" << std::endl;
16582 }
print_VkTessellationDomainOrigin(const VkTessellationDomainOrigin * obj,const std::string & str,bool commaNeeded=true)16583 static void print_VkTessellationDomainOrigin(const VkTessellationDomainOrigin *obj, const std::string &str,
16584                                              bool commaNeeded = true)
16585 {
16586     PRINT_SPACE
16587     if (str != "")
16588         _OUT << "\"" << str << "\""
16589              << " : ";
16590     if (commaNeeded)
16591         _OUT << "\"" << VkTessellationDomainOrigin_map[*obj] << "\"," << std::endl;
16592     else
16593         _OUT << "\"" << VkTessellationDomainOrigin_map[*obj] << "\"" << std::endl;
16594 }
16595 
16596 static std::map<uint64_t, std::string> VkSamplerYcbcrModelConversion_map = {
16597     std::make_pair(0, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY"),
16598     std::make_pair(1, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY"),
16599     std::make_pair(2, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709"),
16600     std::make_pair(3, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601"),
16601     std::make_pair(4, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020"),
16602 };
print_VkSamplerYcbcrModelConversion(VkSamplerYcbcrModelConversion obj,const std::string & str,bool commaNeeded=true)16603 static void print_VkSamplerYcbcrModelConversion(VkSamplerYcbcrModelConversion obj, const std::string &str,
16604                                                 bool commaNeeded = true)
16605 {
16606     PRINT_SPACE
16607     if (str != "")
16608         _OUT << "\"" << str << "\""
16609              << " : ";
16610     if (commaNeeded)
16611         _OUT << "\"" << VkSamplerYcbcrModelConversion_map[obj] << "\"," << std::endl;
16612     else
16613         _OUT << "\"" << VkSamplerYcbcrModelConversion_map[obj] << "\"" << std::endl;
16614 }
print_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion * obj,const std::string & str,bool commaNeeded=true)16615 static void print_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion *obj, const std::string &str,
16616                                                 bool commaNeeded = true)
16617 {
16618     PRINT_SPACE
16619     if (str != "")
16620         _OUT << "\"" << str << "\""
16621              << " : ";
16622     if (commaNeeded)
16623         _OUT << "\"" << VkSamplerYcbcrModelConversion_map[*obj] << "\"," << std::endl;
16624     else
16625         _OUT << "\"" << VkSamplerYcbcrModelConversion_map[*obj] << "\"" << std::endl;
16626 }
16627 
16628 static std::map<uint64_t, std::string> VkSamplerYcbcrRange_map = {
16629     std::make_pair(0, "VK_SAMPLER_YCBCR_RANGE_ITU_FULL"),
16630     std::make_pair(1, "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW"),
16631 };
print_VkSamplerYcbcrRange(VkSamplerYcbcrRange obj,const std::string & str,bool commaNeeded=true)16632 static void print_VkSamplerYcbcrRange(VkSamplerYcbcrRange obj, const std::string &str, bool commaNeeded = true)
16633 {
16634     PRINT_SPACE
16635     if (str != "")
16636         _OUT << "\"" << str << "\""
16637              << " : ";
16638     if (commaNeeded)
16639         _OUT << "\"" << VkSamplerYcbcrRange_map[obj] << "\"," << std::endl;
16640     else
16641         _OUT << "\"" << VkSamplerYcbcrRange_map[obj] << "\"" << std::endl;
16642 }
print_VkSamplerYcbcrRange(const VkSamplerYcbcrRange * obj,const std::string & str,bool commaNeeded=true)16643 static void print_VkSamplerYcbcrRange(const VkSamplerYcbcrRange *obj, const std::string &str, bool commaNeeded = true)
16644 {
16645     PRINT_SPACE
16646     if (str != "")
16647         _OUT << "\"" << str << "\""
16648              << " : ";
16649     if (commaNeeded)
16650         _OUT << "\"" << VkSamplerYcbcrRange_map[*obj] << "\"," << std::endl;
16651     else
16652         _OUT << "\"" << VkSamplerYcbcrRange_map[*obj] << "\"" << std::endl;
16653 }
16654 
16655 static std::map<uint64_t, std::string> VkChromaLocation_map = {
16656     std::make_pair(0, "VK_CHROMA_LOCATION_COSITED_EVEN"),
16657     std::make_pair(1, "VK_CHROMA_LOCATION_MIDPOINT"),
16658 };
print_VkChromaLocation(VkChromaLocation obj,const std::string & str,bool commaNeeded=true)16659 static void print_VkChromaLocation(VkChromaLocation obj, const std::string &str, bool commaNeeded = true)
16660 {
16661     PRINT_SPACE
16662     if (str != "")
16663         _OUT << "\"" << str << "\""
16664              << " : ";
16665     if (commaNeeded)
16666         _OUT << "\"" << VkChromaLocation_map[obj] << "\"," << std::endl;
16667     else
16668         _OUT << "\"" << VkChromaLocation_map[obj] << "\"" << std::endl;
16669 }
print_VkChromaLocation(const VkChromaLocation * obj,const std::string & str,bool commaNeeded=true)16670 static void print_VkChromaLocation(const VkChromaLocation *obj, const std::string &str, bool commaNeeded = true)
16671 {
16672     PRINT_SPACE
16673     if (str != "")
16674         _OUT << "\"" << str << "\""
16675              << " : ";
16676     if (commaNeeded)
16677         _OUT << "\"" << VkChromaLocation_map[*obj] << "\"," << std::endl;
16678     else
16679         _OUT << "\"" << VkChromaLocation_map[*obj] << "\"" << std::endl;
16680 }
16681 
16682 static std::map<uint64_t, std::string> VkExternalMemoryHandleTypeFlagBits_map = {
16683     std::make_pair(1ULL << 0, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"),
16684     std::make_pair(1ULL << 1, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT"),
16685     std::make_pair(1ULL << 2, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"),
16686     std::make_pair(1ULL << 3, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT"),
16687     std::make_pair(1ULL << 4, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT"),
16688     std::make_pair(1ULL << 5, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT"),
16689     std::make_pair(1ULL << 6, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT"),
16690     std::make_pair(1ULL << 9, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT"),
16691     std::make_pair(1ULL << 10, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID"),
16692     std::make_pair(1ULL << 7, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"),
16693     std::make_pair(1ULL << 8, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"),
16694     std::make_pair(1ULL << 11, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA"),
16695     std::make_pair(1ULL << 12, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV"),
16696     std::make_pair(1ULL << 13, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCI_BUF_BIT_NV"),
16697 };
print_VkExternalMemoryHandleTypeFlagBits(VkExternalMemoryHandleTypeFlagBits obj,const std::string & str,bool commaNeeded=true)16698 static void print_VkExternalMemoryHandleTypeFlagBits(VkExternalMemoryHandleTypeFlagBits obj, const std::string &str,
16699                                                      bool commaNeeded = true)
16700 {
16701     PRINT_SPACE
16702     if (str != "")
16703         _OUT << "\"" << str << "\""
16704              << " : ";
16705     if (commaNeeded)
16706         _OUT << "\"" << VkExternalMemoryHandleTypeFlagBits_map[obj] << "\"," << std::endl;
16707     else
16708         _OUT << "\"" << VkExternalMemoryHandleTypeFlagBits_map[obj] << "\"" << std::endl;
16709 }
print_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits * obj,const std::string & str,bool commaNeeded=true)16710 static void print_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits *obj,
16711                                                      const std::string &str, bool commaNeeded = true)
16712 {
16713     PRINT_SPACE
16714     if (str != "")
16715         _OUT << "\"" << str << "\""
16716              << " : ";
16717     if (commaNeeded)
16718         _OUT << "\"" << VkExternalMemoryHandleTypeFlagBits_map[*obj] << "\"," << std::endl;
16719     else
16720         _OUT << "\"" << VkExternalMemoryHandleTypeFlagBits_map[*obj] << "\"" << std::endl;
16721 }
16722 
16723 static std::map<uint64_t, std::string> VkExternalMemoryFeatureFlagBits_map = {
16724     std::make_pair(1ULL << 0, "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT"),
16725     std::make_pair(1ULL << 1, "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT"),
16726     std::make_pair(1ULL << 2, "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT"),
16727 };
print_VkExternalMemoryFeatureFlagBits(VkExternalMemoryFeatureFlagBits obj,const std::string & str,bool commaNeeded=true)16728 static void print_VkExternalMemoryFeatureFlagBits(VkExternalMemoryFeatureFlagBits obj, const std::string &str,
16729                                                   bool commaNeeded = true)
16730 {
16731     PRINT_SPACE
16732     if (str != "")
16733         _OUT << "\"" << str << "\""
16734              << " : ";
16735     if (commaNeeded)
16736         _OUT << "\"" << VkExternalMemoryFeatureFlagBits_map[obj] << "\"," << std::endl;
16737     else
16738         _OUT << "\"" << VkExternalMemoryFeatureFlagBits_map[obj] << "\"" << std::endl;
16739 }
print_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits * obj,const std::string & str,bool commaNeeded=true)16740 static void print_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits *obj, const std::string &str,
16741                                                   bool commaNeeded = true)
16742 {
16743     PRINT_SPACE
16744     if (str != "")
16745         _OUT << "\"" << str << "\""
16746              << " : ";
16747     if (commaNeeded)
16748         _OUT << "\"" << VkExternalMemoryFeatureFlagBits_map[*obj] << "\"," << std::endl;
16749     else
16750         _OUT << "\"" << VkExternalMemoryFeatureFlagBits_map[*obj] << "\"" << std::endl;
16751 }
16752 
16753 static std::map<uint64_t, std::string> VkExternalFenceHandleTypeFlagBits_map = {
16754     std::make_pair(1ULL << 0, "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT"),
16755     std::make_pair(1ULL << 1, "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT"),
16756     std::make_pair(1ULL << 2, "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"),
16757     std::make_pair(1ULL << 3, "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT"),
16758     std::make_pair(1ULL << 4, "VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV"),
16759     std::make_pair(1ULL << 5, "VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV"),
16760     std::make_pair(1ULL << 4, "VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV"),
16761     std::make_pair(1ULL << 5, "VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV"),
16762 };
print_VkExternalFenceHandleTypeFlagBits(VkExternalFenceHandleTypeFlagBits obj,const std::string & str,bool commaNeeded=true)16763 static void print_VkExternalFenceHandleTypeFlagBits(VkExternalFenceHandleTypeFlagBits obj, const std::string &str,
16764                                                     bool commaNeeded = true)
16765 {
16766     PRINT_SPACE
16767     if (str != "")
16768         _OUT << "\"" << str << "\""
16769              << " : ";
16770     if (commaNeeded)
16771         _OUT << "\"" << VkExternalFenceHandleTypeFlagBits_map[obj] << "\"," << std::endl;
16772     else
16773         _OUT << "\"" << VkExternalFenceHandleTypeFlagBits_map[obj] << "\"" << std::endl;
16774 }
print_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits * obj,const std::string & str,bool commaNeeded=true)16775 static void print_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits *obj,
16776                                                     const std::string &str, bool commaNeeded = true)
16777 {
16778     PRINT_SPACE
16779     if (str != "")
16780         _OUT << "\"" << str << "\""
16781              << " : ";
16782     if (commaNeeded)
16783         _OUT << "\"" << VkExternalFenceHandleTypeFlagBits_map[*obj] << "\"," << std::endl;
16784     else
16785         _OUT << "\"" << VkExternalFenceHandleTypeFlagBits_map[*obj] << "\"" << std::endl;
16786 }
16787 
16788 static std::map<uint64_t, std::string> VkExternalFenceFeatureFlagBits_map = {
16789     std::make_pair(1ULL << 0, "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT"),
16790     std::make_pair(1ULL << 1, "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT"),
16791 };
print_VkExternalFenceFeatureFlagBits(VkExternalFenceFeatureFlagBits obj,const std::string & str,bool commaNeeded=true)16792 static void print_VkExternalFenceFeatureFlagBits(VkExternalFenceFeatureFlagBits obj, const std::string &str,
16793                                                  bool commaNeeded = true)
16794 {
16795     PRINT_SPACE
16796     if (str != "")
16797         _OUT << "\"" << str << "\""
16798              << " : ";
16799     if (commaNeeded)
16800         _OUT << "\"" << VkExternalFenceFeatureFlagBits_map[obj] << "\"," << std::endl;
16801     else
16802         _OUT << "\"" << VkExternalFenceFeatureFlagBits_map[obj] << "\"" << std::endl;
16803 }
print_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits * obj,const std::string & str,bool commaNeeded=true)16804 static void print_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits *obj, const std::string &str,
16805                                                  bool commaNeeded = true)
16806 {
16807     PRINT_SPACE
16808     if (str != "")
16809         _OUT << "\"" << str << "\""
16810              << " : ";
16811     if (commaNeeded)
16812         _OUT << "\"" << VkExternalFenceFeatureFlagBits_map[*obj] << "\"," << std::endl;
16813     else
16814         _OUT << "\"" << VkExternalFenceFeatureFlagBits_map[*obj] << "\"" << std::endl;
16815 }
16816 
16817 static std::map<uint64_t, std::string> VkFenceImportFlagBits_map = {
16818     std::make_pair(1ULL << 0, "VK_FENCE_IMPORT_TEMPORARY_BIT"),
16819 };
print_VkFenceImportFlagBits(VkFenceImportFlagBits obj,const std::string & str,bool commaNeeded=true)16820 static void print_VkFenceImportFlagBits(VkFenceImportFlagBits obj, const std::string &str, bool commaNeeded = true)
16821 {
16822     PRINT_SPACE
16823     if (str != "")
16824         _OUT << "\"" << str << "\""
16825              << " : ";
16826     if (commaNeeded)
16827         _OUT << "\"" << VkFenceImportFlagBits_map[obj] << "\"," << std::endl;
16828     else
16829         _OUT << "\"" << VkFenceImportFlagBits_map[obj] << "\"" << std::endl;
16830 }
print_VkFenceImportFlagBits(const VkFenceImportFlagBits * obj,const std::string & str,bool commaNeeded=true)16831 static void print_VkFenceImportFlagBits(const VkFenceImportFlagBits *obj, const std::string &str,
16832                                         bool commaNeeded = true)
16833 {
16834     PRINT_SPACE
16835     if (str != "")
16836         _OUT << "\"" << str << "\""
16837              << " : ";
16838     if (commaNeeded)
16839         _OUT << "\"" << VkFenceImportFlagBits_map[*obj] << "\"," << std::endl;
16840     else
16841         _OUT << "\"" << VkFenceImportFlagBits_map[*obj] << "\"" << std::endl;
16842 }
16843 
16844 static std::map<uint64_t, std::string> VkSemaphoreImportFlagBits_map = {
16845     std::make_pair(1ULL << 0, "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT"),
16846 };
print_VkSemaphoreImportFlagBits(VkSemaphoreImportFlagBits obj,const std::string & str,bool commaNeeded=true)16847 static void print_VkSemaphoreImportFlagBits(VkSemaphoreImportFlagBits obj, const std::string &str,
16848                                             bool commaNeeded = true)
16849 {
16850     PRINT_SPACE
16851     if (str != "")
16852         _OUT << "\"" << str << "\""
16853              << " : ";
16854     if (commaNeeded)
16855         _OUT << "\"" << VkSemaphoreImportFlagBits_map[obj] << "\"," << std::endl;
16856     else
16857         _OUT << "\"" << VkSemaphoreImportFlagBits_map[obj] << "\"" << std::endl;
16858 }
print_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits * obj,const std::string & str,bool commaNeeded=true)16859 static void print_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits *obj, const std::string &str,
16860                                             bool commaNeeded = true)
16861 {
16862     PRINT_SPACE
16863     if (str != "")
16864         _OUT << "\"" << str << "\""
16865              << " : ";
16866     if (commaNeeded)
16867         _OUT << "\"" << VkSemaphoreImportFlagBits_map[*obj] << "\"," << std::endl;
16868     else
16869         _OUT << "\"" << VkSemaphoreImportFlagBits_map[*obj] << "\"" << std::endl;
16870 }
16871 
16872 static std::map<uint64_t, std::string> VkExternalSemaphoreHandleTypeFlagBits_map = {
16873     std::make_pair(1ULL << 0, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT"),
16874     std::make_pair(1ULL << 1, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT"),
16875     std::make_pair(1ULL << 2, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"),
16876     std::make_pair(1ULL << 3, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT"),
16877     std::make_pair(1ULL << 4, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT"),
16878     std::make_pair(1ULL << 7, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA"),
16879     std::make_pair(1ULL << 5, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV"),
16880 };
print_VkExternalSemaphoreHandleTypeFlagBits(VkExternalSemaphoreHandleTypeFlagBits obj,const std::string & str,bool commaNeeded=true)16881 static void print_VkExternalSemaphoreHandleTypeFlagBits(VkExternalSemaphoreHandleTypeFlagBits obj,
16882                                                         const std::string &str, bool commaNeeded = true)
16883 {
16884     PRINT_SPACE
16885     if (str != "")
16886         _OUT << "\"" << str << "\""
16887              << " : ";
16888     if (commaNeeded)
16889         _OUT << "\"" << VkExternalSemaphoreHandleTypeFlagBits_map[obj] << "\"," << std::endl;
16890     else
16891         _OUT << "\"" << VkExternalSemaphoreHandleTypeFlagBits_map[obj] << "\"" << std::endl;
16892 }
print_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits * obj,const std::string & str,bool commaNeeded=true)16893 static void print_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits *obj,
16894                                                         const std::string &str, bool commaNeeded = true)
16895 {
16896     PRINT_SPACE
16897     if (str != "")
16898         _OUT << "\"" << str << "\""
16899              << " : ";
16900     if (commaNeeded)
16901         _OUT << "\"" << VkExternalSemaphoreHandleTypeFlagBits_map[*obj] << "\"," << std::endl;
16902     else
16903         _OUT << "\"" << VkExternalSemaphoreHandleTypeFlagBits_map[*obj] << "\"" << std::endl;
16904 }
16905 
16906 static std::map<uint64_t, std::string> VkExternalSemaphoreFeatureFlagBits_map = {
16907     std::make_pair(1ULL << 0, "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT"),
16908     std::make_pair(1ULL << 1, "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT"),
16909 };
print_VkExternalSemaphoreFeatureFlagBits(VkExternalSemaphoreFeatureFlagBits obj,const std::string & str,bool commaNeeded=true)16910 static void print_VkExternalSemaphoreFeatureFlagBits(VkExternalSemaphoreFeatureFlagBits obj, const std::string &str,
16911                                                      bool commaNeeded = true)
16912 {
16913     PRINT_SPACE
16914     if (str != "")
16915         _OUT << "\"" << str << "\""
16916              << " : ";
16917     if (commaNeeded)
16918         _OUT << "\"" << VkExternalSemaphoreFeatureFlagBits_map[obj] << "\"," << std::endl;
16919     else
16920         _OUT << "\"" << VkExternalSemaphoreFeatureFlagBits_map[obj] << "\"" << std::endl;
16921 }
print_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits * obj,const std::string & str,bool commaNeeded=true)16922 static void print_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits *obj,
16923                                                      const std::string &str, bool commaNeeded = true)
16924 {
16925     PRINT_SPACE
16926     if (str != "")
16927         _OUT << "\"" << str << "\""
16928              << " : ";
16929     if (commaNeeded)
16930         _OUT << "\"" << VkExternalSemaphoreFeatureFlagBits_map[*obj] << "\"," << std::endl;
16931     else
16932         _OUT << "\"" << VkExternalSemaphoreFeatureFlagBits_map[*obj] << "\"" << std::endl;
16933 }
16934 
print_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags obj,const std::string & str,bool commaNeeded=true)16935 static void print_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags obj, const std::string &str, bool commaNeeded = true)
16936 {
16937     PRINT_SPACE
16938     if (str != "")
16939         _OUT << "\"" << str << "\""
16940              << " : ";
16941     const int max_bits = 64; // We don't expect the number to be larger.
16942     std::bitset<max_bits> b(obj);
16943     _OUT << "\"";
16944     if (obj == 0)
16945         _OUT << "0";
16946     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
16947     {
16948         if (b[i] == 1)
16949         {
16950             bitCount++;
16951             if (bitCount < b.count())
16952                 _OUT << VkSubgroupFeatureFlagBits_map[1ULL << i] << " | ";
16953             else
16954                 _OUT << VkSubgroupFeatureFlagBits_map[1ULL << i];
16955         }
16956     }
16957     if (commaNeeded)
16958         _OUT << "\""
16959              << ",";
16960     else
16961         _OUT << "\""
16962              << "";
16963     _OUT << std::endl;
16964 }
print_VkSubgroupFeatureFlags(const VkSubgroupFeatureFlags * obj,const std::string & str,bool commaNeeded=true)16965 static void print_VkSubgroupFeatureFlags(const VkSubgroupFeatureFlags *obj, const std::string &str,
16966                                          bool commaNeeded = true)
16967 {
16968     PRINT_SPACE
16969     if (str != "")
16970         _OUT << "\"" << str << "\""
16971              << " : ";
16972     const int max_bits = 64; // We don't expect the number to be larger.
16973     std::bitset<max_bits> b(obj);
16974     _OUT << "\"";
16975     if (obj == 0)
16976         _OUT << "0";
16977     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
16978     {
16979         if (b[i] == 1)
16980         {
16981             bitCount++;
16982             if (bitCount < b.count())
16983                 _OUT << VkSubgroupFeatureFlagBits_map[1ULL << i] << " | ";
16984             else
16985                 _OUT << VkSubgroupFeatureFlagBits_map[1ULL << i];
16986         }
16987     }
16988     if (commaNeeded)
16989         _OUT << "\""
16990              << ",";
16991     else
16992         _OUT << "\""
16993              << "";
16994     _OUT << std::endl;
16995 }
16996 
print_VkPeerMemoryFeatureFlags(VkPeerMemoryFeatureFlags obj,const std::string & str,bool commaNeeded=true)16997 static void print_VkPeerMemoryFeatureFlags(VkPeerMemoryFeatureFlags obj, const std::string &str,
16998                                            bool commaNeeded = true)
16999 {
17000     PRINT_SPACE
17001     if (str != "")
17002         _OUT << "\"" << str << "\""
17003              << " : ";
17004     const int max_bits = 64; // We don't expect the number to be larger.
17005     std::bitset<max_bits> b(obj);
17006     _OUT << "\"";
17007     if (obj == 0)
17008         _OUT << "0";
17009     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17010     {
17011         if (b[i] == 1)
17012         {
17013             bitCount++;
17014             if (bitCount < b.count())
17015                 _OUT << VkPeerMemoryFeatureFlagBits_map[1ULL << i] << " | ";
17016             else
17017                 _OUT << VkPeerMemoryFeatureFlagBits_map[1ULL << i];
17018         }
17019     }
17020     if (commaNeeded)
17021         _OUT << "\""
17022              << ",";
17023     else
17024         _OUT << "\""
17025              << "";
17026     _OUT << std::endl;
17027 }
print_VkPeerMemoryFeatureFlags(const VkPeerMemoryFeatureFlags * obj,const std::string & str,bool commaNeeded=true)17028 static void print_VkPeerMemoryFeatureFlags(const VkPeerMemoryFeatureFlags *obj, const std::string &str,
17029                                            bool commaNeeded = true)
17030 {
17031     PRINT_SPACE
17032     if (str != "")
17033         _OUT << "\"" << str << "\""
17034              << " : ";
17035     const int max_bits = 64; // We don't expect the number to be larger.
17036     std::bitset<max_bits> b(obj);
17037     _OUT << "\"";
17038     if (obj == 0)
17039         _OUT << "0";
17040     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17041     {
17042         if (b[i] == 1)
17043         {
17044             bitCount++;
17045             if (bitCount < b.count())
17046                 _OUT << VkPeerMemoryFeatureFlagBits_map[1ULL << i] << " | ";
17047             else
17048                 _OUT << VkPeerMemoryFeatureFlagBits_map[1ULL << i];
17049         }
17050     }
17051     if (commaNeeded)
17052         _OUT << "\""
17053              << ",";
17054     else
17055         _OUT << "\""
17056              << "";
17057     _OUT << std::endl;
17058 }
17059 
print_VkMemoryAllocateFlags(VkMemoryAllocateFlags obj,const std::string & str,bool commaNeeded=true)17060 static void print_VkMemoryAllocateFlags(VkMemoryAllocateFlags obj, const std::string &str, bool commaNeeded = true)
17061 {
17062     PRINT_SPACE
17063     if (str != "")
17064         _OUT << "\"" << str << "\""
17065              << " : ";
17066     const int max_bits = 64; // We don't expect the number to be larger.
17067     std::bitset<max_bits> b(obj);
17068     _OUT << "\"";
17069     if (obj == 0)
17070         _OUT << "0";
17071     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17072     {
17073         if (b[i] == 1)
17074         {
17075             bitCount++;
17076             if (bitCount < b.count())
17077                 _OUT << VkMemoryAllocateFlagBits_map[1ULL << i] << " | ";
17078             else
17079                 _OUT << VkMemoryAllocateFlagBits_map[1ULL << i];
17080         }
17081     }
17082     if (commaNeeded)
17083         _OUT << "\""
17084              << ",";
17085     else
17086         _OUT << "\""
17087              << "";
17088     _OUT << std::endl;
17089 }
print_VkMemoryAllocateFlags(const VkMemoryAllocateFlags * obj,const std::string & str,bool commaNeeded=true)17090 static void print_VkMemoryAllocateFlags(const VkMemoryAllocateFlags *obj, const std::string &str,
17091                                         bool commaNeeded = true)
17092 {
17093     PRINT_SPACE
17094     if (str != "")
17095         _OUT << "\"" << str << "\""
17096              << " : ";
17097     const int max_bits = 64; // We don't expect the number to be larger.
17098     std::bitset<max_bits> b(obj);
17099     _OUT << "\"";
17100     if (obj == 0)
17101         _OUT << "0";
17102     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17103     {
17104         if (b[i] == 1)
17105         {
17106             bitCount++;
17107             if (bitCount < b.count())
17108                 _OUT << VkMemoryAllocateFlagBits_map[1ULL << i] << " | ";
17109             else
17110                 _OUT << VkMemoryAllocateFlagBits_map[1ULL << i];
17111         }
17112     }
17113     if (commaNeeded)
17114         _OUT << "\""
17115              << ",";
17116     else
17117         _OUT << "\""
17118              << "";
17119     _OUT << std::endl;
17120 }
17121 
print_VkExternalMemoryHandleTypeFlags(VkExternalMemoryHandleTypeFlags obj,const std::string & str,bool commaNeeded=true)17122 static void print_VkExternalMemoryHandleTypeFlags(VkExternalMemoryHandleTypeFlags obj, const std::string &str,
17123                                                   bool commaNeeded = true)
17124 {
17125     PRINT_SPACE
17126     if (str != "")
17127         _OUT << "\"" << str << "\""
17128              << " : ";
17129     const int max_bits = 64; // We don't expect the number to be larger.
17130     std::bitset<max_bits> b(obj);
17131     _OUT << "\"";
17132     if (obj == 0)
17133         _OUT << "0";
17134     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17135     {
17136         if (b[i] == 1)
17137         {
17138             bitCount++;
17139             if (bitCount < b.count())
17140                 _OUT << VkExternalMemoryHandleTypeFlagBits_map[1ULL << i] << " | ";
17141             else
17142                 _OUT << VkExternalMemoryHandleTypeFlagBits_map[1ULL << i];
17143         }
17144     }
17145     if (commaNeeded)
17146         _OUT << "\""
17147              << ",";
17148     else
17149         _OUT << "\""
17150              << "";
17151     _OUT << std::endl;
17152 }
print_VkExternalMemoryHandleTypeFlags(const VkExternalMemoryHandleTypeFlags * obj,const std::string & str,bool commaNeeded=true)17153 static void print_VkExternalMemoryHandleTypeFlags(const VkExternalMemoryHandleTypeFlags *obj, const std::string &str,
17154                                                   bool commaNeeded = true)
17155 {
17156     PRINT_SPACE
17157     if (str != "")
17158         _OUT << "\"" << str << "\""
17159              << " : ";
17160     const int max_bits = 64; // We don't expect the number to be larger.
17161     std::bitset<max_bits> b(obj);
17162     _OUT << "\"";
17163     if (obj == 0)
17164         _OUT << "0";
17165     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17166     {
17167         if (b[i] == 1)
17168         {
17169             bitCount++;
17170             if (bitCount < b.count())
17171                 _OUT << VkExternalMemoryHandleTypeFlagBits_map[1ULL << i] << " | ";
17172             else
17173                 _OUT << VkExternalMemoryHandleTypeFlagBits_map[1ULL << i];
17174         }
17175     }
17176     if (commaNeeded)
17177         _OUT << "\""
17178              << ",";
17179     else
17180         _OUT << "\""
17181              << "";
17182     _OUT << std::endl;
17183 }
17184 
print_VkExternalMemoryFeatureFlags(VkExternalMemoryFeatureFlags obj,const std::string & str,bool commaNeeded=true)17185 static void print_VkExternalMemoryFeatureFlags(VkExternalMemoryFeatureFlags obj, const std::string &str,
17186                                                bool commaNeeded = true)
17187 {
17188     PRINT_SPACE
17189     if (str != "")
17190         _OUT << "\"" << str << "\""
17191              << " : ";
17192     const int max_bits = 64; // We don't expect the number to be larger.
17193     std::bitset<max_bits> b(obj);
17194     _OUT << "\"";
17195     if (obj == 0)
17196         _OUT << "0";
17197     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17198     {
17199         if (b[i] == 1)
17200         {
17201             bitCount++;
17202             if (bitCount < b.count())
17203                 _OUT << VkExternalMemoryFeatureFlagBits_map[1ULL << i] << " | ";
17204             else
17205                 _OUT << VkExternalMemoryFeatureFlagBits_map[1ULL << i];
17206         }
17207     }
17208     if (commaNeeded)
17209         _OUT << "\""
17210              << ",";
17211     else
17212         _OUT << "\""
17213              << "";
17214     _OUT << std::endl;
17215 }
print_VkExternalMemoryFeatureFlags(const VkExternalMemoryFeatureFlags * obj,const std::string & str,bool commaNeeded=true)17216 static void print_VkExternalMemoryFeatureFlags(const VkExternalMemoryFeatureFlags *obj, const std::string &str,
17217                                                bool commaNeeded = true)
17218 {
17219     PRINT_SPACE
17220     if (str != "")
17221         _OUT << "\"" << str << "\""
17222              << " : ";
17223     const int max_bits = 64; // We don't expect the number to be larger.
17224     std::bitset<max_bits> b(obj);
17225     _OUT << "\"";
17226     if (obj == 0)
17227         _OUT << "0";
17228     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17229     {
17230         if (b[i] == 1)
17231         {
17232             bitCount++;
17233             if (bitCount < b.count())
17234                 _OUT << VkExternalMemoryFeatureFlagBits_map[1ULL << i] << " | ";
17235             else
17236                 _OUT << VkExternalMemoryFeatureFlagBits_map[1ULL << i];
17237         }
17238     }
17239     if (commaNeeded)
17240         _OUT << "\""
17241              << ",";
17242     else
17243         _OUT << "\""
17244              << "";
17245     _OUT << std::endl;
17246 }
17247 
print_VkExternalFenceHandleTypeFlags(VkExternalFenceHandleTypeFlags obj,const std::string & str,bool commaNeeded=true)17248 static void print_VkExternalFenceHandleTypeFlags(VkExternalFenceHandleTypeFlags obj, const std::string &str,
17249                                                  bool commaNeeded = true)
17250 {
17251     PRINT_SPACE
17252     if (str != "")
17253         _OUT << "\"" << str << "\""
17254              << " : ";
17255     const int max_bits = 64; // We don't expect the number to be larger.
17256     std::bitset<max_bits> b(obj);
17257     _OUT << "\"";
17258     if (obj == 0)
17259         _OUT << "0";
17260     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17261     {
17262         if (b[i] == 1)
17263         {
17264             bitCount++;
17265             if (bitCount < b.count())
17266                 _OUT << VkExternalFenceHandleTypeFlagBits_map[1ULL << i] << " | ";
17267             else
17268                 _OUT << VkExternalFenceHandleTypeFlagBits_map[1ULL << i];
17269         }
17270     }
17271     if (commaNeeded)
17272         _OUT << "\""
17273              << ",";
17274     else
17275         _OUT << "\""
17276              << "";
17277     _OUT << std::endl;
17278 }
print_VkExternalFenceHandleTypeFlags(const VkExternalFenceHandleTypeFlags * obj,const std::string & str,bool commaNeeded=true)17279 static void print_VkExternalFenceHandleTypeFlags(const VkExternalFenceHandleTypeFlags *obj, const std::string &str,
17280                                                  bool commaNeeded = true)
17281 {
17282     PRINT_SPACE
17283     if (str != "")
17284         _OUT << "\"" << str << "\""
17285              << " : ";
17286     const int max_bits = 64; // We don't expect the number to be larger.
17287     std::bitset<max_bits> b(obj);
17288     _OUT << "\"";
17289     if (obj == 0)
17290         _OUT << "0";
17291     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17292     {
17293         if (b[i] == 1)
17294         {
17295             bitCount++;
17296             if (bitCount < b.count())
17297                 _OUT << VkExternalFenceHandleTypeFlagBits_map[1ULL << i] << " | ";
17298             else
17299                 _OUT << VkExternalFenceHandleTypeFlagBits_map[1ULL << i];
17300         }
17301     }
17302     if (commaNeeded)
17303         _OUT << "\""
17304              << ",";
17305     else
17306         _OUT << "\""
17307              << "";
17308     _OUT << std::endl;
17309 }
17310 
print_VkExternalFenceFeatureFlags(VkExternalFenceFeatureFlags obj,const std::string & str,bool commaNeeded=true)17311 static void print_VkExternalFenceFeatureFlags(VkExternalFenceFeatureFlags obj, const std::string &str,
17312                                               bool commaNeeded = true)
17313 {
17314     PRINT_SPACE
17315     if (str != "")
17316         _OUT << "\"" << str << "\""
17317              << " : ";
17318     const int max_bits = 64; // We don't expect the number to be larger.
17319     std::bitset<max_bits> b(obj);
17320     _OUT << "\"";
17321     if (obj == 0)
17322         _OUT << "0";
17323     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17324     {
17325         if (b[i] == 1)
17326         {
17327             bitCount++;
17328             if (bitCount < b.count())
17329                 _OUT << VkExternalFenceFeatureFlagBits_map[1ULL << i] << " | ";
17330             else
17331                 _OUT << VkExternalFenceFeatureFlagBits_map[1ULL << i];
17332         }
17333     }
17334     if (commaNeeded)
17335         _OUT << "\""
17336              << ",";
17337     else
17338         _OUT << "\""
17339              << "";
17340     _OUT << std::endl;
17341 }
print_VkExternalFenceFeatureFlags(const VkExternalFenceFeatureFlags * obj,const std::string & str,bool commaNeeded=true)17342 static void print_VkExternalFenceFeatureFlags(const VkExternalFenceFeatureFlags *obj, const std::string &str,
17343                                               bool commaNeeded = true)
17344 {
17345     PRINT_SPACE
17346     if (str != "")
17347         _OUT << "\"" << str << "\""
17348              << " : ";
17349     const int max_bits = 64; // We don't expect the number to be larger.
17350     std::bitset<max_bits> b(obj);
17351     _OUT << "\"";
17352     if (obj == 0)
17353         _OUT << "0";
17354     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17355     {
17356         if (b[i] == 1)
17357         {
17358             bitCount++;
17359             if (bitCount < b.count())
17360                 _OUT << VkExternalFenceFeatureFlagBits_map[1ULL << i] << " | ";
17361             else
17362                 _OUT << VkExternalFenceFeatureFlagBits_map[1ULL << i];
17363         }
17364     }
17365     if (commaNeeded)
17366         _OUT << "\""
17367              << ",";
17368     else
17369         _OUT << "\""
17370              << "";
17371     _OUT << std::endl;
17372 }
17373 
print_VkFenceImportFlags(VkFenceImportFlags obj,const std::string & str,bool commaNeeded=true)17374 static void print_VkFenceImportFlags(VkFenceImportFlags obj, const std::string &str, bool commaNeeded = true)
17375 {
17376     PRINT_SPACE
17377     if (str != "")
17378         _OUT << "\"" << str << "\""
17379              << " : ";
17380     const int max_bits = 64; // We don't expect the number to be larger.
17381     std::bitset<max_bits> b(obj);
17382     _OUT << "\"";
17383     if (obj == 0)
17384         _OUT << "0";
17385     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17386     {
17387         if (b[i] == 1)
17388         {
17389             bitCount++;
17390             if (bitCount < b.count())
17391                 _OUT << VkFenceImportFlagBits_map[1ULL << i] << " | ";
17392             else
17393                 _OUT << VkFenceImportFlagBits_map[1ULL << i];
17394         }
17395     }
17396     if (commaNeeded)
17397         _OUT << "\""
17398              << ",";
17399     else
17400         _OUT << "\""
17401              << "";
17402     _OUT << std::endl;
17403 }
print_VkFenceImportFlags(const VkFenceImportFlags * obj,const std::string & str,bool commaNeeded=true)17404 static void print_VkFenceImportFlags(const VkFenceImportFlags *obj, const std::string &str, bool commaNeeded = true)
17405 {
17406     PRINT_SPACE
17407     if (str != "")
17408         _OUT << "\"" << str << "\""
17409              << " : ";
17410     const int max_bits = 64; // We don't expect the number to be larger.
17411     std::bitset<max_bits> b(obj);
17412     _OUT << "\"";
17413     if (obj == 0)
17414         _OUT << "0";
17415     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17416     {
17417         if (b[i] == 1)
17418         {
17419             bitCount++;
17420             if (bitCount < b.count())
17421                 _OUT << VkFenceImportFlagBits_map[1ULL << i] << " | ";
17422             else
17423                 _OUT << VkFenceImportFlagBits_map[1ULL << i];
17424         }
17425     }
17426     if (commaNeeded)
17427         _OUT << "\""
17428              << ",";
17429     else
17430         _OUT << "\""
17431              << "";
17432     _OUT << std::endl;
17433 }
17434 
print_VkSemaphoreImportFlags(VkSemaphoreImportFlags obj,const std::string & str,bool commaNeeded=true)17435 static void print_VkSemaphoreImportFlags(VkSemaphoreImportFlags obj, const std::string &str, bool commaNeeded = true)
17436 {
17437     PRINT_SPACE
17438     if (str != "")
17439         _OUT << "\"" << str << "\""
17440              << " : ";
17441     const int max_bits = 64; // We don't expect the number to be larger.
17442     std::bitset<max_bits> b(obj);
17443     _OUT << "\"";
17444     if (obj == 0)
17445         _OUT << "0";
17446     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17447     {
17448         if (b[i] == 1)
17449         {
17450             bitCount++;
17451             if (bitCount < b.count())
17452                 _OUT << VkSemaphoreImportFlagBits_map[1ULL << i] << " | ";
17453             else
17454                 _OUT << VkSemaphoreImportFlagBits_map[1ULL << i];
17455         }
17456     }
17457     if (commaNeeded)
17458         _OUT << "\""
17459              << ",";
17460     else
17461         _OUT << "\""
17462              << "";
17463     _OUT << std::endl;
17464 }
print_VkSemaphoreImportFlags(const VkSemaphoreImportFlags * obj,const std::string & str,bool commaNeeded=true)17465 static void print_VkSemaphoreImportFlags(const VkSemaphoreImportFlags *obj, const std::string &str,
17466                                          bool commaNeeded = true)
17467 {
17468     PRINT_SPACE
17469     if (str != "")
17470         _OUT << "\"" << str << "\""
17471              << " : ";
17472     const int max_bits = 64; // We don't expect the number to be larger.
17473     std::bitset<max_bits> b(obj);
17474     _OUT << "\"";
17475     if (obj == 0)
17476         _OUT << "0";
17477     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17478     {
17479         if (b[i] == 1)
17480         {
17481             bitCount++;
17482             if (bitCount < b.count())
17483                 _OUT << VkSemaphoreImportFlagBits_map[1ULL << i] << " | ";
17484             else
17485                 _OUT << VkSemaphoreImportFlagBits_map[1ULL << i];
17486         }
17487     }
17488     if (commaNeeded)
17489         _OUT << "\""
17490              << ",";
17491     else
17492         _OUT << "\""
17493              << "";
17494     _OUT << std::endl;
17495 }
17496 
print_VkExternalSemaphoreHandleTypeFlags(VkExternalSemaphoreHandleTypeFlags obj,const std::string & str,bool commaNeeded=true)17497 static void print_VkExternalSemaphoreHandleTypeFlags(VkExternalSemaphoreHandleTypeFlags obj, const std::string &str,
17498                                                      bool commaNeeded = true)
17499 {
17500     PRINT_SPACE
17501     if (str != "")
17502         _OUT << "\"" << str << "\""
17503              << " : ";
17504     const int max_bits = 64; // We don't expect the number to be larger.
17505     std::bitset<max_bits> b(obj);
17506     _OUT << "\"";
17507     if (obj == 0)
17508         _OUT << "0";
17509     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17510     {
17511         if (b[i] == 1)
17512         {
17513             bitCount++;
17514             if (bitCount < b.count())
17515                 _OUT << VkExternalSemaphoreHandleTypeFlagBits_map[1ULL << i] << " | ";
17516             else
17517                 _OUT << VkExternalSemaphoreHandleTypeFlagBits_map[1ULL << i];
17518         }
17519     }
17520     if (commaNeeded)
17521         _OUT << "\""
17522              << ",";
17523     else
17524         _OUT << "\""
17525              << "";
17526     _OUT << std::endl;
17527 }
print_VkExternalSemaphoreHandleTypeFlags(const VkExternalSemaphoreHandleTypeFlags * obj,const std::string & str,bool commaNeeded=true)17528 static void print_VkExternalSemaphoreHandleTypeFlags(const VkExternalSemaphoreHandleTypeFlags *obj,
17529                                                      const std::string &str, bool commaNeeded = true)
17530 {
17531     PRINT_SPACE
17532     if (str != "")
17533         _OUT << "\"" << str << "\""
17534              << " : ";
17535     const int max_bits = 64; // We don't expect the number to be larger.
17536     std::bitset<max_bits> b(obj);
17537     _OUT << "\"";
17538     if (obj == 0)
17539         _OUT << "0";
17540     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17541     {
17542         if (b[i] == 1)
17543         {
17544             bitCount++;
17545             if (bitCount < b.count())
17546                 _OUT << VkExternalSemaphoreHandleTypeFlagBits_map[1ULL << i] << " | ";
17547             else
17548                 _OUT << VkExternalSemaphoreHandleTypeFlagBits_map[1ULL << i];
17549         }
17550     }
17551     if (commaNeeded)
17552         _OUT << "\""
17553              << ",";
17554     else
17555         _OUT << "\""
17556              << "";
17557     _OUT << std::endl;
17558 }
17559 
print_VkExternalSemaphoreFeatureFlags(VkExternalSemaphoreFeatureFlags obj,const std::string & str,bool commaNeeded=true)17560 static void print_VkExternalSemaphoreFeatureFlags(VkExternalSemaphoreFeatureFlags obj, const std::string &str,
17561                                                   bool commaNeeded = true)
17562 {
17563     PRINT_SPACE
17564     if (str != "")
17565         _OUT << "\"" << str << "\""
17566              << " : ";
17567     const int max_bits = 64; // We don't expect the number to be larger.
17568     std::bitset<max_bits> b(obj);
17569     _OUT << "\"";
17570     if (obj == 0)
17571         _OUT << "0";
17572     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17573     {
17574         if (b[i] == 1)
17575         {
17576             bitCount++;
17577             if (bitCount < b.count())
17578                 _OUT << VkExternalSemaphoreFeatureFlagBits_map[1ULL << i] << " | ";
17579             else
17580                 _OUT << VkExternalSemaphoreFeatureFlagBits_map[1ULL << i];
17581         }
17582     }
17583     if (commaNeeded)
17584         _OUT << "\""
17585              << ",";
17586     else
17587         _OUT << "\""
17588              << "";
17589     _OUT << std::endl;
17590 }
print_VkExternalSemaphoreFeatureFlags(const VkExternalSemaphoreFeatureFlags * obj,const std::string & str,bool commaNeeded=true)17591 static void print_VkExternalSemaphoreFeatureFlags(const VkExternalSemaphoreFeatureFlags *obj, const std::string &str,
17592                                                   bool commaNeeded = true)
17593 {
17594     PRINT_SPACE
17595     if (str != "")
17596         _OUT << "\"" << str << "\""
17597              << " : ";
17598     const int max_bits = 64; // We don't expect the number to be larger.
17599     std::bitset<max_bits> b(obj);
17600     _OUT << "\"";
17601     if (obj == 0)
17602         _OUT << "0";
17603     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
17604     {
17605         if (b[i] == 1)
17606         {
17607             bitCount++;
17608             if (bitCount < b.count())
17609                 _OUT << VkExternalSemaphoreFeatureFlagBits_map[1ULL << i] << " | ";
17610             else
17611                 _OUT << VkExternalSemaphoreFeatureFlagBits_map[1ULL << i];
17612         }
17613     }
17614     if (commaNeeded)
17615         _OUT << "\""
17616              << ",";
17617     else
17618         _OUT << "\""
17619              << "";
17620     _OUT << std::endl;
17621 }
17622 
print_VkPhysicalDeviceSubgroupProperties(VkPhysicalDeviceSubgroupProperties obj,const std::string & s,bool commaNeeded=true)17623 static void print_VkPhysicalDeviceSubgroupProperties(VkPhysicalDeviceSubgroupProperties obj, const std::string &s,
17624                                                      bool commaNeeded = true)
17625 {
17626     PRINT_SPACE
17627     _OUT << "{" << std::endl;
17628     INDENT(4);
17629 
17630     print_VkStructureType(obj.sType, "sType", 1);
17631 
17632     if (obj.pNext)
17633     {
17634         dumpPNextChain(obj.pNext);
17635     }
17636     else
17637     {
17638         PRINT_SPACE
17639         _OUT << "\"pNext\":"
17640              << "\"NULL\""
17641              << "," << std::endl;
17642     }
17643 
17644     print_uint32_t(obj.subgroupSize, "subgroupSize", 1);
17645 
17646     print_VkShaderStageFlags(obj.supportedStages, "supportedStages", 1);
17647 
17648     print_VkSubgroupFeatureFlags(obj.supportedOperations, "supportedOperations", 1);
17649 
17650     print_VkBool32(obj.quadOperationsInAllStages, "quadOperationsInAllStages", 0);
17651 
17652     INDENT(-4);
17653     PRINT_SPACE
17654     if (commaNeeded)
17655         _OUT << "}," << std::endl;
17656     else
17657         _OUT << "}" << std::endl;
17658 }
print_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties * obj,const std::string & s,bool commaNeeded=true)17659 static void print_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties *obj,
17660                                                      const std::string &s, bool commaNeeded = true)
17661 {
17662     PRINT_SPACE
17663     _OUT << "{" << std::endl;
17664     INDENT(4);
17665 
17666     print_VkStructureType(obj->sType, "sType", 1);
17667 
17668     if (obj->pNext)
17669     {
17670         dumpPNextChain(obj->pNext);
17671     }
17672     else
17673     {
17674         PRINT_SPACE
17675         _OUT << "\"pNext\":"
17676              << "\"NULL\""
17677              << "," << std::endl;
17678     }
17679 
17680     print_uint32_t(obj->subgroupSize, "subgroupSize", 1);
17681 
17682     print_VkShaderStageFlags(obj->supportedStages, "supportedStages", 1);
17683 
17684     print_VkSubgroupFeatureFlags(obj->supportedOperations, "supportedOperations", 1);
17685 
17686     print_VkBool32(obj->quadOperationsInAllStages, "quadOperationsInAllStages", 0);
17687 
17688     INDENT(-4);
17689     PRINT_SPACE
17690     if (commaNeeded)
17691         _OUT << "}," << std::endl;
17692     else
17693         _OUT << "}" << std::endl;
17694 }
17695 
print_VkBindBufferMemoryInfo(VkBindBufferMemoryInfo obj,const std::string & s,bool commaNeeded=true)17696 static void print_VkBindBufferMemoryInfo(VkBindBufferMemoryInfo obj, const std::string &s, bool commaNeeded = true)
17697 {
17698     PRINT_SPACE
17699     _OUT << "{" << std::endl;
17700     INDENT(4);
17701 
17702     print_VkStructureType(obj.sType, "sType", 1);
17703 
17704     if (obj.pNext)
17705     {
17706         dumpPNextChain(obj.pNext);
17707     }
17708     else
17709     {
17710         PRINT_SPACE
17711         _OUT << "\"pNext\":"
17712              << "\"NULL\""
17713              << "," << std::endl;
17714     }
17715 
17716     // CTS : required value
17717     PRINT_SPACE _OUT << "\""
17718                      << "buffer"
17719                      << "\""
17720                      << " : "
17721                      << "\""
17722                      << "\"," << std::endl;
17723 
17724     // CTS : required value
17725     PRINT_SPACE _OUT << "\""
17726                      << "memory"
17727                      << "\""
17728                      << " : "
17729                      << "\""
17730                      << "\"," << std::endl;
17731 
17732     print_VkDeviceSize(obj.memoryOffset, "memoryOffset", 0);
17733 
17734     INDENT(-4);
17735     PRINT_SPACE
17736     if (commaNeeded)
17737         _OUT << "}," << std::endl;
17738     else
17739         _OUT << "}" << std::endl;
17740 }
print_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo * obj,const std::string & s,bool commaNeeded=true)17741 static void print_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo *obj, const std::string &s,
17742                                          bool commaNeeded = true)
17743 {
17744     PRINT_SPACE
17745     _OUT << "{" << std::endl;
17746     INDENT(4);
17747 
17748     print_VkStructureType(obj->sType, "sType", 1);
17749 
17750     if (obj->pNext)
17751     {
17752         dumpPNextChain(obj->pNext);
17753     }
17754     else
17755     {
17756         PRINT_SPACE
17757         _OUT << "\"pNext\":"
17758              << "\"NULL\""
17759              << "," << std::endl;
17760     }
17761 
17762     // CTS : required value
17763     PRINT_SPACE _OUT << "\""
17764                      << "buffer"
17765                      << "\""
17766                      << " : "
17767                      << "\""
17768                      << "\"," << std::endl;
17769 
17770     // CTS : required value
17771     PRINT_SPACE _OUT << "\""
17772                      << "memory"
17773                      << "\""
17774                      << " : "
17775                      << "\""
17776                      << "\"," << std::endl;
17777 
17778     print_VkDeviceSize(obj->memoryOffset, "memoryOffset", 0);
17779 
17780     INDENT(-4);
17781     PRINT_SPACE
17782     if (commaNeeded)
17783         _OUT << "}," << std::endl;
17784     else
17785         _OUT << "}" << std::endl;
17786 }
17787 
print_VkBindImageMemoryInfo(VkBindImageMemoryInfo obj,const std::string & s,bool commaNeeded=true)17788 static void print_VkBindImageMemoryInfo(VkBindImageMemoryInfo obj, const std::string &s, bool commaNeeded = true)
17789 {
17790     PRINT_SPACE
17791     _OUT << "{" << std::endl;
17792     INDENT(4);
17793 
17794     print_VkStructureType(obj.sType, "sType", 1);
17795 
17796     if (obj.pNext)
17797     {
17798         dumpPNextChain(obj.pNext);
17799     }
17800     else
17801     {
17802         PRINT_SPACE
17803         _OUT << "\"pNext\":"
17804              << "\"NULL\""
17805              << "," << std::endl;
17806     }
17807 
17808     // CTS : required value
17809     PRINT_SPACE _OUT << "\""
17810                      << "image"
17811                      << "\""
17812                      << " : "
17813                      << "\""
17814                      << "\"," << std::endl;
17815 
17816     // CTS : required value
17817     PRINT_SPACE _OUT << "\""
17818                      << "memory"
17819                      << "\""
17820                      << " : "
17821                      << "\""
17822                      << "\"," << std::endl;
17823 
17824     print_VkDeviceSize(obj.memoryOffset, "memoryOffset", 0);
17825 
17826     INDENT(-4);
17827     PRINT_SPACE
17828     if (commaNeeded)
17829         _OUT << "}," << std::endl;
17830     else
17831         _OUT << "}" << std::endl;
17832 }
print_VkBindImageMemoryInfo(const VkBindImageMemoryInfo * obj,const std::string & s,bool commaNeeded=true)17833 static void print_VkBindImageMemoryInfo(const VkBindImageMemoryInfo *obj, const std::string &s, bool commaNeeded = true)
17834 {
17835     PRINT_SPACE
17836     _OUT << "{" << std::endl;
17837     INDENT(4);
17838 
17839     print_VkStructureType(obj->sType, "sType", 1);
17840 
17841     if (obj->pNext)
17842     {
17843         dumpPNextChain(obj->pNext);
17844     }
17845     else
17846     {
17847         PRINT_SPACE
17848         _OUT << "\"pNext\":"
17849              << "\"NULL\""
17850              << "," << std::endl;
17851     }
17852 
17853     // CTS : required value
17854     PRINT_SPACE _OUT << "\""
17855                      << "image"
17856                      << "\""
17857                      << " : "
17858                      << "\""
17859                      << "\"," << std::endl;
17860 
17861     // CTS : required value
17862     PRINT_SPACE _OUT << "\""
17863                      << "memory"
17864                      << "\""
17865                      << " : "
17866                      << "\""
17867                      << "\"," << std::endl;
17868 
17869     print_VkDeviceSize(obj->memoryOffset, "memoryOffset", 0);
17870 
17871     INDENT(-4);
17872     PRINT_SPACE
17873     if (commaNeeded)
17874         _OUT << "}," << std::endl;
17875     else
17876         _OUT << "}" << std::endl;
17877 }
17878 
print_VkPhysicalDevice16BitStorageFeatures(VkPhysicalDevice16BitStorageFeatures obj,const std::string & s,bool commaNeeded=true)17879 static void print_VkPhysicalDevice16BitStorageFeatures(VkPhysicalDevice16BitStorageFeatures obj, const std::string &s,
17880                                                        bool commaNeeded = true)
17881 {
17882     PRINT_SPACE
17883     _OUT << "{" << std::endl;
17884     INDENT(4);
17885 
17886     print_VkStructureType(obj.sType, "sType", 1);
17887 
17888     if (obj.pNext)
17889     {
17890         dumpPNextChain(obj.pNext);
17891     }
17892     else
17893     {
17894         PRINT_SPACE
17895         _OUT << "\"pNext\":"
17896              << "\"NULL\""
17897              << "," << std::endl;
17898     }
17899 
17900     print_VkBool32(obj.storageBuffer16BitAccess, "storageBuffer16BitAccess", 1);
17901 
17902     print_VkBool32(obj.uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1);
17903 
17904     print_VkBool32(obj.storagePushConstant16, "storagePushConstant16", 1);
17905 
17906     print_VkBool32(obj.storageInputOutput16, "storageInputOutput16", 0);
17907 
17908     INDENT(-4);
17909     PRINT_SPACE
17910     if (commaNeeded)
17911         _OUT << "}," << std::endl;
17912     else
17913         _OUT << "}" << std::endl;
17914 }
print_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures * obj,const std::string & s,bool commaNeeded=true)17915 static void print_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures *obj,
17916                                                        const std::string &s, bool commaNeeded = true)
17917 {
17918     PRINT_SPACE
17919     _OUT << "{" << std::endl;
17920     INDENT(4);
17921 
17922     print_VkStructureType(obj->sType, "sType", 1);
17923 
17924     if (obj->pNext)
17925     {
17926         dumpPNextChain(obj->pNext);
17927     }
17928     else
17929     {
17930         PRINT_SPACE
17931         _OUT << "\"pNext\":"
17932              << "\"NULL\""
17933              << "," << std::endl;
17934     }
17935 
17936     print_VkBool32(obj->storageBuffer16BitAccess, "storageBuffer16BitAccess", 1);
17937 
17938     print_VkBool32(obj->uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1);
17939 
17940     print_VkBool32(obj->storagePushConstant16, "storagePushConstant16", 1);
17941 
17942     print_VkBool32(obj->storageInputOutput16, "storageInputOutput16", 0);
17943 
17944     INDENT(-4);
17945     PRINT_SPACE
17946     if (commaNeeded)
17947         _OUT << "}," << std::endl;
17948     else
17949         _OUT << "}" << std::endl;
17950 }
17951 
print_VkMemoryDedicatedRequirements(VkMemoryDedicatedRequirements obj,const std::string & s,bool commaNeeded=true)17952 static void print_VkMemoryDedicatedRequirements(VkMemoryDedicatedRequirements obj, const std::string &s,
17953                                                 bool commaNeeded = true)
17954 {
17955     PRINT_SPACE
17956     _OUT << "{" << std::endl;
17957     INDENT(4);
17958 
17959     print_VkStructureType(obj.sType, "sType", 1);
17960 
17961     if (obj.pNext)
17962     {
17963         dumpPNextChain(obj.pNext);
17964     }
17965     else
17966     {
17967         PRINT_SPACE
17968         _OUT << "\"pNext\":"
17969              << "\"NULL\""
17970              << "," << std::endl;
17971     }
17972 
17973     print_VkBool32(obj.prefersDedicatedAllocation, "prefersDedicatedAllocation", 1);
17974 
17975     print_VkBool32(obj.requiresDedicatedAllocation, "requiresDedicatedAllocation", 0);
17976 
17977     INDENT(-4);
17978     PRINT_SPACE
17979     if (commaNeeded)
17980         _OUT << "}," << std::endl;
17981     else
17982         _OUT << "}" << std::endl;
17983 }
print_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements * obj,const std::string & s,bool commaNeeded=true)17984 static void print_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements *obj, const std::string &s,
17985                                                 bool commaNeeded = true)
17986 {
17987     PRINT_SPACE
17988     _OUT << "{" << std::endl;
17989     INDENT(4);
17990 
17991     print_VkStructureType(obj->sType, "sType", 1);
17992 
17993     if (obj->pNext)
17994     {
17995         dumpPNextChain(obj->pNext);
17996     }
17997     else
17998     {
17999         PRINT_SPACE
18000         _OUT << "\"pNext\":"
18001              << "\"NULL\""
18002              << "," << std::endl;
18003     }
18004 
18005     print_VkBool32(obj->prefersDedicatedAllocation, "prefersDedicatedAllocation", 1);
18006 
18007     print_VkBool32(obj->requiresDedicatedAllocation, "requiresDedicatedAllocation", 0);
18008 
18009     INDENT(-4);
18010     PRINT_SPACE
18011     if (commaNeeded)
18012         _OUT << "}," << std::endl;
18013     else
18014         _OUT << "}" << std::endl;
18015 }
18016 
print_VkMemoryDedicatedAllocateInfo(VkMemoryDedicatedAllocateInfo obj,const std::string & s,bool commaNeeded=true)18017 static void print_VkMemoryDedicatedAllocateInfo(VkMemoryDedicatedAllocateInfo obj, const std::string &s,
18018                                                 bool commaNeeded = true)
18019 {
18020     PRINT_SPACE
18021     _OUT << "{" << std::endl;
18022     INDENT(4);
18023 
18024     print_VkStructureType(obj.sType, "sType", 1);
18025 
18026     if (obj.pNext)
18027     {
18028         dumpPNextChain(obj.pNext);
18029     }
18030     else
18031     {
18032         PRINT_SPACE
18033         _OUT << "\"pNext\":"
18034              << "\"NULL\""
18035              << "," << std::endl;
18036     }
18037 
18038     // CTS : required value
18039     PRINT_SPACE _OUT << "\""
18040                      << "image"
18041                      << "\""
18042                      << " : "
18043                      << "\""
18044                      << "\"," << std::endl;
18045 
18046     // CTS : required value
18047     PRINT_SPACE _OUT << "\""
18048                      << "buffer"
18049                      << "\""
18050                      << " : "
18051                      << "\""
18052                      << "\"" << std::endl;
18053 
18054     INDENT(-4);
18055     PRINT_SPACE
18056     if (commaNeeded)
18057         _OUT << "}," << std::endl;
18058     else
18059         _OUT << "}" << std::endl;
18060 }
print_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo * obj,const std::string & s,bool commaNeeded=true)18061 static void print_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo *obj, const std::string &s,
18062                                                 bool commaNeeded = true)
18063 {
18064     PRINT_SPACE
18065     _OUT << "{" << std::endl;
18066     INDENT(4);
18067 
18068     print_VkStructureType(obj->sType, "sType", 1);
18069 
18070     if (obj->pNext)
18071     {
18072         dumpPNextChain(obj->pNext);
18073     }
18074     else
18075     {
18076         PRINT_SPACE
18077         _OUT << "\"pNext\":"
18078              << "\"NULL\""
18079              << "," << std::endl;
18080     }
18081 
18082     // CTS : required value
18083     PRINT_SPACE _OUT << "\""
18084                      << "image"
18085                      << "\""
18086                      << " : "
18087                      << "\""
18088                      << "\"," << std::endl;
18089 
18090     // CTS : required value
18091     PRINT_SPACE _OUT << "\""
18092                      << "buffer"
18093                      << "\""
18094                      << " : "
18095                      << "\""
18096                      << "\"" << std::endl;
18097 
18098     INDENT(-4);
18099     PRINT_SPACE
18100     if (commaNeeded)
18101         _OUT << "}," << std::endl;
18102     else
18103         _OUT << "}" << std::endl;
18104 }
18105 
print_VkMemoryAllocateFlagsInfo(VkMemoryAllocateFlagsInfo obj,const std::string & s,bool commaNeeded=true)18106 static void print_VkMemoryAllocateFlagsInfo(VkMemoryAllocateFlagsInfo obj, const std::string &s,
18107                                             bool commaNeeded = true)
18108 {
18109     PRINT_SPACE
18110     _OUT << "{" << std::endl;
18111     INDENT(4);
18112 
18113     print_VkStructureType(obj.sType, "sType", 1);
18114 
18115     if (obj.pNext)
18116     {
18117         dumpPNextChain(obj.pNext);
18118     }
18119     else
18120     {
18121         PRINT_SPACE
18122         _OUT << "\"pNext\":"
18123              << "\"NULL\""
18124              << "," << std::endl;
18125     }
18126 
18127     print_VkMemoryAllocateFlags(obj.flags, "flags", 1);
18128 
18129     print_uint32_t(obj.deviceMask, "deviceMask", 0);
18130 
18131     INDENT(-4);
18132     PRINT_SPACE
18133     if (commaNeeded)
18134         _OUT << "}," << std::endl;
18135     else
18136         _OUT << "}" << std::endl;
18137 }
print_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo * obj,const std::string & s,bool commaNeeded=true)18138 static void print_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo *obj, const std::string &s,
18139                                             bool commaNeeded = true)
18140 {
18141     PRINT_SPACE
18142     _OUT << "{" << std::endl;
18143     INDENT(4);
18144 
18145     print_VkStructureType(obj->sType, "sType", 1);
18146 
18147     if (obj->pNext)
18148     {
18149         dumpPNextChain(obj->pNext);
18150     }
18151     else
18152     {
18153         PRINT_SPACE
18154         _OUT << "\"pNext\":"
18155              << "\"NULL\""
18156              << "," << std::endl;
18157     }
18158 
18159     print_VkMemoryAllocateFlags(obj->flags, "flags", 1);
18160 
18161     print_uint32_t(obj->deviceMask, "deviceMask", 0);
18162 
18163     INDENT(-4);
18164     PRINT_SPACE
18165     if (commaNeeded)
18166         _OUT << "}," << std::endl;
18167     else
18168         _OUT << "}" << std::endl;
18169 }
18170 
print_VkDeviceGroupRenderPassBeginInfo(VkDeviceGroupRenderPassBeginInfo obj,const std::string & s,bool commaNeeded=true)18171 static void print_VkDeviceGroupRenderPassBeginInfo(VkDeviceGroupRenderPassBeginInfo obj, const std::string &s,
18172                                                    bool commaNeeded = true)
18173 {
18174     PRINT_SPACE
18175     _OUT << "{" << std::endl;
18176     INDENT(4);
18177 
18178     print_VkStructureType(obj.sType, "sType", 1);
18179 
18180     if (obj.pNext)
18181     {
18182         dumpPNextChain(obj.pNext);
18183     }
18184     else
18185     {
18186         PRINT_SPACE
18187         _OUT << "\"pNext\":"
18188              << "\"NULL\""
18189              << "," << std::endl;
18190     }
18191 
18192     print_uint32_t(obj.deviceMask, "deviceMask", 1);
18193 
18194     print_uint32_t(obj.deviceRenderAreaCount, "deviceRenderAreaCount", 1);
18195 
18196     PRINT_SPACE
18197     _OUT << "\"pDeviceRenderAreas\": " << std::endl;
18198     if (obj.pDeviceRenderAreas)
18199     {
18200         PRINT_SPACE
18201         _OUT << "[" << std::endl;
18202         for (unsigned int i = 0; i < obj.deviceRenderAreaCount; i++)
18203         {
18204             if (i + 1 == obj.deviceRenderAreaCount)
18205                 print_VkRect2D(obj.pDeviceRenderAreas[i], "pDeviceRenderAreas", 0);
18206             else
18207                 print_VkRect2D(obj.pDeviceRenderAreas[i], "pDeviceRenderAreas", 1);
18208         }
18209         PRINT_SPACE
18210         _OUT << "]" << std::endl;
18211     }
18212     else
18213     {
18214         PRINT_SPACE _OUT << "\"NULL\""
18215                          << "" << std::endl;
18216     }
18217 
18218     INDENT(-4);
18219     PRINT_SPACE
18220     if (commaNeeded)
18221         _OUT << "}," << std::endl;
18222     else
18223         _OUT << "}" << std::endl;
18224 }
print_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo * obj,const std::string & s,bool commaNeeded=true)18225 static void print_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo *obj, const std::string &s,
18226                                                    bool commaNeeded = true)
18227 {
18228     PRINT_SPACE
18229     _OUT << "{" << std::endl;
18230     INDENT(4);
18231 
18232     print_VkStructureType(obj->sType, "sType", 1);
18233 
18234     if (obj->pNext)
18235     {
18236         dumpPNextChain(obj->pNext);
18237     }
18238     else
18239     {
18240         PRINT_SPACE
18241         _OUT << "\"pNext\":"
18242              << "\"NULL\""
18243              << "," << std::endl;
18244     }
18245 
18246     print_uint32_t(obj->deviceMask, "deviceMask", 1);
18247 
18248     print_uint32_t(obj->deviceRenderAreaCount, "deviceRenderAreaCount", 1);
18249 
18250     PRINT_SPACE
18251     _OUT << "\"pDeviceRenderAreas\": " << std::endl;
18252     if (obj->pDeviceRenderAreas)
18253     {
18254         PRINT_SPACE
18255         _OUT << "[" << std::endl;
18256         for (unsigned int i = 0; i < obj->deviceRenderAreaCount; i++)
18257         {
18258             if (i + 1 == obj->deviceRenderAreaCount)
18259                 print_VkRect2D(obj->pDeviceRenderAreas[i], "pDeviceRenderAreas", 0);
18260             else
18261                 print_VkRect2D(obj->pDeviceRenderAreas[i], "pDeviceRenderAreas", 1);
18262         }
18263         PRINT_SPACE
18264         _OUT << "]" << std::endl;
18265     }
18266     else
18267     {
18268         PRINT_SPACE _OUT << "\"NULL\""
18269                          << "" << std::endl;
18270     }
18271 
18272     INDENT(-4);
18273     PRINT_SPACE
18274     if (commaNeeded)
18275         _OUT << "}," << std::endl;
18276     else
18277         _OUT << "}" << std::endl;
18278 }
18279 
print_VkDeviceGroupCommandBufferBeginInfo(VkDeviceGroupCommandBufferBeginInfo obj,const std::string & s,bool commaNeeded=true)18280 static void print_VkDeviceGroupCommandBufferBeginInfo(VkDeviceGroupCommandBufferBeginInfo obj, const std::string &s,
18281                                                       bool commaNeeded = true)
18282 {
18283     PRINT_SPACE
18284     _OUT << "{" << std::endl;
18285     INDENT(4);
18286 
18287     print_VkStructureType(obj.sType, "sType", 1);
18288 
18289     if (obj.pNext)
18290     {
18291         dumpPNextChain(obj.pNext);
18292     }
18293     else
18294     {
18295         PRINT_SPACE
18296         _OUT << "\"pNext\":"
18297              << "\"NULL\""
18298              << "," << std::endl;
18299     }
18300 
18301     print_uint32_t(obj.deviceMask, "deviceMask", 0);
18302 
18303     INDENT(-4);
18304     PRINT_SPACE
18305     if (commaNeeded)
18306         _OUT << "}," << std::endl;
18307     else
18308         _OUT << "}" << std::endl;
18309 }
print_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo * obj,const std::string & s,bool commaNeeded=true)18310 static void print_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo *obj,
18311                                                       const std::string &s, bool commaNeeded = true)
18312 {
18313     PRINT_SPACE
18314     _OUT << "{" << std::endl;
18315     INDENT(4);
18316 
18317     print_VkStructureType(obj->sType, "sType", 1);
18318 
18319     if (obj->pNext)
18320     {
18321         dumpPNextChain(obj->pNext);
18322     }
18323     else
18324     {
18325         PRINT_SPACE
18326         _OUT << "\"pNext\":"
18327              << "\"NULL\""
18328              << "," << std::endl;
18329     }
18330 
18331     print_uint32_t(obj->deviceMask, "deviceMask", 0);
18332 
18333     INDENT(-4);
18334     PRINT_SPACE
18335     if (commaNeeded)
18336         _OUT << "}," << std::endl;
18337     else
18338         _OUT << "}" << std::endl;
18339 }
18340 
print_VkDeviceGroupSubmitInfo(VkDeviceGroupSubmitInfo obj,const std::string & s,bool commaNeeded=true)18341 static void print_VkDeviceGroupSubmitInfo(VkDeviceGroupSubmitInfo obj, const std::string &s, bool commaNeeded = true)
18342 {
18343     PRINT_SPACE
18344     _OUT << "{" << std::endl;
18345     INDENT(4);
18346 
18347     print_VkStructureType(obj.sType, "sType", 1);
18348 
18349     if (obj.pNext)
18350     {
18351         dumpPNextChain(obj.pNext);
18352     }
18353     else
18354     {
18355         PRINT_SPACE
18356         _OUT << "\"pNext\":"
18357              << "\"NULL\""
18358              << "," << std::endl;
18359     }
18360 
18361     print_uint32_t(obj.waitSemaphoreCount, "waitSemaphoreCount", 1);
18362 
18363     PRINT_SPACE
18364     _OUT << "\"pWaitSemaphoreDeviceIndices\":" << std::endl;
18365     PRINT_SPACE
18366     if (obj.pWaitSemaphoreDeviceIndices)
18367     {
18368         _OUT << "[" << std::endl;
18369         for (unsigned int i = 0; i < obj.waitSemaphoreCount; i++)
18370         {
18371             bool isCommaNeeded = (i + 1) != obj.waitSemaphoreCount;
18372             print_uint32_t(obj.pWaitSemaphoreDeviceIndices[i], "", isCommaNeeded);
18373         }
18374         PRINT_SPACE
18375         _OUT << "]"
18376              << "," << std::endl;
18377     }
18378     else
18379     {
18380         _OUT << "\"NULL\""
18381              << "," << std::endl;
18382     }
18383 
18384     print_uint32_t(obj.commandBufferCount, "commandBufferCount", 1);
18385 
18386     PRINT_SPACE
18387     _OUT << "\"pCommandBufferDeviceMasks\":" << std::endl;
18388     PRINT_SPACE
18389     if (obj.pCommandBufferDeviceMasks)
18390     {
18391         _OUT << "[" << std::endl;
18392         for (unsigned int i = 0; i < obj.commandBufferCount; i++)
18393         {
18394             bool isCommaNeeded = (i + 1) != obj.commandBufferCount;
18395             print_uint32_t(obj.pCommandBufferDeviceMasks[i], "", isCommaNeeded);
18396         }
18397         PRINT_SPACE
18398         _OUT << "]"
18399              << "," << std::endl;
18400     }
18401     else
18402     {
18403         _OUT << "\"NULL\""
18404              << "," << std::endl;
18405     }
18406 
18407     print_uint32_t(obj.signalSemaphoreCount, "signalSemaphoreCount", 1);
18408 
18409     PRINT_SPACE
18410     _OUT << "\"pSignalSemaphoreDeviceIndices\":" << std::endl;
18411     PRINT_SPACE
18412     if (obj.pSignalSemaphoreDeviceIndices)
18413     {
18414         _OUT << "[" << std::endl;
18415         for (unsigned int i = 0; i < obj.signalSemaphoreCount; i++)
18416         {
18417             bool isCommaNeeded = (i + 1) != obj.signalSemaphoreCount;
18418             print_uint32_t(obj.pSignalSemaphoreDeviceIndices[i], "", isCommaNeeded);
18419         }
18420         PRINT_SPACE
18421         _OUT << "]"
18422              << "" << std::endl;
18423     }
18424     else
18425     {
18426         _OUT << "\"NULL\""
18427              << "" << std::endl;
18428     }
18429 
18430     INDENT(-4);
18431     PRINT_SPACE
18432     if (commaNeeded)
18433         _OUT << "}," << std::endl;
18434     else
18435         _OUT << "}" << std::endl;
18436 }
print_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo * obj,const std::string & s,bool commaNeeded=true)18437 static void print_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo *obj, const std::string &s,
18438                                           bool commaNeeded = true)
18439 {
18440     PRINT_SPACE
18441     _OUT << "{" << std::endl;
18442     INDENT(4);
18443 
18444     print_VkStructureType(obj->sType, "sType", 1);
18445 
18446     if (obj->pNext)
18447     {
18448         dumpPNextChain(obj->pNext);
18449     }
18450     else
18451     {
18452         PRINT_SPACE
18453         _OUT << "\"pNext\":"
18454              << "\"NULL\""
18455              << "," << std::endl;
18456     }
18457 
18458     print_uint32_t(obj->waitSemaphoreCount, "waitSemaphoreCount", 1);
18459 
18460     PRINT_SPACE
18461     _OUT << "\"pWaitSemaphoreDeviceIndices\":" << std::endl;
18462     PRINT_SPACE
18463     if (obj->pWaitSemaphoreDeviceIndices)
18464     {
18465         _OUT << "[" << std::endl;
18466         for (unsigned int i = 0; i < obj->waitSemaphoreCount; i++)
18467         {
18468             bool isCommaNeeded = (i + 1) != obj->waitSemaphoreCount;
18469             print_uint32_t(obj->pWaitSemaphoreDeviceIndices[i], "", isCommaNeeded);
18470         }
18471         PRINT_SPACE
18472         _OUT << "]"
18473              << "," << std::endl;
18474     }
18475     else
18476     {
18477         _OUT << "\"NULL\""
18478              << "," << std::endl;
18479     }
18480 
18481     print_uint32_t(obj->commandBufferCount, "commandBufferCount", 1);
18482 
18483     PRINT_SPACE
18484     _OUT << "\"pCommandBufferDeviceMasks\":" << std::endl;
18485     PRINT_SPACE
18486     if (obj->pCommandBufferDeviceMasks)
18487     {
18488         _OUT << "[" << std::endl;
18489         for (unsigned int i = 0; i < obj->commandBufferCount; i++)
18490         {
18491             bool isCommaNeeded = (i + 1) != obj->commandBufferCount;
18492             print_uint32_t(obj->pCommandBufferDeviceMasks[i], "", isCommaNeeded);
18493         }
18494         PRINT_SPACE
18495         _OUT << "]"
18496              << "," << std::endl;
18497     }
18498     else
18499     {
18500         _OUT << "\"NULL\""
18501              << "," << std::endl;
18502     }
18503 
18504     print_uint32_t(obj->signalSemaphoreCount, "signalSemaphoreCount", 1);
18505 
18506     PRINT_SPACE
18507     _OUT << "\"pSignalSemaphoreDeviceIndices\":" << std::endl;
18508     PRINT_SPACE
18509     if (obj->pSignalSemaphoreDeviceIndices)
18510     {
18511         _OUT << "[" << std::endl;
18512         for (unsigned int i = 0; i < obj->signalSemaphoreCount; i++)
18513         {
18514             bool isCommaNeeded = (i + 1) != obj->signalSemaphoreCount;
18515             print_uint32_t(obj->pSignalSemaphoreDeviceIndices[i], "", isCommaNeeded);
18516         }
18517         PRINT_SPACE
18518         _OUT << "]"
18519              << "" << std::endl;
18520     }
18521     else
18522     {
18523         _OUT << "\"NULL\""
18524              << "" << std::endl;
18525     }
18526 
18527     INDENT(-4);
18528     PRINT_SPACE
18529     if (commaNeeded)
18530         _OUT << "}," << std::endl;
18531     else
18532         _OUT << "}" << std::endl;
18533 }
18534 
print_VkBindBufferMemoryDeviceGroupInfo(VkBindBufferMemoryDeviceGroupInfo obj,const std::string & s,bool commaNeeded=true)18535 static void print_VkBindBufferMemoryDeviceGroupInfo(VkBindBufferMemoryDeviceGroupInfo obj, const std::string &s,
18536                                                     bool commaNeeded = true)
18537 {
18538     PRINT_SPACE
18539     _OUT << "{" << std::endl;
18540     INDENT(4);
18541 
18542     print_VkStructureType(obj.sType, "sType", 1);
18543 
18544     if (obj.pNext)
18545     {
18546         dumpPNextChain(obj.pNext);
18547     }
18548     else
18549     {
18550         PRINT_SPACE
18551         _OUT << "\"pNext\":"
18552              << "\"NULL\""
18553              << "," << std::endl;
18554     }
18555 
18556     print_uint32_t(obj.deviceIndexCount, "deviceIndexCount", 1);
18557 
18558     PRINT_SPACE
18559     _OUT << "\"pDeviceIndices\":" << std::endl;
18560     PRINT_SPACE
18561     if (obj.pDeviceIndices)
18562     {
18563         _OUT << "[" << std::endl;
18564         for (unsigned int i = 0; i < obj.deviceIndexCount; i++)
18565         {
18566             bool isCommaNeeded = (i + 1) != obj.deviceIndexCount;
18567             print_uint32_t(obj.pDeviceIndices[i], "", isCommaNeeded);
18568         }
18569         PRINT_SPACE
18570         _OUT << "]"
18571              << "" << std::endl;
18572     }
18573     else
18574     {
18575         _OUT << "\"NULL\""
18576              << "" << std::endl;
18577     }
18578 
18579     INDENT(-4);
18580     PRINT_SPACE
18581     if (commaNeeded)
18582         _OUT << "}," << std::endl;
18583     else
18584         _OUT << "}" << std::endl;
18585 }
print_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo * obj,const std::string & s,bool commaNeeded=true)18586 static void print_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo *obj, const std::string &s,
18587                                                     bool commaNeeded = true)
18588 {
18589     PRINT_SPACE
18590     _OUT << "{" << std::endl;
18591     INDENT(4);
18592 
18593     print_VkStructureType(obj->sType, "sType", 1);
18594 
18595     if (obj->pNext)
18596     {
18597         dumpPNextChain(obj->pNext);
18598     }
18599     else
18600     {
18601         PRINT_SPACE
18602         _OUT << "\"pNext\":"
18603              << "\"NULL\""
18604              << "," << std::endl;
18605     }
18606 
18607     print_uint32_t(obj->deviceIndexCount, "deviceIndexCount", 1);
18608 
18609     PRINT_SPACE
18610     _OUT << "\"pDeviceIndices\":" << std::endl;
18611     PRINT_SPACE
18612     if (obj->pDeviceIndices)
18613     {
18614         _OUT << "[" << std::endl;
18615         for (unsigned int i = 0; i < obj->deviceIndexCount; i++)
18616         {
18617             bool isCommaNeeded = (i + 1) != obj->deviceIndexCount;
18618             print_uint32_t(obj->pDeviceIndices[i], "", isCommaNeeded);
18619         }
18620         PRINT_SPACE
18621         _OUT << "]"
18622              << "" << std::endl;
18623     }
18624     else
18625     {
18626         _OUT << "\"NULL\""
18627              << "" << std::endl;
18628     }
18629 
18630     INDENT(-4);
18631     PRINT_SPACE
18632     if (commaNeeded)
18633         _OUT << "}," << std::endl;
18634     else
18635         _OUT << "}" << std::endl;
18636 }
18637 
print_VkBindImageMemoryDeviceGroupInfo(VkBindImageMemoryDeviceGroupInfo obj,const std::string & s,bool commaNeeded=true)18638 static void print_VkBindImageMemoryDeviceGroupInfo(VkBindImageMemoryDeviceGroupInfo obj, const std::string &s,
18639                                                    bool commaNeeded = true)
18640 {
18641     PRINT_SPACE
18642     _OUT << "{" << std::endl;
18643     INDENT(4);
18644 
18645     print_VkStructureType(obj.sType, "sType", 1);
18646 
18647     if (obj.pNext)
18648     {
18649         dumpPNextChain(obj.pNext);
18650     }
18651     else
18652     {
18653         PRINT_SPACE
18654         _OUT << "\"pNext\":"
18655              << "\"NULL\""
18656              << "," << std::endl;
18657     }
18658 
18659     print_uint32_t(obj.deviceIndexCount, "deviceIndexCount", 1);
18660 
18661     PRINT_SPACE
18662     _OUT << "\"pDeviceIndices\":" << std::endl;
18663     PRINT_SPACE
18664     if (obj.pDeviceIndices)
18665     {
18666         _OUT << "[" << std::endl;
18667         for (unsigned int i = 0; i < obj.deviceIndexCount; i++)
18668         {
18669             bool isCommaNeeded = (i + 1) != obj.deviceIndexCount;
18670             print_uint32_t(obj.pDeviceIndices[i], "", isCommaNeeded);
18671         }
18672         PRINT_SPACE
18673         _OUT << "]"
18674              << "," << std::endl;
18675     }
18676     else
18677     {
18678         _OUT << "\"NULL\""
18679              << "," << std::endl;
18680     }
18681 
18682     print_uint32_t(obj.splitInstanceBindRegionCount, "splitInstanceBindRegionCount", 1);
18683 
18684     PRINT_SPACE
18685     _OUT << "\"pSplitInstanceBindRegions\": " << std::endl;
18686     if (obj.pSplitInstanceBindRegions)
18687     {
18688         PRINT_SPACE
18689         _OUT << "[" << std::endl;
18690         for (unsigned int i = 0; i < obj.splitInstanceBindRegionCount; i++)
18691         {
18692             if (i + 1 == obj.splitInstanceBindRegionCount)
18693                 print_VkRect2D(obj.pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 0);
18694             else
18695                 print_VkRect2D(obj.pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 1);
18696         }
18697         PRINT_SPACE
18698         _OUT << "]" << std::endl;
18699     }
18700     else
18701     {
18702         PRINT_SPACE _OUT << "\"NULL\""
18703                          << "" << std::endl;
18704     }
18705 
18706     INDENT(-4);
18707     PRINT_SPACE
18708     if (commaNeeded)
18709         _OUT << "}," << std::endl;
18710     else
18711         _OUT << "}" << std::endl;
18712 }
print_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo * obj,const std::string & s,bool commaNeeded=true)18713 static void print_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo *obj, const std::string &s,
18714                                                    bool commaNeeded = true)
18715 {
18716     PRINT_SPACE
18717     _OUT << "{" << std::endl;
18718     INDENT(4);
18719 
18720     print_VkStructureType(obj->sType, "sType", 1);
18721 
18722     if (obj->pNext)
18723     {
18724         dumpPNextChain(obj->pNext);
18725     }
18726     else
18727     {
18728         PRINT_SPACE
18729         _OUT << "\"pNext\":"
18730              << "\"NULL\""
18731              << "," << std::endl;
18732     }
18733 
18734     print_uint32_t(obj->deviceIndexCount, "deviceIndexCount", 1);
18735 
18736     PRINT_SPACE
18737     _OUT << "\"pDeviceIndices\":" << std::endl;
18738     PRINT_SPACE
18739     if (obj->pDeviceIndices)
18740     {
18741         _OUT << "[" << std::endl;
18742         for (unsigned int i = 0; i < obj->deviceIndexCount; i++)
18743         {
18744             bool isCommaNeeded = (i + 1) != obj->deviceIndexCount;
18745             print_uint32_t(obj->pDeviceIndices[i], "", isCommaNeeded);
18746         }
18747         PRINT_SPACE
18748         _OUT << "]"
18749              << "," << std::endl;
18750     }
18751     else
18752     {
18753         _OUT << "\"NULL\""
18754              << "," << std::endl;
18755     }
18756 
18757     print_uint32_t(obj->splitInstanceBindRegionCount, "splitInstanceBindRegionCount", 1);
18758 
18759     PRINT_SPACE
18760     _OUT << "\"pSplitInstanceBindRegions\": " << std::endl;
18761     if (obj->pSplitInstanceBindRegions)
18762     {
18763         PRINT_SPACE
18764         _OUT << "[" << std::endl;
18765         for (unsigned int i = 0; i < obj->splitInstanceBindRegionCount; i++)
18766         {
18767             if (i + 1 == obj->splitInstanceBindRegionCount)
18768                 print_VkRect2D(obj->pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 0);
18769             else
18770                 print_VkRect2D(obj->pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 1);
18771         }
18772         PRINT_SPACE
18773         _OUT << "]" << std::endl;
18774     }
18775     else
18776     {
18777         PRINT_SPACE _OUT << "\"NULL\""
18778                          << "" << std::endl;
18779     }
18780 
18781     INDENT(-4);
18782     PRINT_SPACE
18783     if (commaNeeded)
18784         _OUT << "}," << std::endl;
18785     else
18786         _OUT << "}" << std::endl;
18787 }
18788 
print_VkPhysicalDeviceGroupProperties(VkPhysicalDeviceGroupProperties obj,const std::string & s,bool commaNeeded=true)18789 static void print_VkPhysicalDeviceGroupProperties(VkPhysicalDeviceGroupProperties obj, const std::string &s,
18790                                                   bool commaNeeded = true)
18791 {
18792     PRINT_SPACE
18793     _OUT << "{" << std::endl;
18794     INDENT(4);
18795 
18796     print_VkStructureType(obj.sType, "sType", 1);
18797 
18798     if (obj.pNext)
18799     {
18800         dumpPNextChain(obj.pNext);
18801     }
18802     else
18803     {
18804         PRINT_SPACE
18805         _OUT << "\"pNext\":"
18806              << "\"NULL\""
18807              << "," << std::endl;
18808     }
18809 
18810     print_uint32_t(obj.physicalDeviceCount, "physicalDeviceCount", 1);
18811 
18812     PRINT_SPACE
18813     _OUT << "\"physicalDevices\":" << std::endl;
18814     PRINT_SPACE
18815     _OUT << "[" << std::endl;
18816     for (unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
18817     {
18818         std::stringstream tmp;
18819         tmp << "physicalDevices"
18820             << "_" << i;
18821         bool isCommaNeeded = (i + 1) != VK_MAX_DEVICE_GROUP_SIZE;
18822         print_VkPhysicalDevice(obj.physicalDevices[i], tmp.str(), isCommaNeeded);
18823     }
18824     PRINT_SPACE
18825     _OUT << "]"
18826          << "," << std::endl;
18827 
18828     print_VkBool32(obj.subsetAllocation, "subsetAllocation", 0);
18829 
18830     INDENT(-4);
18831     PRINT_SPACE
18832     if (commaNeeded)
18833         _OUT << "}," << std::endl;
18834     else
18835         _OUT << "}" << std::endl;
18836 }
print_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties * obj,const std::string & s,bool commaNeeded=true)18837 static void print_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties *obj, const std::string &s,
18838                                                   bool commaNeeded = true)
18839 {
18840     PRINT_SPACE
18841     _OUT << "{" << std::endl;
18842     INDENT(4);
18843 
18844     print_VkStructureType(obj->sType, "sType", 1);
18845 
18846     if (obj->pNext)
18847     {
18848         dumpPNextChain(obj->pNext);
18849     }
18850     else
18851     {
18852         PRINT_SPACE
18853         _OUT << "\"pNext\":"
18854              << "\"NULL\""
18855              << "," << std::endl;
18856     }
18857 
18858     print_uint32_t(obj->physicalDeviceCount, "physicalDeviceCount", 1);
18859 
18860     PRINT_SPACE
18861     _OUT << "\"physicalDevices\":" << std::endl;
18862     PRINT_SPACE
18863     _OUT << "[" << std::endl;
18864     for (unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
18865     {
18866         std::stringstream tmp;
18867         tmp << "physicalDevices"
18868             << "_" << i;
18869         bool isCommaNeeded = (i + 1) != VK_MAX_DEVICE_GROUP_SIZE;
18870         print_VkPhysicalDevice(obj->physicalDevices[i], tmp.str(), isCommaNeeded);
18871     }
18872     PRINT_SPACE
18873     _OUT << "]"
18874          << "," << std::endl;
18875 
18876     print_VkBool32(obj->subsetAllocation, "subsetAllocation", 0);
18877 
18878     INDENT(-4);
18879     PRINT_SPACE
18880     if (commaNeeded)
18881         _OUT << "}," << std::endl;
18882     else
18883         _OUT << "}" << std::endl;
18884 }
18885 
print_VkDeviceGroupDeviceCreateInfo(VkDeviceGroupDeviceCreateInfo obj,const std::string & s,bool commaNeeded=true)18886 static void print_VkDeviceGroupDeviceCreateInfo(VkDeviceGroupDeviceCreateInfo obj, const std::string &s,
18887                                                 bool commaNeeded = true)
18888 {
18889     PRINT_SPACE
18890     _OUT << "{" << std::endl;
18891     INDENT(4);
18892 
18893     print_VkStructureType(obj.sType, "sType", 1);
18894 
18895     if (obj.pNext)
18896     {
18897         dumpPNextChain(obj.pNext);
18898     }
18899     else
18900     {
18901         PRINT_SPACE
18902         _OUT << "\"pNext\":"
18903              << "\"NULL\""
18904              << "," << std::endl;
18905     }
18906 
18907     print_uint32_t(obj.physicalDeviceCount, "physicalDeviceCount", 1);
18908 
18909     PRINT_SPACE
18910     _OUT << "\"pPhysicalDevices\":" << std::endl;
18911     PRINT_SPACE
18912     if (obj.pPhysicalDevices)
18913     {
18914         _OUT << "[" << std::endl;
18915         for (unsigned int i = 0; i < obj.physicalDeviceCount; i++)
18916         {
18917             std::stringstream tmp;
18918             tmp << "pPhysicalDevices"
18919                 << "_" << i;
18920             bool isCommaNeeded = (i + 1) != obj.physicalDeviceCount;
18921             print_VkPhysicalDevice(obj.pPhysicalDevices[i], tmp.str(), isCommaNeeded);
18922         }
18923         PRINT_SPACE
18924         _OUT << "]"
18925              << "" << std::endl;
18926     }
18927     else
18928     {
18929         _OUT << "\"NULL\""
18930              << "" << std::endl;
18931     }
18932 
18933     INDENT(-4);
18934     PRINT_SPACE
18935     if (commaNeeded)
18936         _OUT << "}," << std::endl;
18937     else
18938         _OUT << "}" << std::endl;
18939 }
print_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo * obj,const std::string & s,bool commaNeeded=true)18940 static void print_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo *obj, const std::string &s,
18941                                                 bool commaNeeded = true)
18942 {
18943     PRINT_SPACE
18944     _OUT << "{" << std::endl;
18945     INDENT(4);
18946 
18947     print_VkStructureType(obj->sType, "sType", 1);
18948 
18949     if (obj->pNext)
18950     {
18951         dumpPNextChain(obj->pNext);
18952     }
18953     else
18954     {
18955         PRINT_SPACE
18956         _OUT << "\"pNext\":"
18957              << "\"NULL\""
18958              << "," << std::endl;
18959     }
18960 
18961     print_uint32_t(obj->physicalDeviceCount, "physicalDeviceCount", 1);
18962 
18963     PRINT_SPACE
18964     _OUT << "\"pPhysicalDevices\":" << std::endl;
18965     PRINT_SPACE
18966     if (obj->pPhysicalDevices)
18967     {
18968         _OUT << "[" << std::endl;
18969         for (unsigned int i = 0; i < obj->physicalDeviceCount; i++)
18970         {
18971             std::stringstream tmp;
18972             tmp << "pPhysicalDevices"
18973                 << "_" << i;
18974             bool isCommaNeeded = (i + 1) != obj->physicalDeviceCount;
18975             print_VkPhysicalDevice(obj->pPhysicalDevices[i], tmp.str(), isCommaNeeded);
18976         }
18977         PRINT_SPACE
18978         _OUT << "]"
18979              << "" << std::endl;
18980     }
18981     else
18982     {
18983         _OUT << "\"NULL\""
18984              << "" << std::endl;
18985     }
18986 
18987     INDENT(-4);
18988     PRINT_SPACE
18989     if (commaNeeded)
18990         _OUT << "}," << std::endl;
18991     else
18992         _OUT << "}" << std::endl;
18993 }
18994 
print_VkBufferMemoryRequirementsInfo2(VkBufferMemoryRequirementsInfo2 obj,const std::string & s,bool commaNeeded=true)18995 static void print_VkBufferMemoryRequirementsInfo2(VkBufferMemoryRequirementsInfo2 obj, const std::string &s,
18996                                                   bool commaNeeded = true)
18997 {
18998     PRINT_SPACE
18999     _OUT << "{" << std::endl;
19000     INDENT(4);
19001 
19002     print_VkStructureType(obj.sType, "sType", 1);
19003 
19004     if (obj.pNext)
19005     {
19006         dumpPNextChain(obj.pNext);
19007     }
19008     else
19009     {
19010         PRINT_SPACE
19011         _OUT << "\"pNext\":"
19012              << "\"NULL\""
19013              << "," << std::endl;
19014     }
19015 
19016     // CTS : required value
19017     PRINT_SPACE _OUT << "\""
19018                      << "buffer"
19019                      << "\""
19020                      << " : "
19021                      << "\""
19022                      << "\"" << std::endl;
19023 
19024     INDENT(-4);
19025     PRINT_SPACE
19026     if (commaNeeded)
19027         _OUT << "}," << std::endl;
19028     else
19029         _OUT << "}" << std::endl;
19030 }
print_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2 * obj,const std::string & s,bool commaNeeded=true)19031 static void print_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2 *obj, const std::string &s,
19032                                                   bool commaNeeded = true)
19033 {
19034     PRINT_SPACE
19035     _OUT << "{" << std::endl;
19036     INDENT(4);
19037 
19038     print_VkStructureType(obj->sType, "sType", 1);
19039 
19040     if (obj->pNext)
19041     {
19042         dumpPNextChain(obj->pNext);
19043     }
19044     else
19045     {
19046         PRINT_SPACE
19047         _OUT << "\"pNext\":"
19048              << "\"NULL\""
19049              << "," << std::endl;
19050     }
19051 
19052     // CTS : required value
19053     PRINT_SPACE _OUT << "\""
19054                      << "buffer"
19055                      << "\""
19056                      << " : "
19057                      << "\""
19058                      << "\"" << std::endl;
19059 
19060     INDENT(-4);
19061     PRINT_SPACE
19062     if (commaNeeded)
19063         _OUT << "}," << std::endl;
19064     else
19065         _OUT << "}" << std::endl;
19066 }
19067 
print_VkImageMemoryRequirementsInfo2(VkImageMemoryRequirementsInfo2 obj,const std::string & s,bool commaNeeded=true)19068 static void print_VkImageMemoryRequirementsInfo2(VkImageMemoryRequirementsInfo2 obj, const std::string &s,
19069                                                  bool commaNeeded = true)
19070 {
19071     PRINT_SPACE
19072     _OUT << "{" << std::endl;
19073     INDENT(4);
19074 
19075     print_VkStructureType(obj.sType, "sType", 1);
19076 
19077     if (obj.pNext)
19078     {
19079         dumpPNextChain(obj.pNext);
19080     }
19081     else
19082     {
19083         PRINT_SPACE
19084         _OUT << "\"pNext\":"
19085              << "\"NULL\""
19086              << "," << std::endl;
19087     }
19088 
19089     // CTS : required value
19090     PRINT_SPACE _OUT << "\""
19091                      << "image"
19092                      << "\""
19093                      << " : "
19094                      << "\""
19095                      << "\"" << std::endl;
19096 
19097     INDENT(-4);
19098     PRINT_SPACE
19099     if (commaNeeded)
19100         _OUT << "}," << std::endl;
19101     else
19102         _OUT << "}" << std::endl;
19103 }
print_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2 * obj,const std::string & s,bool commaNeeded=true)19104 static void print_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2 *obj, const std::string &s,
19105                                                  bool commaNeeded = true)
19106 {
19107     PRINT_SPACE
19108     _OUT << "{" << std::endl;
19109     INDENT(4);
19110 
19111     print_VkStructureType(obj->sType, "sType", 1);
19112 
19113     if (obj->pNext)
19114     {
19115         dumpPNextChain(obj->pNext);
19116     }
19117     else
19118     {
19119         PRINT_SPACE
19120         _OUT << "\"pNext\":"
19121              << "\"NULL\""
19122              << "," << std::endl;
19123     }
19124 
19125     // CTS : required value
19126     PRINT_SPACE _OUT << "\""
19127                      << "image"
19128                      << "\""
19129                      << " : "
19130                      << "\""
19131                      << "\"" << std::endl;
19132 
19133     INDENT(-4);
19134     PRINT_SPACE
19135     if (commaNeeded)
19136         _OUT << "}," << std::endl;
19137     else
19138         _OUT << "}" << std::endl;
19139 }
19140 
print_VkMemoryRequirements2(VkMemoryRequirements2 obj,const std::string & s,bool commaNeeded=true)19141 static void print_VkMemoryRequirements2(VkMemoryRequirements2 obj, const std::string &s, bool commaNeeded = true)
19142 {
19143     PRINT_SPACE
19144     _OUT << "{" << std::endl;
19145     INDENT(4);
19146 
19147     print_VkStructureType(obj.sType, "sType", 1);
19148 
19149     if (obj.pNext)
19150     {
19151         dumpPNextChain(obj.pNext);
19152     }
19153     else
19154     {
19155         PRINT_SPACE
19156         _OUT << "\"pNext\":"
19157              << "\"NULL\""
19158              << "," << std::endl;
19159     }
19160 
19161     PRINT_SPACE
19162     _OUT << "\"memoryRequirements\": " << std::endl;
19163     {
19164         print_VkMemoryRequirements(obj.memoryRequirements, "memoryRequirements", 0);
19165     }
19166 
19167     INDENT(-4);
19168     PRINT_SPACE
19169     if (commaNeeded)
19170         _OUT << "}," << std::endl;
19171     else
19172         _OUT << "}" << std::endl;
19173 }
print_VkMemoryRequirements2(const VkMemoryRequirements2 * obj,const std::string & s,bool commaNeeded=true)19174 static void print_VkMemoryRequirements2(const VkMemoryRequirements2 *obj, const std::string &s, bool commaNeeded = true)
19175 {
19176     PRINT_SPACE
19177     _OUT << "{" << std::endl;
19178     INDENT(4);
19179 
19180     print_VkStructureType(obj->sType, "sType", 1);
19181 
19182     if (obj->pNext)
19183     {
19184         dumpPNextChain(obj->pNext);
19185     }
19186     else
19187     {
19188         PRINT_SPACE
19189         _OUT << "\"pNext\":"
19190              << "\"NULL\""
19191              << "," << std::endl;
19192     }
19193 
19194     PRINT_SPACE
19195     _OUT << "\"memoryRequirements\": " << std::endl;
19196     {
19197         print_VkMemoryRequirements(obj->memoryRequirements, "memoryRequirements", 0);
19198     }
19199 
19200     INDENT(-4);
19201     PRINT_SPACE
19202     if (commaNeeded)
19203         _OUT << "}," << std::endl;
19204     else
19205         _OUT << "}" << std::endl;
19206 }
19207 
print_VkPhysicalDeviceFeatures2(VkPhysicalDeviceFeatures2 obj,const std::string & s,bool commaNeeded=true)19208 static void print_VkPhysicalDeviceFeatures2(VkPhysicalDeviceFeatures2 obj, const std::string &s,
19209                                             bool commaNeeded = true)
19210 {
19211     PRINT_SPACE
19212     _OUT << "{" << std::endl;
19213     INDENT(4);
19214 
19215     print_VkStructureType(obj.sType, "sType", 1);
19216 
19217     if (obj.pNext)
19218     {
19219         dumpPNextChain(obj.pNext);
19220     }
19221     else
19222     {
19223         PRINT_SPACE
19224         _OUT << "\"pNext\":"
19225              << "\"NULL\""
19226              << "," << std::endl;
19227     }
19228 
19229     PRINT_SPACE
19230     _OUT << "\"features\": " << std::endl;
19231     {
19232         print_VkPhysicalDeviceFeatures(obj.features, "features", 0);
19233     }
19234 
19235     INDENT(-4);
19236     PRINT_SPACE
19237     if (commaNeeded)
19238         _OUT << "}," << std::endl;
19239     else
19240         _OUT << "}" << std::endl;
19241 }
print_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 * obj,const std::string & s,bool commaNeeded=true)19242 static void print_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 *obj, const std::string &s,
19243                                             bool commaNeeded = true)
19244 {
19245     PRINT_SPACE
19246     _OUT << "{" << std::endl;
19247     INDENT(4);
19248 
19249     print_VkStructureType(obj->sType, "sType", 1);
19250 
19251     if (obj->pNext)
19252     {
19253         dumpPNextChain(obj->pNext);
19254     }
19255     else
19256     {
19257         PRINT_SPACE
19258         _OUT << "\"pNext\":"
19259              << "\"NULL\""
19260              << "," << std::endl;
19261     }
19262 
19263     PRINT_SPACE
19264     _OUT << "\"features\": " << std::endl;
19265     {
19266         print_VkPhysicalDeviceFeatures(obj->features, "features", 0);
19267     }
19268 
19269     INDENT(-4);
19270     PRINT_SPACE
19271     if (commaNeeded)
19272         _OUT << "}," << std::endl;
19273     else
19274         _OUT << "}" << std::endl;
19275 }
19276 
print_VkPhysicalDeviceProperties2(VkPhysicalDeviceProperties2 obj,const std::string & s,bool commaNeeded=true)19277 static void print_VkPhysicalDeviceProperties2(VkPhysicalDeviceProperties2 obj, const std::string &s,
19278                                               bool commaNeeded = true)
19279 {
19280     PRINT_SPACE
19281     _OUT << "{" << std::endl;
19282     INDENT(4);
19283 
19284     print_VkStructureType(obj.sType, "sType", 1);
19285 
19286     if (obj.pNext)
19287     {
19288         dumpPNextChain(obj.pNext);
19289     }
19290     else
19291     {
19292         PRINT_SPACE
19293         _OUT << "\"pNext\":"
19294              << "\"NULL\""
19295              << "," << std::endl;
19296     }
19297 
19298     PRINT_SPACE
19299     _OUT << "\"properties\": " << std::endl;
19300     {
19301         print_VkPhysicalDeviceProperties(obj.properties, "properties", 0);
19302     }
19303 
19304     INDENT(-4);
19305     PRINT_SPACE
19306     if (commaNeeded)
19307         _OUT << "}," << std::endl;
19308     else
19309         _OUT << "}" << std::endl;
19310 }
print_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 * obj,const std::string & s,bool commaNeeded=true)19311 static void print_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 *obj, const std::string &s,
19312                                               bool commaNeeded = true)
19313 {
19314     PRINT_SPACE
19315     _OUT << "{" << std::endl;
19316     INDENT(4);
19317 
19318     print_VkStructureType(obj->sType, "sType", 1);
19319 
19320     if (obj->pNext)
19321     {
19322         dumpPNextChain(obj->pNext);
19323     }
19324     else
19325     {
19326         PRINT_SPACE
19327         _OUT << "\"pNext\":"
19328              << "\"NULL\""
19329              << "," << std::endl;
19330     }
19331 
19332     PRINT_SPACE
19333     _OUT << "\"properties\": " << std::endl;
19334     {
19335         print_VkPhysicalDeviceProperties(obj->properties, "properties", 0);
19336     }
19337 
19338     INDENT(-4);
19339     PRINT_SPACE
19340     if (commaNeeded)
19341         _OUT << "}," << std::endl;
19342     else
19343         _OUT << "}" << std::endl;
19344 }
19345 
print_VkFormatProperties2(VkFormatProperties2 obj,const std::string & s,bool commaNeeded=true)19346 static void print_VkFormatProperties2(VkFormatProperties2 obj, const std::string &s, bool commaNeeded = true)
19347 {
19348     PRINT_SPACE
19349     _OUT << "{" << std::endl;
19350     INDENT(4);
19351 
19352     print_VkStructureType(obj.sType, "sType", 1);
19353 
19354     if (obj.pNext)
19355     {
19356         dumpPNextChain(obj.pNext);
19357     }
19358     else
19359     {
19360         PRINT_SPACE
19361         _OUT << "\"pNext\":"
19362              << "\"NULL\""
19363              << "," << std::endl;
19364     }
19365 
19366     PRINT_SPACE
19367     _OUT << "\"formatProperties\": " << std::endl;
19368     {
19369         print_VkFormatProperties(obj.formatProperties, "formatProperties", 0);
19370     }
19371 
19372     INDENT(-4);
19373     PRINT_SPACE
19374     if (commaNeeded)
19375         _OUT << "}," << std::endl;
19376     else
19377         _OUT << "}" << std::endl;
19378 }
print_VkFormatProperties2(const VkFormatProperties2 * obj,const std::string & s,bool commaNeeded=true)19379 static void print_VkFormatProperties2(const VkFormatProperties2 *obj, const std::string &s, bool commaNeeded = true)
19380 {
19381     PRINT_SPACE
19382     _OUT << "{" << std::endl;
19383     INDENT(4);
19384 
19385     print_VkStructureType(obj->sType, "sType", 1);
19386 
19387     if (obj->pNext)
19388     {
19389         dumpPNextChain(obj->pNext);
19390     }
19391     else
19392     {
19393         PRINT_SPACE
19394         _OUT << "\"pNext\":"
19395              << "\"NULL\""
19396              << "," << std::endl;
19397     }
19398 
19399     PRINT_SPACE
19400     _OUT << "\"formatProperties\": " << std::endl;
19401     {
19402         print_VkFormatProperties(obj->formatProperties, "formatProperties", 0);
19403     }
19404 
19405     INDENT(-4);
19406     PRINT_SPACE
19407     if (commaNeeded)
19408         _OUT << "}," << std::endl;
19409     else
19410         _OUT << "}" << std::endl;
19411 }
19412 
print_VkImageFormatProperties2(VkImageFormatProperties2 obj,const std::string & s,bool commaNeeded=true)19413 static void print_VkImageFormatProperties2(VkImageFormatProperties2 obj, const std::string &s, bool commaNeeded = true)
19414 {
19415     PRINT_SPACE
19416     _OUT << "{" << std::endl;
19417     INDENT(4);
19418 
19419     print_VkStructureType(obj.sType, "sType", 1);
19420 
19421     if (obj.pNext)
19422     {
19423         dumpPNextChain(obj.pNext);
19424     }
19425     else
19426     {
19427         PRINT_SPACE
19428         _OUT << "\"pNext\":"
19429              << "\"NULL\""
19430              << "," << std::endl;
19431     }
19432 
19433     PRINT_SPACE
19434     _OUT << "\"imageFormatProperties\": " << std::endl;
19435     {
19436         print_VkImageFormatProperties(obj.imageFormatProperties, "imageFormatProperties", 0);
19437     }
19438 
19439     INDENT(-4);
19440     PRINT_SPACE
19441     if (commaNeeded)
19442         _OUT << "}," << std::endl;
19443     else
19444         _OUT << "}" << std::endl;
19445 }
print_VkImageFormatProperties2(const VkImageFormatProperties2 * obj,const std::string & s,bool commaNeeded=true)19446 static void print_VkImageFormatProperties2(const VkImageFormatProperties2 *obj, const std::string &s,
19447                                            bool commaNeeded = true)
19448 {
19449     PRINT_SPACE
19450     _OUT << "{" << std::endl;
19451     INDENT(4);
19452 
19453     print_VkStructureType(obj->sType, "sType", 1);
19454 
19455     if (obj->pNext)
19456     {
19457         dumpPNextChain(obj->pNext);
19458     }
19459     else
19460     {
19461         PRINT_SPACE
19462         _OUT << "\"pNext\":"
19463              << "\"NULL\""
19464              << "," << std::endl;
19465     }
19466 
19467     PRINT_SPACE
19468     _OUT << "\"imageFormatProperties\": " << std::endl;
19469     {
19470         print_VkImageFormatProperties(obj->imageFormatProperties, "imageFormatProperties", 0);
19471     }
19472 
19473     INDENT(-4);
19474     PRINT_SPACE
19475     if (commaNeeded)
19476         _OUT << "}," << std::endl;
19477     else
19478         _OUT << "}" << std::endl;
19479 }
19480 
print_VkPhysicalDeviceImageFormatInfo2(VkPhysicalDeviceImageFormatInfo2 obj,const std::string & s,bool commaNeeded=true)19481 static void print_VkPhysicalDeviceImageFormatInfo2(VkPhysicalDeviceImageFormatInfo2 obj, const std::string &s,
19482                                                    bool commaNeeded = true)
19483 {
19484     PRINT_SPACE
19485     _OUT << "{" << std::endl;
19486     INDENT(4);
19487 
19488     print_VkStructureType(obj.sType, "sType", 1);
19489 
19490     if (obj.pNext)
19491     {
19492         dumpPNextChain(obj.pNext);
19493     }
19494     else
19495     {
19496         PRINT_SPACE
19497         _OUT << "\"pNext\":"
19498              << "\"NULL\""
19499              << "," << std::endl;
19500     }
19501 
19502     print_VkFormat(obj.format, "format", 1);
19503 
19504     print_VkImageType(obj.type, "type", 1);
19505 
19506     print_VkImageTiling(obj.tiling, "tiling", 1);
19507 
19508     print_VkImageUsageFlags(obj.usage, "usage", 1);
19509 
19510     print_VkImageCreateFlags(obj.flags, "flags", 0);
19511 
19512     INDENT(-4);
19513     PRINT_SPACE
19514     if (commaNeeded)
19515         _OUT << "}," << std::endl;
19516     else
19517         _OUT << "}" << std::endl;
19518 }
print_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 * obj,const std::string & s,bool commaNeeded=true)19519 static void print_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 *obj, const std::string &s,
19520                                                    bool commaNeeded = true)
19521 {
19522     PRINT_SPACE
19523     _OUT << "{" << std::endl;
19524     INDENT(4);
19525 
19526     print_VkStructureType(obj->sType, "sType", 1);
19527 
19528     if (obj->pNext)
19529     {
19530         dumpPNextChain(obj->pNext);
19531     }
19532     else
19533     {
19534         PRINT_SPACE
19535         _OUT << "\"pNext\":"
19536              << "\"NULL\""
19537              << "," << std::endl;
19538     }
19539 
19540     print_VkFormat(obj->format, "format", 1);
19541 
19542     print_VkImageType(obj->type, "type", 1);
19543 
19544     print_VkImageTiling(obj->tiling, "tiling", 1);
19545 
19546     print_VkImageUsageFlags(obj->usage, "usage", 1);
19547 
19548     print_VkImageCreateFlags(obj->flags, "flags", 0);
19549 
19550     INDENT(-4);
19551     PRINT_SPACE
19552     if (commaNeeded)
19553         _OUT << "}," << std::endl;
19554     else
19555         _OUT << "}" << std::endl;
19556 }
19557 
print_VkQueueFamilyProperties2(VkQueueFamilyProperties2 obj,const std::string & s,bool commaNeeded=true)19558 static void print_VkQueueFamilyProperties2(VkQueueFamilyProperties2 obj, const std::string &s, bool commaNeeded = true)
19559 {
19560     PRINT_SPACE
19561     _OUT << "{" << std::endl;
19562     INDENT(4);
19563 
19564     print_VkStructureType(obj.sType, "sType", 1);
19565 
19566     if (obj.pNext)
19567     {
19568         dumpPNextChain(obj.pNext);
19569     }
19570     else
19571     {
19572         PRINT_SPACE
19573         _OUT << "\"pNext\":"
19574              << "\"NULL\""
19575              << "," << std::endl;
19576     }
19577 
19578     PRINT_SPACE
19579     _OUT << "\"queueFamilyProperties\": " << std::endl;
19580     {
19581         print_VkQueueFamilyProperties(obj.queueFamilyProperties, "queueFamilyProperties", 0);
19582     }
19583 
19584     INDENT(-4);
19585     PRINT_SPACE
19586     if (commaNeeded)
19587         _OUT << "}," << std::endl;
19588     else
19589         _OUT << "}" << std::endl;
19590 }
print_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 * obj,const std::string & s,bool commaNeeded=true)19591 static void print_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 *obj, const std::string &s,
19592                                            bool commaNeeded = true)
19593 {
19594     PRINT_SPACE
19595     _OUT << "{" << std::endl;
19596     INDENT(4);
19597 
19598     print_VkStructureType(obj->sType, "sType", 1);
19599 
19600     if (obj->pNext)
19601     {
19602         dumpPNextChain(obj->pNext);
19603     }
19604     else
19605     {
19606         PRINT_SPACE
19607         _OUT << "\"pNext\":"
19608              << "\"NULL\""
19609              << "," << std::endl;
19610     }
19611 
19612     PRINT_SPACE
19613     _OUT << "\"queueFamilyProperties\": " << std::endl;
19614     {
19615         print_VkQueueFamilyProperties(obj->queueFamilyProperties, "queueFamilyProperties", 0);
19616     }
19617 
19618     INDENT(-4);
19619     PRINT_SPACE
19620     if (commaNeeded)
19621         _OUT << "}," << std::endl;
19622     else
19623         _OUT << "}" << std::endl;
19624 }
19625 
print_VkPhysicalDeviceMemoryProperties2(VkPhysicalDeviceMemoryProperties2 obj,const std::string & s,bool commaNeeded=true)19626 static void print_VkPhysicalDeviceMemoryProperties2(VkPhysicalDeviceMemoryProperties2 obj, const std::string &s,
19627                                                     bool commaNeeded = true)
19628 {
19629     PRINT_SPACE
19630     _OUT << "{" << std::endl;
19631     INDENT(4);
19632 
19633     print_VkStructureType(obj.sType, "sType", 1);
19634 
19635     if (obj.pNext)
19636     {
19637         dumpPNextChain(obj.pNext);
19638     }
19639     else
19640     {
19641         PRINT_SPACE
19642         _OUT << "\"pNext\":"
19643              << "\"NULL\""
19644              << "," << std::endl;
19645     }
19646 
19647     PRINT_SPACE
19648     _OUT << "\"memoryProperties\": " << std::endl;
19649     {
19650         print_VkPhysicalDeviceMemoryProperties(obj.memoryProperties, "memoryProperties", 0);
19651     }
19652 
19653     INDENT(-4);
19654     PRINT_SPACE
19655     if (commaNeeded)
19656         _OUT << "}," << std::endl;
19657     else
19658         _OUT << "}" << std::endl;
19659 }
print_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 * obj,const std::string & s,bool commaNeeded=true)19660 static void print_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 *obj, const std::string &s,
19661                                                     bool commaNeeded = true)
19662 {
19663     PRINT_SPACE
19664     _OUT << "{" << std::endl;
19665     INDENT(4);
19666 
19667     print_VkStructureType(obj->sType, "sType", 1);
19668 
19669     if (obj->pNext)
19670     {
19671         dumpPNextChain(obj->pNext);
19672     }
19673     else
19674     {
19675         PRINT_SPACE
19676         _OUT << "\"pNext\":"
19677              << "\"NULL\""
19678              << "," << std::endl;
19679     }
19680 
19681     PRINT_SPACE
19682     _OUT << "\"memoryProperties\": " << std::endl;
19683     {
19684         print_VkPhysicalDeviceMemoryProperties(obj->memoryProperties, "memoryProperties", 0);
19685     }
19686 
19687     INDENT(-4);
19688     PRINT_SPACE
19689     if (commaNeeded)
19690         _OUT << "}," << std::endl;
19691     else
19692         _OUT << "}" << std::endl;
19693 }
19694 
print_VkPhysicalDevicePointClippingProperties(VkPhysicalDevicePointClippingProperties obj,const std::string & s,bool commaNeeded=true)19695 static void print_VkPhysicalDevicePointClippingProperties(VkPhysicalDevicePointClippingProperties obj,
19696                                                           const std::string &s, bool commaNeeded = true)
19697 {
19698     PRINT_SPACE
19699     _OUT << "{" << std::endl;
19700     INDENT(4);
19701 
19702     print_VkStructureType(obj.sType, "sType", 1);
19703 
19704     if (obj.pNext)
19705     {
19706         dumpPNextChain(obj.pNext);
19707     }
19708     else
19709     {
19710         PRINT_SPACE
19711         _OUT << "\"pNext\":"
19712              << "\"NULL\""
19713              << "," << std::endl;
19714     }
19715 
19716     print_VkPointClippingBehavior(obj.pointClippingBehavior, "pointClippingBehavior", 0);
19717 
19718     INDENT(-4);
19719     PRINT_SPACE
19720     if (commaNeeded)
19721         _OUT << "}," << std::endl;
19722     else
19723         _OUT << "}" << std::endl;
19724 }
print_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties * obj,const std::string & s,bool commaNeeded=true)19725 static void print_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties *obj,
19726                                                           const std::string &s, bool commaNeeded = true)
19727 {
19728     PRINT_SPACE
19729     _OUT << "{" << std::endl;
19730     INDENT(4);
19731 
19732     print_VkStructureType(obj->sType, "sType", 1);
19733 
19734     if (obj->pNext)
19735     {
19736         dumpPNextChain(obj->pNext);
19737     }
19738     else
19739     {
19740         PRINT_SPACE
19741         _OUT << "\"pNext\":"
19742              << "\"NULL\""
19743              << "," << std::endl;
19744     }
19745 
19746     print_VkPointClippingBehavior(obj->pointClippingBehavior, "pointClippingBehavior", 0);
19747 
19748     INDENT(-4);
19749     PRINT_SPACE
19750     if (commaNeeded)
19751         _OUT << "}," << std::endl;
19752     else
19753         _OUT << "}" << std::endl;
19754 }
19755 
print_VkInputAttachmentAspectReference(VkInputAttachmentAspectReference obj,const std::string & s,bool commaNeeded=true)19756 static void print_VkInputAttachmentAspectReference(VkInputAttachmentAspectReference obj, const std::string &s,
19757                                                    bool commaNeeded = true)
19758 {
19759     PRINT_SPACE
19760     _OUT << "{" << std::endl;
19761     INDENT(4);
19762 
19763     print_uint32_t(obj.subpass, "subpass", 1);
19764 
19765     print_uint32_t(obj.inputAttachmentIndex, "inputAttachmentIndex", 1);
19766 
19767     print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 0);
19768 
19769     INDENT(-4);
19770     PRINT_SPACE
19771     if (commaNeeded)
19772         _OUT << "}," << std::endl;
19773     else
19774         _OUT << "}" << std::endl;
19775 }
print_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference * obj,const std::string & s,bool commaNeeded=true)19776 static void print_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference *obj, const std::string &s,
19777                                                    bool commaNeeded = true)
19778 {
19779     PRINT_SPACE
19780     _OUT << "{" << std::endl;
19781     INDENT(4);
19782 
19783     print_uint32_t(obj->subpass, "subpass", 1);
19784 
19785     print_uint32_t(obj->inputAttachmentIndex, "inputAttachmentIndex", 1);
19786 
19787     print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 0);
19788 
19789     INDENT(-4);
19790     PRINT_SPACE
19791     if (commaNeeded)
19792         _OUT << "}," << std::endl;
19793     else
19794         _OUT << "}" << std::endl;
19795 }
19796 
print_VkRenderPassInputAttachmentAspectCreateInfo(VkRenderPassInputAttachmentAspectCreateInfo obj,const std::string & s,bool commaNeeded=true)19797 static void print_VkRenderPassInputAttachmentAspectCreateInfo(VkRenderPassInputAttachmentAspectCreateInfo obj,
19798                                                               const std::string &s, bool commaNeeded = true)
19799 {
19800     PRINT_SPACE
19801     _OUT << "{" << std::endl;
19802     INDENT(4);
19803 
19804     print_VkStructureType(obj.sType, "sType", 1);
19805 
19806     if (obj.pNext)
19807     {
19808         dumpPNextChain(obj.pNext);
19809     }
19810     else
19811     {
19812         PRINT_SPACE
19813         _OUT << "\"pNext\":"
19814              << "\"NULL\""
19815              << "," << std::endl;
19816     }
19817 
19818     print_uint32_t(obj.aspectReferenceCount, "aspectReferenceCount", 1);
19819 
19820     PRINT_SPACE
19821     _OUT << "\"pAspectReferences\": " << std::endl;
19822     if (obj.pAspectReferences)
19823     {
19824         PRINT_SPACE
19825         _OUT << "[" << std::endl;
19826         for (unsigned int i = 0; i < obj.aspectReferenceCount; i++)
19827         {
19828             if (i + 1 == obj.aspectReferenceCount)
19829                 print_VkInputAttachmentAspectReference(obj.pAspectReferences[i], "pAspectReferences", 0);
19830             else
19831                 print_VkInputAttachmentAspectReference(obj.pAspectReferences[i], "pAspectReferences", 1);
19832         }
19833         PRINT_SPACE
19834         _OUT << "]" << std::endl;
19835     }
19836     else
19837     {
19838         PRINT_SPACE _OUT << "\"NULL\""
19839                          << "" << std::endl;
19840     }
19841 
19842     INDENT(-4);
19843     PRINT_SPACE
19844     if (commaNeeded)
19845         _OUT << "}," << std::endl;
19846     else
19847         _OUT << "}" << std::endl;
19848 }
print_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo * obj,const std::string & s,bool commaNeeded=true)19849 static void print_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo *obj,
19850                                                               const std::string &s, bool commaNeeded = true)
19851 {
19852     PRINT_SPACE
19853     _OUT << "{" << std::endl;
19854     INDENT(4);
19855 
19856     print_VkStructureType(obj->sType, "sType", 1);
19857 
19858     if (obj->pNext)
19859     {
19860         dumpPNextChain(obj->pNext);
19861     }
19862     else
19863     {
19864         PRINT_SPACE
19865         _OUT << "\"pNext\":"
19866              << "\"NULL\""
19867              << "," << std::endl;
19868     }
19869 
19870     print_uint32_t(obj->aspectReferenceCount, "aspectReferenceCount", 1);
19871 
19872     PRINT_SPACE
19873     _OUT << "\"pAspectReferences\": " << std::endl;
19874     if (obj->pAspectReferences)
19875     {
19876         PRINT_SPACE
19877         _OUT << "[" << std::endl;
19878         for (unsigned int i = 0; i < obj->aspectReferenceCount; i++)
19879         {
19880             if (i + 1 == obj->aspectReferenceCount)
19881                 print_VkInputAttachmentAspectReference(obj->pAspectReferences[i], "pAspectReferences", 0);
19882             else
19883                 print_VkInputAttachmentAspectReference(obj->pAspectReferences[i], "pAspectReferences", 1);
19884         }
19885         PRINT_SPACE
19886         _OUT << "]" << std::endl;
19887     }
19888     else
19889     {
19890         PRINT_SPACE _OUT << "\"NULL\""
19891                          << "" << std::endl;
19892     }
19893 
19894     INDENT(-4);
19895     PRINT_SPACE
19896     if (commaNeeded)
19897         _OUT << "}," << std::endl;
19898     else
19899         _OUT << "}" << std::endl;
19900 }
19901 
print_VkImageViewUsageCreateInfo(VkImageViewUsageCreateInfo obj,const std::string & s,bool commaNeeded=true)19902 static void print_VkImageViewUsageCreateInfo(VkImageViewUsageCreateInfo obj, const std::string &s,
19903                                              bool commaNeeded = true)
19904 {
19905     PRINT_SPACE
19906     _OUT << "{" << std::endl;
19907     INDENT(4);
19908 
19909     print_VkStructureType(obj.sType, "sType", 1);
19910 
19911     if (obj.pNext)
19912     {
19913         dumpPNextChain(obj.pNext);
19914     }
19915     else
19916     {
19917         PRINT_SPACE
19918         _OUT << "\"pNext\":"
19919              << "\"NULL\""
19920              << "," << std::endl;
19921     }
19922 
19923     print_VkImageUsageFlags(obj.usage, "usage", 0);
19924 
19925     INDENT(-4);
19926     PRINT_SPACE
19927     if (commaNeeded)
19928         _OUT << "}," << std::endl;
19929     else
19930         _OUT << "}" << std::endl;
19931 }
print_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo * obj,const std::string & s,bool commaNeeded=true)19932 static void print_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo *obj, const std::string &s,
19933                                              bool commaNeeded = true)
19934 {
19935     PRINT_SPACE
19936     _OUT << "{" << std::endl;
19937     INDENT(4);
19938 
19939     print_VkStructureType(obj->sType, "sType", 1);
19940 
19941     if (obj->pNext)
19942     {
19943         dumpPNextChain(obj->pNext);
19944     }
19945     else
19946     {
19947         PRINT_SPACE
19948         _OUT << "\"pNext\":"
19949              << "\"NULL\""
19950              << "," << std::endl;
19951     }
19952 
19953     print_VkImageUsageFlags(obj->usage, "usage", 0);
19954 
19955     INDENT(-4);
19956     PRINT_SPACE
19957     if (commaNeeded)
19958         _OUT << "}," << std::endl;
19959     else
19960         _OUT << "}" << std::endl;
19961 }
19962 
print_VkPipelineTessellationDomainOriginStateCreateInfo(VkPipelineTessellationDomainOriginStateCreateInfo obj,const std::string & s,bool commaNeeded=true)19963 static void print_VkPipelineTessellationDomainOriginStateCreateInfo(
19964     VkPipelineTessellationDomainOriginStateCreateInfo obj, const std::string &s, bool commaNeeded = true)
19965 {
19966     PRINT_SPACE
19967     _OUT << "{" << std::endl;
19968     INDENT(4);
19969 
19970     print_VkStructureType(obj.sType, "sType", 1);
19971 
19972     if (obj.pNext)
19973     {
19974         dumpPNextChain(obj.pNext);
19975     }
19976     else
19977     {
19978         PRINT_SPACE
19979         _OUT << "\"pNext\":"
19980              << "\"NULL\""
19981              << "," << std::endl;
19982     }
19983 
19984     print_VkTessellationDomainOrigin(obj.domainOrigin, "domainOrigin", 0);
19985 
19986     INDENT(-4);
19987     PRINT_SPACE
19988     if (commaNeeded)
19989         _OUT << "}," << std::endl;
19990     else
19991         _OUT << "}" << std::endl;
19992 }
print_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo * obj,const std::string & s,bool commaNeeded=true)19993 static void print_VkPipelineTessellationDomainOriginStateCreateInfo(
19994     const VkPipelineTessellationDomainOriginStateCreateInfo *obj, const std::string &s, bool commaNeeded = true)
19995 {
19996     PRINT_SPACE
19997     _OUT << "{" << std::endl;
19998     INDENT(4);
19999 
20000     print_VkStructureType(obj->sType, "sType", 1);
20001 
20002     if (obj->pNext)
20003     {
20004         dumpPNextChain(obj->pNext);
20005     }
20006     else
20007     {
20008         PRINT_SPACE
20009         _OUT << "\"pNext\":"
20010              << "\"NULL\""
20011              << "," << std::endl;
20012     }
20013 
20014     print_VkTessellationDomainOrigin(obj->domainOrigin, "domainOrigin", 0);
20015 
20016     INDENT(-4);
20017     PRINT_SPACE
20018     if (commaNeeded)
20019         _OUT << "}," << std::endl;
20020     else
20021         _OUT << "}" << std::endl;
20022 }
20023 
print_VkRenderPassMultiviewCreateInfo(VkRenderPassMultiviewCreateInfo obj,const std::string & s,bool commaNeeded=true)20024 static void print_VkRenderPassMultiviewCreateInfo(VkRenderPassMultiviewCreateInfo obj, const std::string &s,
20025                                                   bool commaNeeded = true)
20026 {
20027     PRINT_SPACE
20028     _OUT << "{" << std::endl;
20029     INDENT(4);
20030 
20031     print_VkStructureType(obj.sType, "sType", 1);
20032 
20033     if (obj.pNext)
20034     {
20035         dumpPNextChain(obj.pNext);
20036     }
20037     else
20038     {
20039         PRINT_SPACE
20040         _OUT << "\"pNext\":"
20041              << "\"NULL\""
20042              << "," << std::endl;
20043     }
20044 
20045     print_uint32_t(obj.subpassCount, "subpassCount", 1);
20046 
20047     PRINT_SPACE
20048     _OUT << "\"pViewMasks\":" << std::endl;
20049     PRINT_SPACE
20050     if (obj.pViewMasks)
20051     {
20052         _OUT << "[" << std::endl;
20053         for (unsigned int i = 0; i < obj.subpassCount; i++)
20054         {
20055             bool isCommaNeeded = (i + 1) != obj.subpassCount;
20056             print_uint32_t(obj.pViewMasks[i], "", isCommaNeeded);
20057         }
20058         PRINT_SPACE
20059         _OUT << "]"
20060              << "," << std::endl;
20061     }
20062     else
20063     {
20064         _OUT << "\"NULL\""
20065              << "," << std::endl;
20066     }
20067 
20068     print_uint32_t(obj.dependencyCount, "dependencyCount", 1);
20069 
20070     PRINT_SPACE
20071     _OUT << "\"pViewOffsets\":" << std::endl;
20072     PRINT_SPACE
20073     if (obj.pViewOffsets)
20074     {
20075         _OUT << "[" << std::endl;
20076         for (unsigned int i = 0; i < obj.dependencyCount; i++)
20077         {
20078             bool isCommaNeeded = (i + 1) != obj.dependencyCount;
20079             print_int32_t(obj.pViewOffsets[i], "", isCommaNeeded);
20080         }
20081         PRINT_SPACE
20082         _OUT << "]"
20083              << "," << std::endl;
20084     }
20085     else
20086     {
20087         _OUT << "\"NULL\""
20088              << "," << std::endl;
20089     }
20090 
20091     print_uint32_t(obj.correlationMaskCount, "correlationMaskCount", 1);
20092 
20093     PRINT_SPACE
20094     _OUT << "\"pCorrelationMasks\":" << std::endl;
20095     PRINT_SPACE
20096     if (obj.pCorrelationMasks)
20097     {
20098         _OUT << "[" << std::endl;
20099         for (unsigned int i = 0; i < obj.correlationMaskCount; i++)
20100         {
20101             bool isCommaNeeded = (i + 1) != obj.correlationMaskCount;
20102             print_uint32_t(obj.pCorrelationMasks[i], "", isCommaNeeded);
20103         }
20104         PRINT_SPACE
20105         _OUT << "]"
20106              << "" << std::endl;
20107     }
20108     else
20109     {
20110         _OUT << "\"NULL\""
20111              << "" << std::endl;
20112     }
20113 
20114     INDENT(-4);
20115     PRINT_SPACE
20116     if (commaNeeded)
20117         _OUT << "}," << std::endl;
20118     else
20119         _OUT << "}" << std::endl;
20120 }
print_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo * obj,const std::string & s,bool commaNeeded=true)20121 static void print_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo *obj, const std::string &s,
20122                                                   bool commaNeeded = true)
20123 {
20124     PRINT_SPACE
20125     _OUT << "{" << std::endl;
20126     INDENT(4);
20127 
20128     print_VkStructureType(obj->sType, "sType", 1);
20129 
20130     if (obj->pNext)
20131     {
20132         dumpPNextChain(obj->pNext);
20133     }
20134     else
20135     {
20136         PRINT_SPACE
20137         _OUT << "\"pNext\":"
20138              << "\"NULL\""
20139              << "," << std::endl;
20140     }
20141 
20142     print_uint32_t(obj->subpassCount, "subpassCount", 1);
20143 
20144     PRINT_SPACE
20145     _OUT << "\"pViewMasks\":" << std::endl;
20146     PRINT_SPACE
20147     if (obj->pViewMasks)
20148     {
20149         _OUT << "[" << std::endl;
20150         for (unsigned int i = 0; i < obj->subpassCount; i++)
20151         {
20152             bool isCommaNeeded = (i + 1) != obj->subpassCount;
20153             print_uint32_t(obj->pViewMasks[i], "", isCommaNeeded);
20154         }
20155         PRINT_SPACE
20156         _OUT << "]"
20157              << "," << std::endl;
20158     }
20159     else
20160     {
20161         _OUT << "\"NULL\""
20162              << "," << std::endl;
20163     }
20164 
20165     print_uint32_t(obj->dependencyCount, "dependencyCount", 1);
20166 
20167     PRINT_SPACE
20168     _OUT << "\"pViewOffsets\":" << std::endl;
20169     PRINT_SPACE
20170     if (obj->pViewOffsets)
20171     {
20172         _OUT << "[" << std::endl;
20173         for (unsigned int i = 0; i < obj->dependencyCount; i++)
20174         {
20175             bool isCommaNeeded = (i + 1) != obj->dependencyCount;
20176             print_int32_t(obj->pViewOffsets[i], "", isCommaNeeded);
20177         }
20178         PRINT_SPACE
20179         _OUT << "]"
20180              << "," << std::endl;
20181     }
20182     else
20183     {
20184         _OUT << "\"NULL\""
20185              << "," << std::endl;
20186     }
20187 
20188     print_uint32_t(obj->correlationMaskCount, "correlationMaskCount", 1);
20189 
20190     PRINT_SPACE
20191     _OUT << "\"pCorrelationMasks\":" << std::endl;
20192     PRINT_SPACE
20193     if (obj->pCorrelationMasks)
20194     {
20195         _OUT << "[" << std::endl;
20196         for (unsigned int i = 0; i < obj->correlationMaskCount; i++)
20197         {
20198             bool isCommaNeeded = (i + 1) != obj->correlationMaskCount;
20199             print_uint32_t(obj->pCorrelationMasks[i], "", isCommaNeeded);
20200         }
20201         PRINT_SPACE
20202         _OUT << "]"
20203              << "" << std::endl;
20204     }
20205     else
20206     {
20207         _OUT << "\"NULL\""
20208              << "" << std::endl;
20209     }
20210 
20211     INDENT(-4);
20212     PRINT_SPACE
20213     if (commaNeeded)
20214         _OUT << "}," << std::endl;
20215     else
20216         _OUT << "}" << std::endl;
20217 }
20218 
print_VkPhysicalDeviceMultiviewFeatures(VkPhysicalDeviceMultiviewFeatures obj,const std::string & s,bool commaNeeded=true)20219 static void print_VkPhysicalDeviceMultiviewFeatures(VkPhysicalDeviceMultiviewFeatures obj, const std::string &s,
20220                                                     bool commaNeeded = true)
20221 {
20222     PRINT_SPACE
20223     _OUT << "{" << std::endl;
20224     INDENT(4);
20225 
20226     print_VkStructureType(obj.sType, "sType", 1);
20227 
20228     if (obj.pNext)
20229     {
20230         dumpPNextChain(obj.pNext);
20231     }
20232     else
20233     {
20234         PRINT_SPACE
20235         _OUT << "\"pNext\":"
20236              << "\"NULL\""
20237              << "," << std::endl;
20238     }
20239 
20240     print_VkBool32(obj.multiview, "multiview", 1);
20241 
20242     print_VkBool32(obj.multiviewGeometryShader, "multiviewGeometryShader", 1);
20243 
20244     print_VkBool32(obj.multiviewTessellationShader, "multiviewTessellationShader", 0);
20245 
20246     INDENT(-4);
20247     PRINT_SPACE
20248     if (commaNeeded)
20249         _OUT << "}," << std::endl;
20250     else
20251         _OUT << "}" << std::endl;
20252 }
print_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures * obj,const std::string & s,bool commaNeeded=true)20253 static void print_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures *obj, const std::string &s,
20254                                                     bool commaNeeded = true)
20255 {
20256     PRINT_SPACE
20257     _OUT << "{" << std::endl;
20258     INDENT(4);
20259 
20260     print_VkStructureType(obj->sType, "sType", 1);
20261 
20262     if (obj->pNext)
20263     {
20264         dumpPNextChain(obj->pNext);
20265     }
20266     else
20267     {
20268         PRINT_SPACE
20269         _OUT << "\"pNext\":"
20270              << "\"NULL\""
20271              << "," << std::endl;
20272     }
20273 
20274     print_VkBool32(obj->multiview, "multiview", 1);
20275 
20276     print_VkBool32(obj->multiviewGeometryShader, "multiviewGeometryShader", 1);
20277 
20278     print_VkBool32(obj->multiviewTessellationShader, "multiviewTessellationShader", 0);
20279 
20280     INDENT(-4);
20281     PRINT_SPACE
20282     if (commaNeeded)
20283         _OUT << "}," << std::endl;
20284     else
20285         _OUT << "}" << std::endl;
20286 }
20287 
print_VkPhysicalDeviceMultiviewProperties(VkPhysicalDeviceMultiviewProperties obj,const std::string & s,bool commaNeeded=true)20288 static void print_VkPhysicalDeviceMultiviewProperties(VkPhysicalDeviceMultiviewProperties obj, const std::string &s,
20289                                                       bool commaNeeded = true)
20290 {
20291     PRINT_SPACE
20292     _OUT << "{" << std::endl;
20293     INDENT(4);
20294 
20295     print_VkStructureType(obj.sType, "sType", 1);
20296 
20297     if (obj.pNext)
20298     {
20299         dumpPNextChain(obj.pNext);
20300     }
20301     else
20302     {
20303         PRINT_SPACE
20304         _OUT << "\"pNext\":"
20305              << "\"NULL\""
20306              << "," << std::endl;
20307     }
20308 
20309     print_uint32_t(obj.maxMultiviewViewCount, "maxMultiviewViewCount", 1);
20310 
20311     print_uint32_t(obj.maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 0);
20312 
20313     INDENT(-4);
20314     PRINT_SPACE
20315     if (commaNeeded)
20316         _OUT << "}," << std::endl;
20317     else
20318         _OUT << "}" << std::endl;
20319 }
print_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties * obj,const std::string & s,bool commaNeeded=true)20320 static void print_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties *obj,
20321                                                       const std::string &s, bool commaNeeded = true)
20322 {
20323     PRINT_SPACE
20324     _OUT << "{" << std::endl;
20325     INDENT(4);
20326 
20327     print_VkStructureType(obj->sType, "sType", 1);
20328 
20329     if (obj->pNext)
20330     {
20331         dumpPNextChain(obj->pNext);
20332     }
20333     else
20334     {
20335         PRINT_SPACE
20336         _OUT << "\"pNext\":"
20337              << "\"NULL\""
20338              << "," << std::endl;
20339     }
20340 
20341     print_uint32_t(obj->maxMultiviewViewCount, "maxMultiviewViewCount", 1);
20342 
20343     print_uint32_t(obj->maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 0);
20344 
20345     INDENT(-4);
20346     PRINT_SPACE
20347     if (commaNeeded)
20348         _OUT << "}," << std::endl;
20349     else
20350         _OUT << "}" << std::endl;
20351 }
20352 
print_VkPhysicalDeviceVariablePointersFeatures(VkPhysicalDeviceVariablePointersFeatures obj,const std::string & s,bool commaNeeded=true)20353 static void print_VkPhysicalDeviceVariablePointersFeatures(VkPhysicalDeviceVariablePointersFeatures obj,
20354                                                            const std::string &s, bool commaNeeded = true)
20355 {
20356     PRINT_SPACE
20357     _OUT << "{" << std::endl;
20358     INDENT(4);
20359 
20360     print_VkStructureType(obj.sType, "sType", 1);
20361 
20362     if (obj.pNext)
20363     {
20364         dumpPNextChain(obj.pNext);
20365     }
20366     else
20367     {
20368         PRINT_SPACE
20369         _OUT << "\"pNext\":"
20370              << "\"NULL\""
20371              << "," << std::endl;
20372     }
20373 
20374     print_VkBool32(obj.variablePointersStorageBuffer, "variablePointersStorageBuffer", 1);
20375 
20376     print_VkBool32(obj.variablePointers, "variablePointers", 0);
20377 
20378     INDENT(-4);
20379     PRINT_SPACE
20380     if (commaNeeded)
20381         _OUT << "}," << std::endl;
20382     else
20383         _OUT << "}" << std::endl;
20384 }
print_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures * obj,const std::string & s,bool commaNeeded=true)20385 static void print_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures *obj,
20386                                                            const std::string &s, bool commaNeeded = true)
20387 {
20388     PRINT_SPACE
20389     _OUT << "{" << std::endl;
20390     INDENT(4);
20391 
20392     print_VkStructureType(obj->sType, "sType", 1);
20393 
20394     if (obj->pNext)
20395     {
20396         dumpPNextChain(obj->pNext);
20397     }
20398     else
20399     {
20400         PRINT_SPACE
20401         _OUT << "\"pNext\":"
20402              << "\"NULL\""
20403              << "," << std::endl;
20404     }
20405 
20406     print_VkBool32(obj->variablePointersStorageBuffer, "variablePointersStorageBuffer", 1);
20407 
20408     print_VkBool32(obj->variablePointers, "variablePointers", 0);
20409 
20410     INDENT(-4);
20411     PRINT_SPACE
20412     if (commaNeeded)
20413         _OUT << "}," << std::endl;
20414     else
20415         _OUT << "}" << std::endl;
20416 }
20417 
20418 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures;
20419 
print_VkPhysicalDeviceProtectedMemoryFeatures(VkPhysicalDeviceProtectedMemoryFeatures obj,const std::string & s,bool commaNeeded=true)20420 static void print_VkPhysicalDeviceProtectedMemoryFeatures(VkPhysicalDeviceProtectedMemoryFeatures obj,
20421                                                           const std::string &s, bool commaNeeded = true)
20422 {
20423     PRINT_SPACE
20424     _OUT << "{" << std::endl;
20425     INDENT(4);
20426 
20427     print_VkStructureType(obj.sType, "sType", 1);
20428 
20429     if (obj.pNext)
20430     {
20431         dumpPNextChain(obj.pNext);
20432     }
20433     else
20434     {
20435         PRINT_SPACE
20436         _OUT << "\"pNext\":"
20437              << "\"NULL\""
20438              << "," << std::endl;
20439     }
20440 
20441     print_VkBool32(obj.protectedMemory, "protectedMemory", 0);
20442 
20443     INDENT(-4);
20444     PRINT_SPACE
20445     if (commaNeeded)
20446         _OUT << "}," << std::endl;
20447     else
20448         _OUT << "}" << std::endl;
20449 }
print_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures * obj,const std::string & s,bool commaNeeded=true)20450 static void print_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures *obj,
20451                                                           const std::string &s, bool commaNeeded = true)
20452 {
20453     PRINT_SPACE
20454     _OUT << "{" << std::endl;
20455     INDENT(4);
20456 
20457     print_VkStructureType(obj->sType, "sType", 1);
20458 
20459     if (obj->pNext)
20460     {
20461         dumpPNextChain(obj->pNext);
20462     }
20463     else
20464     {
20465         PRINT_SPACE
20466         _OUT << "\"pNext\":"
20467              << "\"NULL\""
20468              << "," << std::endl;
20469     }
20470 
20471     print_VkBool32(obj->protectedMemory, "protectedMemory", 0);
20472 
20473     INDENT(-4);
20474     PRINT_SPACE
20475     if (commaNeeded)
20476         _OUT << "}," << std::endl;
20477     else
20478         _OUT << "}" << std::endl;
20479 }
20480 
print_VkPhysicalDeviceProtectedMemoryProperties(VkPhysicalDeviceProtectedMemoryProperties obj,const std::string & s,bool commaNeeded=true)20481 static void print_VkPhysicalDeviceProtectedMemoryProperties(VkPhysicalDeviceProtectedMemoryProperties obj,
20482                                                             const std::string &s, bool commaNeeded = true)
20483 {
20484     PRINT_SPACE
20485     _OUT << "{" << std::endl;
20486     INDENT(4);
20487 
20488     print_VkStructureType(obj.sType, "sType", 1);
20489 
20490     if (obj.pNext)
20491     {
20492         dumpPNextChain(obj.pNext);
20493     }
20494     else
20495     {
20496         PRINT_SPACE
20497         _OUT << "\"pNext\":"
20498              << "\"NULL\""
20499              << "," << std::endl;
20500     }
20501 
20502     print_VkBool32(obj.protectedNoFault, "protectedNoFault", 0);
20503 
20504     INDENT(-4);
20505     PRINT_SPACE
20506     if (commaNeeded)
20507         _OUT << "}," << std::endl;
20508     else
20509         _OUT << "}" << std::endl;
20510 }
print_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties * obj,const std::string & s,bool commaNeeded=true)20511 static void print_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties *obj,
20512                                                             const std::string &s, bool commaNeeded = true)
20513 {
20514     PRINT_SPACE
20515     _OUT << "{" << std::endl;
20516     INDENT(4);
20517 
20518     print_VkStructureType(obj->sType, "sType", 1);
20519 
20520     if (obj->pNext)
20521     {
20522         dumpPNextChain(obj->pNext);
20523     }
20524     else
20525     {
20526         PRINT_SPACE
20527         _OUT << "\"pNext\":"
20528              << "\"NULL\""
20529              << "," << std::endl;
20530     }
20531 
20532     print_VkBool32(obj->protectedNoFault, "protectedNoFault", 0);
20533 
20534     INDENT(-4);
20535     PRINT_SPACE
20536     if (commaNeeded)
20537         _OUT << "}," << std::endl;
20538     else
20539         _OUT << "}" << std::endl;
20540 }
20541 
print_VkDeviceQueueInfo2(VkDeviceQueueInfo2 obj,const std::string & s,bool commaNeeded=true)20542 static void print_VkDeviceQueueInfo2(VkDeviceQueueInfo2 obj, const std::string &s, bool commaNeeded = true)
20543 {
20544     PRINT_SPACE
20545     _OUT << "{" << std::endl;
20546     INDENT(4);
20547 
20548     print_VkStructureType(obj.sType, "sType", 1);
20549 
20550     if (obj.pNext)
20551     {
20552         dumpPNextChain(obj.pNext);
20553     }
20554     else
20555     {
20556         PRINT_SPACE
20557         _OUT << "\"pNext\":"
20558              << "\"NULL\""
20559              << "," << std::endl;
20560     }
20561 
20562     print_VkDeviceQueueCreateFlags(obj.flags, "flags", 1);
20563 
20564     print_uint32_t(obj.queueFamilyIndex, "queueFamilyIndex", 1);
20565 
20566     print_uint32_t(obj.queueIndex, "queueIndex", 0);
20567 
20568     INDENT(-4);
20569     PRINT_SPACE
20570     if (commaNeeded)
20571         _OUT << "}," << std::endl;
20572     else
20573         _OUT << "}" << std::endl;
20574 }
print_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 * obj,const std::string & s,bool commaNeeded=true)20575 static void print_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 *obj, const std::string &s, bool commaNeeded = true)
20576 {
20577     PRINT_SPACE
20578     _OUT << "{" << std::endl;
20579     INDENT(4);
20580 
20581     print_VkStructureType(obj->sType, "sType", 1);
20582 
20583     if (obj->pNext)
20584     {
20585         dumpPNextChain(obj->pNext);
20586     }
20587     else
20588     {
20589         PRINT_SPACE
20590         _OUT << "\"pNext\":"
20591              << "\"NULL\""
20592              << "," << std::endl;
20593     }
20594 
20595     print_VkDeviceQueueCreateFlags(obj->flags, "flags", 1);
20596 
20597     print_uint32_t(obj->queueFamilyIndex, "queueFamilyIndex", 1);
20598 
20599     print_uint32_t(obj->queueIndex, "queueIndex", 0);
20600 
20601     INDENT(-4);
20602     PRINT_SPACE
20603     if (commaNeeded)
20604         _OUT << "}," << std::endl;
20605     else
20606         _OUT << "}" << std::endl;
20607 }
20608 
print_VkProtectedSubmitInfo(VkProtectedSubmitInfo obj,const std::string & s,bool commaNeeded=true)20609 static void print_VkProtectedSubmitInfo(VkProtectedSubmitInfo obj, const std::string &s, bool commaNeeded = true)
20610 {
20611     PRINT_SPACE
20612     _OUT << "{" << std::endl;
20613     INDENT(4);
20614 
20615     print_VkStructureType(obj.sType, "sType", 1);
20616 
20617     if (obj.pNext)
20618     {
20619         dumpPNextChain(obj.pNext);
20620     }
20621     else
20622     {
20623         PRINT_SPACE
20624         _OUT << "\"pNext\":"
20625              << "\"NULL\""
20626              << "," << std::endl;
20627     }
20628 
20629     print_VkBool32(obj.protectedSubmit, "protectedSubmit", 0);
20630 
20631     INDENT(-4);
20632     PRINT_SPACE
20633     if (commaNeeded)
20634         _OUT << "}," << std::endl;
20635     else
20636         _OUT << "}" << std::endl;
20637 }
print_VkProtectedSubmitInfo(const VkProtectedSubmitInfo * obj,const std::string & s,bool commaNeeded=true)20638 static void print_VkProtectedSubmitInfo(const VkProtectedSubmitInfo *obj, const std::string &s, bool commaNeeded = true)
20639 {
20640     PRINT_SPACE
20641     _OUT << "{" << std::endl;
20642     INDENT(4);
20643 
20644     print_VkStructureType(obj->sType, "sType", 1);
20645 
20646     if (obj->pNext)
20647     {
20648         dumpPNextChain(obj->pNext);
20649     }
20650     else
20651     {
20652         PRINT_SPACE
20653         _OUT << "\"pNext\":"
20654              << "\"NULL\""
20655              << "," << std::endl;
20656     }
20657 
20658     print_VkBool32(obj->protectedSubmit, "protectedSubmit", 0);
20659 
20660     INDENT(-4);
20661     PRINT_SPACE
20662     if (commaNeeded)
20663         _OUT << "}," << std::endl;
20664     else
20665         _OUT << "}" << std::endl;
20666 }
20667 
print_VkSamplerYcbcrConversionCreateInfo(VkSamplerYcbcrConversionCreateInfo obj,const std::string & s,bool commaNeeded=true)20668 static void print_VkSamplerYcbcrConversionCreateInfo(VkSamplerYcbcrConversionCreateInfo obj, const std::string &s,
20669                                                      bool commaNeeded = true)
20670 {
20671     PRINT_SPACE
20672     _OUT << "{" << std::endl;
20673     INDENT(4);
20674 
20675     print_VkStructureType(obj.sType, "sType", 1);
20676 
20677     if (obj.pNext)
20678     {
20679         dumpPNextChain(obj.pNext);
20680     }
20681     else
20682     {
20683         PRINT_SPACE
20684         _OUT << "\"pNext\":"
20685              << "\"NULL\""
20686              << "," << std::endl;
20687     }
20688 
20689     print_VkFormat(obj.format, "format", 1);
20690 
20691     print_VkSamplerYcbcrModelConversion(obj.ycbcrModel, "ycbcrModel", 1);
20692 
20693     print_VkSamplerYcbcrRange(obj.ycbcrRange, "ycbcrRange", 1);
20694 
20695     PRINT_SPACE
20696     _OUT << "\"components\": " << std::endl;
20697     {
20698         print_VkComponentMapping(obj.components, "components", 1);
20699     }
20700 
20701     print_VkChromaLocation(obj.xChromaOffset, "xChromaOffset", 1);
20702 
20703     print_VkChromaLocation(obj.yChromaOffset, "yChromaOffset", 1);
20704 
20705     print_VkFilter(obj.chromaFilter, "chromaFilter", 1);
20706 
20707     print_VkBool32(obj.forceExplicitReconstruction, "forceExplicitReconstruction", 0);
20708 
20709     INDENT(-4);
20710     PRINT_SPACE
20711     if (commaNeeded)
20712         _OUT << "}," << std::endl;
20713     else
20714         _OUT << "}" << std::endl;
20715 }
print_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo * obj,const std::string & s,bool commaNeeded=true)20716 static void print_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo *obj,
20717                                                      const std::string &s, bool commaNeeded = true)
20718 {
20719     PRINT_SPACE
20720     _OUT << "{" << std::endl;
20721     INDENT(4);
20722 
20723     print_VkStructureType(obj->sType, "sType", 1);
20724 
20725     if (obj->pNext)
20726     {
20727         dumpPNextChain(obj->pNext);
20728     }
20729     else
20730     {
20731         PRINT_SPACE
20732         _OUT << "\"pNext\":"
20733              << "\"NULL\""
20734              << "," << std::endl;
20735     }
20736 
20737     print_VkFormat(obj->format, "format", 1);
20738 
20739     print_VkSamplerYcbcrModelConversion(obj->ycbcrModel, "ycbcrModel", 1);
20740 
20741     print_VkSamplerYcbcrRange(obj->ycbcrRange, "ycbcrRange", 1);
20742 
20743     PRINT_SPACE
20744     _OUT << "\"components\": " << std::endl;
20745     {
20746         print_VkComponentMapping(obj->components, "components", 1);
20747     }
20748 
20749     print_VkChromaLocation(obj->xChromaOffset, "xChromaOffset", 1);
20750 
20751     print_VkChromaLocation(obj->yChromaOffset, "yChromaOffset", 1);
20752 
20753     print_VkFilter(obj->chromaFilter, "chromaFilter", 1);
20754 
20755     print_VkBool32(obj->forceExplicitReconstruction, "forceExplicitReconstruction", 0);
20756 
20757     INDENT(-4);
20758     PRINT_SPACE
20759     if (commaNeeded)
20760         _OUT << "}," << std::endl;
20761     else
20762         _OUT << "}" << std::endl;
20763 }
20764 
print_VkSamplerYcbcrConversionInfo(VkSamplerYcbcrConversionInfo obj,const std::string & s,bool commaNeeded=true)20765 static void print_VkSamplerYcbcrConversionInfo(VkSamplerYcbcrConversionInfo obj, const std::string &s,
20766                                                bool commaNeeded = true)
20767 {
20768     PRINT_SPACE
20769     _OUT << "{" << std::endl;
20770     INDENT(4);
20771 
20772     print_VkStructureType(obj.sType, "sType", 1);
20773 
20774     if (obj.pNext)
20775     {
20776         dumpPNextChain(obj.pNext);
20777     }
20778     else
20779     {
20780         PRINT_SPACE
20781         _OUT << "\"pNext\":"
20782              << "\"NULL\""
20783              << "," << std::endl;
20784     }
20785 
20786     // CTS : required value
20787     PRINT_SPACE _OUT << "\""
20788                      << "conversion"
20789                      << "\""
20790                      << " : " << obj.conversion.getInternal() << std::endl;
20791 
20792     INDENT(-4);
20793     PRINT_SPACE
20794     if (commaNeeded)
20795         _OUT << "}," << std::endl;
20796     else
20797         _OUT << "}" << std::endl;
20798 }
print_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo * obj,const std::string & s,bool commaNeeded=true)20799 static void print_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo *obj, const std::string &s,
20800                                                bool commaNeeded = true)
20801 {
20802     PRINT_SPACE
20803     _OUT << "{" << std::endl;
20804     INDENT(4);
20805 
20806     print_VkStructureType(obj->sType, "sType", 1);
20807 
20808     if (obj->pNext)
20809     {
20810         dumpPNextChain(obj->pNext);
20811     }
20812     else
20813     {
20814         PRINT_SPACE
20815         _OUT << "\"pNext\":"
20816              << "\"NULL\""
20817              << "," << std::endl;
20818     }
20819 
20820     // CTS : required value
20821     PRINT_SPACE _OUT << "\""
20822                      << "conversion"
20823                      << "\""
20824                      << " : " << obj->conversion.getInternal() << std::endl;
20825 
20826     INDENT(-4);
20827     PRINT_SPACE
20828     if (commaNeeded)
20829         _OUT << "}," << std::endl;
20830     else
20831         _OUT << "}" << std::endl;
20832 }
20833 
print_VkBindImagePlaneMemoryInfo(VkBindImagePlaneMemoryInfo obj,const std::string & s,bool commaNeeded=true)20834 static void print_VkBindImagePlaneMemoryInfo(VkBindImagePlaneMemoryInfo obj, const std::string &s,
20835                                              bool commaNeeded = true)
20836 {
20837     PRINT_SPACE
20838     _OUT << "{" << std::endl;
20839     INDENT(4);
20840 
20841     print_VkStructureType(obj.sType, "sType", 1);
20842 
20843     if (obj.pNext)
20844     {
20845         dumpPNextChain(obj.pNext);
20846     }
20847     else
20848     {
20849         PRINT_SPACE
20850         _OUT << "\"pNext\":"
20851              << "\"NULL\""
20852              << "," << std::endl;
20853     }
20854 
20855     print_VkImageAspectFlagBits(obj.planeAspect, "planeAspect", 0);
20856 
20857     INDENT(-4);
20858     PRINT_SPACE
20859     if (commaNeeded)
20860         _OUT << "}," << std::endl;
20861     else
20862         _OUT << "}" << std::endl;
20863 }
print_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo * obj,const std::string & s,bool commaNeeded=true)20864 static void print_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo *obj, const std::string &s,
20865                                              bool commaNeeded = true)
20866 {
20867     PRINT_SPACE
20868     _OUT << "{" << std::endl;
20869     INDENT(4);
20870 
20871     print_VkStructureType(obj->sType, "sType", 1);
20872 
20873     if (obj->pNext)
20874     {
20875         dumpPNextChain(obj->pNext);
20876     }
20877     else
20878     {
20879         PRINT_SPACE
20880         _OUT << "\"pNext\":"
20881              << "\"NULL\""
20882              << "," << std::endl;
20883     }
20884 
20885     print_VkImageAspectFlagBits(obj->planeAspect, "planeAspect", 0);
20886 
20887     INDENT(-4);
20888     PRINT_SPACE
20889     if (commaNeeded)
20890         _OUT << "}," << std::endl;
20891     else
20892         _OUT << "}" << std::endl;
20893 }
20894 
print_VkImagePlaneMemoryRequirementsInfo(VkImagePlaneMemoryRequirementsInfo obj,const std::string & s,bool commaNeeded=true)20895 static void print_VkImagePlaneMemoryRequirementsInfo(VkImagePlaneMemoryRequirementsInfo obj, const std::string &s,
20896                                                      bool commaNeeded = true)
20897 {
20898     PRINT_SPACE
20899     _OUT << "{" << std::endl;
20900     INDENT(4);
20901 
20902     print_VkStructureType(obj.sType, "sType", 1);
20903 
20904     if (obj.pNext)
20905     {
20906         dumpPNextChain(obj.pNext);
20907     }
20908     else
20909     {
20910         PRINT_SPACE
20911         _OUT << "\"pNext\":"
20912              << "\"NULL\""
20913              << "," << std::endl;
20914     }
20915 
20916     print_VkImageAspectFlagBits(obj.planeAspect, "planeAspect", 0);
20917 
20918     INDENT(-4);
20919     PRINT_SPACE
20920     if (commaNeeded)
20921         _OUT << "}," << std::endl;
20922     else
20923         _OUT << "}" << std::endl;
20924 }
print_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo * obj,const std::string & s,bool commaNeeded=true)20925 static void print_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo *obj,
20926                                                      const std::string &s, bool commaNeeded = true)
20927 {
20928     PRINT_SPACE
20929     _OUT << "{" << std::endl;
20930     INDENT(4);
20931 
20932     print_VkStructureType(obj->sType, "sType", 1);
20933 
20934     if (obj->pNext)
20935     {
20936         dumpPNextChain(obj->pNext);
20937     }
20938     else
20939     {
20940         PRINT_SPACE
20941         _OUT << "\"pNext\":"
20942              << "\"NULL\""
20943              << "," << std::endl;
20944     }
20945 
20946     print_VkImageAspectFlagBits(obj->planeAspect, "planeAspect", 0);
20947 
20948     INDENT(-4);
20949     PRINT_SPACE
20950     if (commaNeeded)
20951         _OUT << "}," << std::endl;
20952     else
20953         _OUT << "}" << std::endl;
20954 }
20955 
print_VkPhysicalDeviceSamplerYcbcrConversionFeatures(VkPhysicalDeviceSamplerYcbcrConversionFeatures obj,const std::string & s,bool commaNeeded=true)20956 static void print_VkPhysicalDeviceSamplerYcbcrConversionFeatures(VkPhysicalDeviceSamplerYcbcrConversionFeatures obj,
20957                                                                  const std::string &s, bool commaNeeded = true)
20958 {
20959     PRINT_SPACE
20960     _OUT << "{" << std::endl;
20961     INDENT(4);
20962 
20963     print_VkStructureType(obj.sType, "sType", 1);
20964 
20965     if (obj.pNext)
20966     {
20967         dumpPNextChain(obj.pNext);
20968     }
20969     else
20970     {
20971         PRINT_SPACE
20972         _OUT << "\"pNext\":"
20973              << "\"NULL\""
20974              << "," << std::endl;
20975     }
20976 
20977     print_VkBool32(obj.samplerYcbcrConversion, "samplerYcbcrConversion", 0);
20978 
20979     INDENT(-4);
20980     PRINT_SPACE
20981     if (commaNeeded)
20982         _OUT << "}," << std::endl;
20983     else
20984         _OUT << "}" << std::endl;
20985 }
print_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * obj,const std::string & s,bool commaNeeded=true)20986 static void print_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
20987     const VkPhysicalDeviceSamplerYcbcrConversionFeatures *obj, const std::string &s, bool commaNeeded = true)
20988 {
20989     PRINT_SPACE
20990     _OUT << "{" << std::endl;
20991     INDENT(4);
20992 
20993     print_VkStructureType(obj->sType, "sType", 1);
20994 
20995     if (obj->pNext)
20996     {
20997         dumpPNextChain(obj->pNext);
20998     }
20999     else
21000     {
21001         PRINT_SPACE
21002         _OUT << "\"pNext\":"
21003              << "\"NULL\""
21004              << "," << std::endl;
21005     }
21006 
21007     print_VkBool32(obj->samplerYcbcrConversion, "samplerYcbcrConversion", 0);
21008 
21009     INDENT(-4);
21010     PRINT_SPACE
21011     if (commaNeeded)
21012         _OUT << "}," << std::endl;
21013     else
21014         _OUT << "}" << std::endl;
21015 }
21016 
print_VkSamplerYcbcrConversionImageFormatProperties(VkSamplerYcbcrConversionImageFormatProperties obj,const std::string & s,bool commaNeeded=true)21017 static void print_VkSamplerYcbcrConversionImageFormatProperties(VkSamplerYcbcrConversionImageFormatProperties obj,
21018                                                                 const std::string &s, bool commaNeeded = true)
21019 {
21020     PRINT_SPACE
21021     _OUT << "{" << std::endl;
21022     INDENT(4);
21023 
21024     print_VkStructureType(obj.sType, "sType", 1);
21025 
21026     if (obj.pNext)
21027     {
21028         dumpPNextChain(obj.pNext);
21029     }
21030     else
21031     {
21032         PRINT_SPACE
21033         _OUT << "\"pNext\":"
21034              << "\"NULL\""
21035              << "," << std::endl;
21036     }
21037 
21038     print_uint32_t(obj.combinedImageSamplerDescriptorCount, "combinedImageSamplerDescriptorCount", 0);
21039 
21040     INDENT(-4);
21041     PRINT_SPACE
21042     if (commaNeeded)
21043         _OUT << "}," << std::endl;
21044     else
21045         _OUT << "}" << std::endl;
21046 }
print_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties * obj,const std::string & s,bool commaNeeded=true)21047 static void print_VkSamplerYcbcrConversionImageFormatProperties(
21048     const VkSamplerYcbcrConversionImageFormatProperties *obj, const std::string &s, bool commaNeeded = true)
21049 {
21050     PRINT_SPACE
21051     _OUT << "{" << std::endl;
21052     INDENT(4);
21053 
21054     print_VkStructureType(obj->sType, "sType", 1);
21055 
21056     if (obj->pNext)
21057     {
21058         dumpPNextChain(obj->pNext);
21059     }
21060     else
21061     {
21062         PRINT_SPACE
21063         _OUT << "\"pNext\":"
21064              << "\"NULL\""
21065              << "," << std::endl;
21066     }
21067 
21068     print_uint32_t(obj->combinedImageSamplerDescriptorCount, "combinedImageSamplerDescriptorCount", 0);
21069 
21070     INDENT(-4);
21071     PRINT_SPACE
21072     if (commaNeeded)
21073         _OUT << "}," << std::endl;
21074     else
21075         _OUT << "}" << std::endl;
21076 }
21077 
print_VkExternalMemoryProperties(VkExternalMemoryProperties obj,const std::string & s,bool commaNeeded=true)21078 static void print_VkExternalMemoryProperties(VkExternalMemoryProperties obj, const std::string &s,
21079                                              bool commaNeeded = true)
21080 {
21081     PRINT_SPACE
21082     _OUT << "{" << std::endl;
21083     INDENT(4);
21084 
21085     print_VkExternalMemoryFeatureFlags(obj.externalMemoryFeatures, "externalMemoryFeatures", 1);
21086 
21087     print_VkExternalMemoryHandleTypeFlags(obj.exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1);
21088 
21089     print_VkExternalMemoryHandleTypeFlags(obj.compatibleHandleTypes, "compatibleHandleTypes", 0);
21090 
21091     INDENT(-4);
21092     PRINT_SPACE
21093     if (commaNeeded)
21094         _OUT << "}," << std::endl;
21095     else
21096         _OUT << "}" << std::endl;
21097 }
print_VkExternalMemoryProperties(const VkExternalMemoryProperties * obj,const std::string & s,bool commaNeeded=true)21098 static void print_VkExternalMemoryProperties(const VkExternalMemoryProperties *obj, const std::string &s,
21099                                              bool commaNeeded = true)
21100 {
21101     PRINT_SPACE
21102     _OUT << "{" << std::endl;
21103     INDENT(4);
21104 
21105     print_VkExternalMemoryFeatureFlags(obj->externalMemoryFeatures, "externalMemoryFeatures", 1);
21106 
21107     print_VkExternalMemoryHandleTypeFlags(obj->exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1);
21108 
21109     print_VkExternalMemoryHandleTypeFlags(obj->compatibleHandleTypes, "compatibleHandleTypes", 0);
21110 
21111     INDENT(-4);
21112     PRINT_SPACE
21113     if (commaNeeded)
21114         _OUT << "}," << std::endl;
21115     else
21116         _OUT << "}" << std::endl;
21117 }
21118 
print_VkPhysicalDeviceExternalImageFormatInfo(VkPhysicalDeviceExternalImageFormatInfo obj,const std::string & s,bool commaNeeded=true)21119 static void print_VkPhysicalDeviceExternalImageFormatInfo(VkPhysicalDeviceExternalImageFormatInfo obj,
21120                                                           const std::string &s, bool commaNeeded = true)
21121 {
21122     PRINT_SPACE
21123     _OUT << "{" << std::endl;
21124     INDENT(4);
21125 
21126     print_VkStructureType(obj.sType, "sType", 1);
21127 
21128     if (obj.pNext)
21129     {
21130         dumpPNextChain(obj.pNext);
21131     }
21132     else
21133     {
21134         PRINT_SPACE
21135         _OUT << "\"pNext\":"
21136              << "\"NULL\""
21137              << "," << std::endl;
21138     }
21139 
21140     print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 0);
21141 
21142     INDENT(-4);
21143     PRINT_SPACE
21144     if (commaNeeded)
21145         _OUT << "}," << std::endl;
21146     else
21147         _OUT << "}" << std::endl;
21148 }
print_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo * obj,const std::string & s,bool commaNeeded=true)21149 static void print_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo *obj,
21150                                                           const std::string &s, bool commaNeeded = true)
21151 {
21152     PRINT_SPACE
21153     _OUT << "{" << std::endl;
21154     INDENT(4);
21155 
21156     print_VkStructureType(obj->sType, "sType", 1);
21157 
21158     if (obj->pNext)
21159     {
21160         dumpPNextChain(obj->pNext);
21161     }
21162     else
21163     {
21164         PRINT_SPACE
21165         _OUT << "\"pNext\":"
21166              << "\"NULL\""
21167              << "," << std::endl;
21168     }
21169 
21170     print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 0);
21171 
21172     INDENT(-4);
21173     PRINT_SPACE
21174     if (commaNeeded)
21175         _OUT << "}," << std::endl;
21176     else
21177         _OUT << "}" << std::endl;
21178 }
21179 
print_VkExternalImageFormatProperties(VkExternalImageFormatProperties obj,const std::string & s,bool commaNeeded=true)21180 static void print_VkExternalImageFormatProperties(VkExternalImageFormatProperties obj, const std::string &s,
21181                                                   bool commaNeeded = true)
21182 {
21183     PRINT_SPACE
21184     _OUT << "{" << std::endl;
21185     INDENT(4);
21186 
21187     print_VkStructureType(obj.sType, "sType", 1);
21188 
21189     if (obj.pNext)
21190     {
21191         dumpPNextChain(obj.pNext);
21192     }
21193     else
21194     {
21195         PRINT_SPACE
21196         _OUT << "\"pNext\":"
21197              << "\"NULL\""
21198              << "," << std::endl;
21199     }
21200 
21201     PRINT_SPACE
21202     _OUT << "\"externalMemoryProperties\": " << std::endl;
21203     {
21204         print_VkExternalMemoryProperties(obj.externalMemoryProperties, "externalMemoryProperties", 0);
21205     }
21206 
21207     INDENT(-4);
21208     PRINT_SPACE
21209     if (commaNeeded)
21210         _OUT << "}," << std::endl;
21211     else
21212         _OUT << "}" << std::endl;
21213 }
print_VkExternalImageFormatProperties(const VkExternalImageFormatProperties * obj,const std::string & s,bool commaNeeded=true)21214 static void print_VkExternalImageFormatProperties(const VkExternalImageFormatProperties *obj, const std::string &s,
21215                                                   bool commaNeeded = true)
21216 {
21217     PRINT_SPACE
21218     _OUT << "{" << std::endl;
21219     INDENT(4);
21220 
21221     print_VkStructureType(obj->sType, "sType", 1);
21222 
21223     if (obj->pNext)
21224     {
21225         dumpPNextChain(obj->pNext);
21226     }
21227     else
21228     {
21229         PRINT_SPACE
21230         _OUT << "\"pNext\":"
21231              << "\"NULL\""
21232              << "," << std::endl;
21233     }
21234 
21235     PRINT_SPACE
21236     _OUT << "\"externalMemoryProperties\": " << std::endl;
21237     {
21238         print_VkExternalMemoryProperties(obj->externalMemoryProperties, "externalMemoryProperties", 0);
21239     }
21240 
21241     INDENT(-4);
21242     PRINT_SPACE
21243     if (commaNeeded)
21244         _OUT << "}," << std::endl;
21245     else
21246         _OUT << "}" << std::endl;
21247 }
21248 
print_VkPhysicalDeviceExternalBufferInfo(VkPhysicalDeviceExternalBufferInfo obj,const std::string & s,bool commaNeeded=true)21249 static void print_VkPhysicalDeviceExternalBufferInfo(VkPhysicalDeviceExternalBufferInfo obj, const std::string &s,
21250                                                      bool commaNeeded = true)
21251 {
21252     PRINT_SPACE
21253     _OUT << "{" << std::endl;
21254     INDENT(4);
21255 
21256     print_VkStructureType(obj.sType, "sType", 1);
21257 
21258     if (obj.pNext)
21259     {
21260         dumpPNextChain(obj.pNext);
21261     }
21262     else
21263     {
21264         PRINT_SPACE
21265         _OUT << "\"pNext\":"
21266              << "\"NULL\""
21267              << "," << std::endl;
21268     }
21269 
21270     print_VkBufferCreateFlags(obj.flags, "flags", 1);
21271 
21272     print_VkBufferUsageFlags(obj.usage, "usage", 1);
21273 
21274     print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 0);
21275 
21276     INDENT(-4);
21277     PRINT_SPACE
21278     if (commaNeeded)
21279         _OUT << "}," << std::endl;
21280     else
21281         _OUT << "}" << std::endl;
21282 }
print_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo * obj,const std::string & s,bool commaNeeded=true)21283 static void print_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo *obj,
21284                                                      const std::string &s, bool commaNeeded = true)
21285 {
21286     PRINT_SPACE
21287     _OUT << "{" << std::endl;
21288     INDENT(4);
21289 
21290     print_VkStructureType(obj->sType, "sType", 1);
21291 
21292     if (obj->pNext)
21293     {
21294         dumpPNextChain(obj->pNext);
21295     }
21296     else
21297     {
21298         PRINT_SPACE
21299         _OUT << "\"pNext\":"
21300              << "\"NULL\""
21301              << "," << std::endl;
21302     }
21303 
21304     print_VkBufferCreateFlags(obj->flags, "flags", 1);
21305 
21306     print_VkBufferUsageFlags(obj->usage, "usage", 1);
21307 
21308     print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 0);
21309 
21310     INDENT(-4);
21311     PRINT_SPACE
21312     if (commaNeeded)
21313         _OUT << "}," << std::endl;
21314     else
21315         _OUT << "}" << std::endl;
21316 }
21317 
print_VkExternalBufferProperties(VkExternalBufferProperties obj,const std::string & s,bool commaNeeded=true)21318 static void print_VkExternalBufferProperties(VkExternalBufferProperties obj, const std::string &s,
21319                                              bool commaNeeded = true)
21320 {
21321     PRINT_SPACE
21322     _OUT << "{" << std::endl;
21323     INDENT(4);
21324 
21325     print_VkStructureType(obj.sType, "sType", 1);
21326 
21327     if (obj.pNext)
21328     {
21329         dumpPNextChain(obj.pNext);
21330     }
21331     else
21332     {
21333         PRINT_SPACE
21334         _OUT << "\"pNext\":"
21335              << "\"NULL\""
21336              << "," << std::endl;
21337     }
21338 
21339     PRINT_SPACE
21340     _OUT << "\"externalMemoryProperties\": " << std::endl;
21341     {
21342         print_VkExternalMemoryProperties(obj.externalMemoryProperties, "externalMemoryProperties", 0);
21343     }
21344 
21345     INDENT(-4);
21346     PRINT_SPACE
21347     if (commaNeeded)
21348         _OUT << "}," << std::endl;
21349     else
21350         _OUT << "}" << std::endl;
21351 }
print_VkExternalBufferProperties(const VkExternalBufferProperties * obj,const std::string & s,bool commaNeeded=true)21352 static void print_VkExternalBufferProperties(const VkExternalBufferProperties *obj, const std::string &s,
21353                                              bool commaNeeded = true)
21354 {
21355     PRINT_SPACE
21356     _OUT << "{" << std::endl;
21357     INDENT(4);
21358 
21359     print_VkStructureType(obj->sType, "sType", 1);
21360 
21361     if (obj->pNext)
21362     {
21363         dumpPNextChain(obj->pNext);
21364     }
21365     else
21366     {
21367         PRINT_SPACE
21368         _OUT << "\"pNext\":"
21369              << "\"NULL\""
21370              << "," << std::endl;
21371     }
21372 
21373     PRINT_SPACE
21374     _OUT << "\"externalMemoryProperties\": " << std::endl;
21375     {
21376         print_VkExternalMemoryProperties(obj->externalMemoryProperties, "externalMemoryProperties", 0);
21377     }
21378 
21379     INDENT(-4);
21380     PRINT_SPACE
21381     if (commaNeeded)
21382         _OUT << "}," << std::endl;
21383     else
21384         _OUT << "}" << std::endl;
21385 }
21386 
print_VkPhysicalDeviceIDProperties(VkPhysicalDeviceIDProperties obj,const std::string & s,bool commaNeeded=true)21387 static void print_VkPhysicalDeviceIDProperties(VkPhysicalDeviceIDProperties obj, const std::string &s,
21388                                                bool commaNeeded = true)
21389 {
21390     PRINT_SPACE
21391     _OUT << "{" << std::endl;
21392     INDENT(4);
21393 
21394     print_VkStructureType(obj.sType, "sType", 1);
21395 
21396     if (obj.pNext)
21397     {
21398         dumpPNextChain(obj.pNext);
21399     }
21400     else
21401     {
21402         PRINT_SPACE
21403         _OUT << "\"pNext\":"
21404              << "\"NULL\""
21405              << "," << std::endl;
21406     }
21407 
21408     PRINT_SPACE
21409     _OUT << "\"deviceUUID\":" << std::endl;
21410     PRINT_SPACE
21411     _OUT << "[" << std::endl;
21412     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
21413     {
21414         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
21415         print_uint8_t(obj.deviceUUID[i], "", isCommaNeeded);
21416     }
21417     PRINT_SPACE
21418     _OUT << "]"
21419          << "," << std::endl;
21420 
21421     PRINT_SPACE
21422     _OUT << "\"driverUUID\":" << std::endl;
21423     PRINT_SPACE
21424     _OUT << "[" << std::endl;
21425     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
21426     {
21427         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
21428         print_uint8_t(obj.driverUUID[i], "", isCommaNeeded);
21429     }
21430     PRINT_SPACE
21431     _OUT << "]"
21432          << "," << std::endl;
21433 
21434     PRINT_SPACE
21435     _OUT << "\"deviceLUID\":" << std::endl;
21436     PRINT_SPACE
21437     _OUT << "[" << std::endl;
21438     for (unsigned int i = 0; i < VK_LUID_SIZE; i++)
21439     {
21440         bool isCommaNeeded = (i + 1) != VK_LUID_SIZE;
21441         print_uint8_t(obj.deviceLUID[i], "", isCommaNeeded);
21442     }
21443     PRINT_SPACE
21444     _OUT << "]"
21445          << "," << std::endl;
21446 
21447     print_uint32_t(obj.deviceNodeMask, "deviceNodeMask", 1);
21448 
21449     print_VkBool32(obj.deviceLUIDValid, "deviceLUIDValid", 0);
21450 
21451     INDENT(-4);
21452     PRINT_SPACE
21453     if (commaNeeded)
21454         _OUT << "}," << std::endl;
21455     else
21456         _OUT << "}" << std::endl;
21457 }
print_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties * obj,const std::string & s,bool commaNeeded=true)21458 static void print_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties *obj, const std::string &s,
21459                                                bool commaNeeded = true)
21460 {
21461     PRINT_SPACE
21462     _OUT << "{" << std::endl;
21463     INDENT(4);
21464 
21465     print_VkStructureType(obj->sType, "sType", 1);
21466 
21467     if (obj->pNext)
21468     {
21469         dumpPNextChain(obj->pNext);
21470     }
21471     else
21472     {
21473         PRINT_SPACE
21474         _OUT << "\"pNext\":"
21475              << "\"NULL\""
21476              << "," << std::endl;
21477     }
21478 
21479     PRINT_SPACE
21480     _OUT << "\"deviceUUID\":" << std::endl;
21481     PRINT_SPACE
21482     _OUT << "[" << std::endl;
21483     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
21484     {
21485         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
21486         print_uint8_t(obj->deviceUUID[i], "", isCommaNeeded);
21487     }
21488     PRINT_SPACE
21489     _OUT << "]"
21490          << "," << std::endl;
21491 
21492     PRINT_SPACE
21493     _OUT << "\"driverUUID\":" << std::endl;
21494     PRINT_SPACE
21495     _OUT << "[" << std::endl;
21496     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
21497     {
21498         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
21499         print_uint8_t(obj->driverUUID[i], "", isCommaNeeded);
21500     }
21501     PRINT_SPACE
21502     _OUT << "]"
21503          << "," << std::endl;
21504 
21505     PRINT_SPACE
21506     _OUT << "\"deviceLUID\":" << std::endl;
21507     PRINT_SPACE
21508     _OUT << "[" << std::endl;
21509     for (unsigned int i = 0; i < VK_LUID_SIZE; i++)
21510     {
21511         bool isCommaNeeded = (i + 1) != VK_LUID_SIZE;
21512         print_uint8_t(obj->deviceLUID[i], "", isCommaNeeded);
21513     }
21514     PRINT_SPACE
21515     _OUT << "]"
21516          << "," << std::endl;
21517 
21518     print_uint32_t(obj->deviceNodeMask, "deviceNodeMask", 1);
21519 
21520     print_VkBool32(obj->deviceLUIDValid, "deviceLUIDValid", 0);
21521 
21522     INDENT(-4);
21523     PRINT_SPACE
21524     if (commaNeeded)
21525         _OUT << "}," << std::endl;
21526     else
21527         _OUT << "}" << std::endl;
21528 }
21529 
print_VkExternalMemoryImageCreateInfo(VkExternalMemoryImageCreateInfo obj,const std::string & s,bool commaNeeded=true)21530 static void print_VkExternalMemoryImageCreateInfo(VkExternalMemoryImageCreateInfo obj, const std::string &s,
21531                                                   bool commaNeeded = true)
21532 {
21533     PRINT_SPACE
21534     _OUT << "{" << std::endl;
21535     INDENT(4);
21536 
21537     print_VkStructureType(obj.sType, "sType", 1);
21538 
21539     if (obj.pNext)
21540     {
21541         dumpPNextChain(obj.pNext);
21542     }
21543     else
21544     {
21545         PRINT_SPACE
21546         _OUT << "\"pNext\":"
21547              << "\"NULL\""
21548              << "," << std::endl;
21549     }
21550 
21551     print_VkExternalMemoryHandleTypeFlags(obj.handleTypes, "handleTypes", 0);
21552 
21553     INDENT(-4);
21554     PRINT_SPACE
21555     if (commaNeeded)
21556         _OUT << "}," << std::endl;
21557     else
21558         _OUT << "}" << std::endl;
21559 }
print_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo * obj,const std::string & s,bool commaNeeded=true)21560 static void print_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo *obj, const std::string &s,
21561                                                   bool commaNeeded = true)
21562 {
21563     PRINT_SPACE
21564     _OUT << "{" << std::endl;
21565     INDENT(4);
21566 
21567     print_VkStructureType(obj->sType, "sType", 1);
21568 
21569     if (obj->pNext)
21570     {
21571         dumpPNextChain(obj->pNext);
21572     }
21573     else
21574     {
21575         PRINT_SPACE
21576         _OUT << "\"pNext\":"
21577              << "\"NULL\""
21578              << "," << std::endl;
21579     }
21580 
21581     print_VkExternalMemoryHandleTypeFlags(obj->handleTypes, "handleTypes", 0);
21582 
21583     INDENT(-4);
21584     PRINT_SPACE
21585     if (commaNeeded)
21586         _OUT << "}," << std::endl;
21587     else
21588         _OUT << "}" << std::endl;
21589 }
21590 
print_VkExternalMemoryBufferCreateInfo(VkExternalMemoryBufferCreateInfo obj,const std::string & s,bool commaNeeded=true)21591 static void print_VkExternalMemoryBufferCreateInfo(VkExternalMemoryBufferCreateInfo obj, const std::string &s,
21592                                                    bool commaNeeded = true)
21593 {
21594     PRINT_SPACE
21595     _OUT << "{" << std::endl;
21596     INDENT(4);
21597 
21598     print_VkStructureType(obj.sType, "sType", 1);
21599 
21600     if (obj.pNext)
21601     {
21602         dumpPNextChain(obj.pNext);
21603     }
21604     else
21605     {
21606         PRINT_SPACE
21607         _OUT << "\"pNext\":"
21608              << "\"NULL\""
21609              << "," << std::endl;
21610     }
21611 
21612     print_VkExternalMemoryHandleTypeFlags(obj.handleTypes, "handleTypes", 0);
21613 
21614     INDENT(-4);
21615     PRINT_SPACE
21616     if (commaNeeded)
21617         _OUT << "}," << std::endl;
21618     else
21619         _OUT << "}" << std::endl;
21620 }
print_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo * obj,const std::string & s,bool commaNeeded=true)21621 static void print_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo *obj, const std::string &s,
21622                                                    bool commaNeeded = true)
21623 {
21624     PRINT_SPACE
21625     _OUT << "{" << std::endl;
21626     INDENT(4);
21627 
21628     print_VkStructureType(obj->sType, "sType", 1);
21629 
21630     if (obj->pNext)
21631     {
21632         dumpPNextChain(obj->pNext);
21633     }
21634     else
21635     {
21636         PRINT_SPACE
21637         _OUT << "\"pNext\":"
21638              << "\"NULL\""
21639              << "," << std::endl;
21640     }
21641 
21642     print_VkExternalMemoryHandleTypeFlags(obj->handleTypes, "handleTypes", 0);
21643 
21644     INDENT(-4);
21645     PRINT_SPACE
21646     if (commaNeeded)
21647         _OUT << "}," << std::endl;
21648     else
21649         _OUT << "}" << std::endl;
21650 }
21651 
print_VkExportMemoryAllocateInfo(VkExportMemoryAllocateInfo obj,const std::string & s,bool commaNeeded=true)21652 static void print_VkExportMemoryAllocateInfo(VkExportMemoryAllocateInfo obj, const std::string &s,
21653                                              bool commaNeeded = true)
21654 {
21655     PRINT_SPACE
21656     _OUT << "{" << std::endl;
21657     INDENT(4);
21658 
21659     print_VkStructureType(obj.sType, "sType", 1);
21660 
21661     if (obj.pNext)
21662     {
21663         dumpPNextChain(obj.pNext);
21664     }
21665     else
21666     {
21667         PRINT_SPACE
21668         _OUT << "\"pNext\":"
21669              << "\"NULL\""
21670              << "," << std::endl;
21671     }
21672 
21673     print_VkExternalMemoryHandleTypeFlags(obj.handleTypes, "handleTypes", 0);
21674 
21675     INDENT(-4);
21676     PRINT_SPACE
21677     if (commaNeeded)
21678         _OUT << "}," << std::endl;
21679     else
21680         _OUT << "}" << std::endl;
21681 }
print_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo * obj,const std::string & s,bool commaNeeded=true)21682 static void print_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo *obj, const std::string &s,
21683                                              bool commaNeeded = true)
21684 {
21685     PRINT_SPACE
21686     _OUT << "{" << std::endl;
21687     INDENT(4);
21688 
21689     print_VkStructureType(obj->sType, "sType", 1);
21690 
21691     if (obj->pNext)
21692     {
21693         dumpPNextChain(obj->pNext);
21694     }
21695     else
21696     {
21697         PRINT_SPACE
21698         _OUT << "\"pNext\":"
21699              << "\"NULL\""
21700              << "," << std::endl;
21701     }
21702 
21703     print_VkExternalMemoryHandleTypeFlags(obj->handleTypes, "handleTypes", 0);
21704 
21705     INDENT(-4);
21706     PRINT_SPACE
21707     if (commaNeeded)
21708         _OUT << "}," << std::endl;
21709     else
21710         _OUT << "}" << std::endl;
21711 }
21712 
print_VkPhysicalDeviceExternalFenceInfo(VkPhysicalDeviceExternalFenceInfo obj,const std::string & s,bool commaNeeded=true)21713 static void print_VkPhysicalDeviceExternalFenceInfo(VkPhysicalDeviceExternalFenceInfo obj, const std::string &s,
21714                                                     bool commaNeeded = true)
21715 {
21716     PRINT_SPACE
21717     _OUT << "{" << std::endl;
21718     INDENT(4);
21719 
21720     print_VkStructureType(obj.sType, "sType", 1);
21721 
21722     if (obj.pNext)
21723     {
21724         dumpPNextChain(obj.pNext);
21725     }
21726     else
21727     {
21728         PRINT_SPACE
21729         _OUT << "\"pNext\":"
21730              << "\"NULL\""
21731              << "," << std::endl;
21732     }
21733 
21734     print_VkExternalFenceHandleTypeFlagBits(obj.handleType, "handleType", 0);
21735 
21736     INDENT(-4);
21737     PRINT_SPACE
21738     if (commaNeeded)
21739         _OUT << "}," << std::endl;
21740     else
21741         _OUT << "}" << std::endl;
21742 }
print_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo * obj,const std::string & s,bool commaNeeded=true)21743 static void print_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo *obj, const std::string &s,
21744                                                     bool commaNeeded = true)
21745 {
21746     PRINT_SPACE
21747     _OUT << "{" << std::endl;
21748     INDENT(4);
21749 
21750     print_VkStructureType(obj->sType, "sType", 1);
21751 
21752     if (obj->pNext)
21753     {
21754         dumpPNextChain(obj->pNext);
21755     }
21756     else
21757     {
21758         PRINT_SPACE
21759         _OUT << "\"pNext\":"
21760              << "\"NULL\""
21761              << "," << std::endl;
21762     }
21763 
21764     print_VkExternalFenceHandleTypeFlagBits(obj->handleType, "handleType", 0);
21765 
21766     INDENT(-4);
21767     PRINT_SPACE
21768     if (commaNeeded)
21769         _OUT << "}," << std::endl;
21770     else
21771         _OUT << "}" << std::endl;
21772 }
21773 
print_VkExternalFenceProperties(VkExternalFenceProperties obj,const std::string & s,bool commaNeeded=true)21774 static void print_VkExternalFenceProperties(VkExternalFenceProperties obj, const std::string &s,
21775                                             bool commaNeeded = true)
21776 {
21777     PRINT_SPACE
21778     _OUT << "{" << std::endl;
21779     INDENT(4);
21780 
21781     print_VkStructureType(obj.sType, "sType", 1);
21782 
21783     if (obj.pNext)
21784     {
21785         dumpPNextChain(obj.pNext);
21786     }
21787     else
21788     {
21789         PRINT_SPACE
21790         _OUT << "\"pNext\":"
21791              << "\"NULL\""
21792              << "," << std::endl;
21793     }
21794 
21795     print_VkExternalFenceHandleTypeFlags(obj.exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1);
21796 
21797     print_VkExternalFenceHandleTypeFlags(obj.compatibleHandleTypes, "compatibleHandleTypes", 1);
21798 
21799     print_VkExternalFenceFeatureFlags(obj.externalFenceFeatures, "externalFenceFeatures", 0);
21800 
21801     INDENT(-4);
21802     PRINT_SPACE
21803     if (commaNeeded)
21804         _OUT << "}," << std::endl;
21805     else
21806         _OUT << "}" << std::endl;
21807 }
print_VkExternalFenceProperties(const VkExternalFenceProperties * obj,const std::string & s,bool commaNeeded=true)21808 static void print_VkExternalFenceProperties(const VkExternalFenceProperties *obj, const std::string &s,
21809                                             bool commaNeeded = true)
21810 {
21811     PRINT_SPACE
21812     _OUT << "{" << std::endl;
21813     INDENT(4);
21814 
21815     print_VkStructureType(obj->sType, "sType", 1);
21816 
21817     if (obj->pNext)
21818     {
21819         dumpPNextChain(obj->pNext);
21820     }
21821     else
21822     {
21823         PRINT_SPACE
21824         _OUT << "\"pNext\":"
21825              << "\"NULL\""
21826              << "," << std::endl;
21827     }
21828 
21829     print_VkExternalFenceHandleTypeFlags(obj->exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1);
21830 
21831     print_VkExternalFenceHandleTypeFlags(obj->compatibleHandleTypes, "compatibleHandleTypes", 1);
21832 
21833     print_VkExternalFenceFeatureFlags(obj->externalFenceFeatures, "externalFenceFeatures", 0);
21834 
21835     INDENT(-4);
21836     PRINT_SPACE
21837     if (commaNeeded)
21838         _OUT << "}," << std::endl;
21839     else
21840         _OUT << "}" << std::endl;
21841 }
21842 
print_VkExportFenceCreateInfo(VkExportFenceCreateInfo obj,const std::string & s,bool commaNeeded=true)21843 static void print_VkExportFenceCreateInfo(VkExportFenceCreateInfo obj, const std::string &s, bool commaNeeded = true)
21844 {
21845     PRINT_SPACE
21846     _OUT << "{" << std::endl;
21847     INDENT(4);
21848 
21849     print_VkStructureType(obj.sType, "sType", 1);
21850 
21851     if (obj.pNext)
21852     {
21853         dumpPNextChain(obj.pNext);
21854     }
21855     else
21856     {
21857         PRINT_SPACE
21858         _OUT << "\"pNext\":"
21859              << "\"NULL\""
21860              << "," << std::endl;
21861     }
21862 
21863     print_VkExternalFenceHandleTypeFlags(obj.handleTypes, "handleTypes", 0);
21864 
21865     INDENT(-4);
21866     PRINT_SPACE
21867     if (commaNeeded)
21868         _OUT << "}," << std::endl;
21869     else
21870         _OUT << "}" << std::endl;
21871 }
print_VkExportFenceCreateInfo(const VkExportFenceCreateInfo * obj,const std::string & s,bool commaNeeded=true)21872 static void print_VkExportFenceCreateInfo(const VkExportFenceCreateInfo *obj, const std::string &s,
21873                                           bool commaNeeded = true)
21874 {
21875     PRINT_SPACE
21876     _OUT << "{" << std::endl;
21877     INDENT(4);
21878 
21879     print_VkStructureType(obj->sType, "sType", 1);
21880 
21881     if (obj->pNext)
21882     {
21883         dumpPNextChain(obj->pNext);
21884     }
21885     else
21886     {
21887         PRINT_SPACE
21888         _OUT << "\"pNext\":"
21889              << "\"NULL\""
21890              << "," << std::endl;
21891     }
21892 
21893     print_VkExternalFenceHandleTypeFlags(obj->handleTypes, "handleTypes", 0);
21894 
21895     INDENT(-4);
21896     PRINT_SPACE
21897     if (commaNeeded)
21898         _OUT << "}," << std::endl;
21899     else
21900         _OUT << "}" << std::endl;
21901 }
21902 
print_VkExportSemaphoreCreateInfo(VkExportSemaphoreCreateInfo obj,const std::string & s,bool commaNeeded=true)21903 static void print_VkExportSemaphoreCreateInfo(VkExportSemaphoreCreateInfo obj, const std::string &s,
21904                                               bool commaNeeded = true)
21905 {
21906     PRINT_SPACE
21907     _OUT << "{" << std::endl;
21908     INDENT(4);
21909 
21910     print_VkStructureType(obj.sType, "sType", 1);
21911 
21912     if (obj.pNext)
21913     {
21914         dumpPNextChain(obj.pNext);
21915     }
21916     else
21917     {
21918         PRINT_SPACE
21919         _OUT << "\"pNext\":"
21920              << "\"NULL\""
21921              << "," << std::endl;
21922     }
21923 
21924     print_VkExternalSemaphoreHandleTypeFlags(obj.handleTypes, "handleTypes", 0);
21925 
21926     INDENT(-4);
21927     PRINT_SPACE
21928     if (commaNeeded)
21929         _OUT << "}," << std::endl;
21930     else
21931         _OUT << "}" << std::endl;
21932 }
print_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo * obj,const std::string & s,bool commaNeeded=true)21933 static void print_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo *obj, const std::string &s,
21934                                               bool commaNeeded = true)
21935 {
21936     PRINT_SPACE
21937     _OUT << "{" << std::endl;
21938     INDENT(4);
21939 
21940     print_VkStructureType(obj->sType, "sType", 1);
21941 
21942     if (obj->pNext)
21943     {
21944         dumpPNextChain(obj->pNext);
21945     }
21946     else
21947     {
21948         PRINT_SPACE
21949         _OUT << "\"pNext\":"
21950              << "\"NULL\""
21951              << "," << std::endl;
21952     }
21953 
21954     print_VkExternalSemaphoreHandleTypeFlags(obj->handleTypes, "handleTypes", 0);
21955 
21956     INDENT(-4);
21957     PRINT_SPACE
21958     if (commaNeeded)
21959         _OUT << "}," << std::endl;
21960     else
21961         _OUT << "}" << std::endl;
21962 }
21963 
print_VkPhysicalDeviceExternalSemaphoreInfo(VkPhysicalDeviceExternalSemaphoreInfo obj,const std::string & s,bool commaNeeded=true)21964 static void print_VkPhysicalDeviceExternalSemaphoreInfo(VkPhysicalDeviceExternalSemaphoreInfo obj, const std::string &s,
21965                                                         bool commaNeeded = true)
21966 {
21967     PRINT_SPACE
21968     _OUT << "{" << std::endl;
21969     INDENT(4);
21970 
21971     print_VkStructureType(obj.sType, "sType", 1);
21972 
21973     if (obj.pNext)
21974     {
21975         dumpPNextChain(obj.pNext);
21976     }
21977     else
21978     {
21979         PRINT_SPACE
21980         _OUT << "\"pNext\":"
21981              << "\"NULL\""
21982              << "," << std::endl;
21983     }
21984 
21985     print_VkExternalSemaphoreHandleTypeFlagBits(obj.handleType, "handleType", 0);
21986 
21987     INDENT(-4);
21988     PRINT_SPACE
21989     if (commaNeeded)
21990         _OUT << "}," << std::endl;
21991     else
21992         _OUT << "}" << std::endl;
21993 }
print_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo * obj,const std::string & s,bool commaNeeded=true)21994 static void print_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo *obj,
21995                                                         const std::string &s, bool commaNeeded = true)
21996 {
21997     PRINT_SPACE
21998     _OUT << "{" << std::endl;
21999     INDENT(4);
22000 
22001     print_VkStructureType(obj->sType, "sType", 1);
22002 
22003     if (obj->pNext)
22004     {
22005         dumpPNextChain(obj->pNext);
22006     }
22007     else
22008     {
22009         PRINT_SPACE
22010         _OUT << "\"pNext\":"
22011              << "\"NULL\""
22012              << "," << std::endl;
22013     }
22014 
22015     print_VkExternalSemaphoreHandleTypeFlagBits(obj->handleType, "handleType", 0);
22016 
22017     INDENT(-4);
22018     PRINT_SPACE
22019     if (commaNeeded)
22020         _OUT << "}," << std::endl;
22021     else
22022         _OUT << "}" << std::endl;
22023 }
22024 
print_VkExternalSemaphoreProperties(VkExternalSemaphoreProperties obj,const std::string & s,bool commaNeeded=true)22025 static void print_VkExternalSemaphoreProperties(VkExternalSemaphoreProperties obj, const std::string &s,
22026                                                 bool commaNeeded = true)
22027 {
22028     PRINT_SPACE
22029     _OUT << "{" << std::endl;
22030     INDENT(4);
22031 
22032     print_VkStructureType(obj.sType, "sType", 1);
22033 
22034     if (obj.pNext)
22035     {
22036         dumpPNextChain(obj.pNext);
22037     }
22038     else
22039     {
22040         PRINT_SPACE
22041         _OUT << "\"pNext\":"
22042              << "\"NULL\""
22043              << "," << std::endl;
22044     }
22045 
22046     print_VkExternalSemaphoreHandleTypeFlags(obj.exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1);
22047 
22048     print_VkExternalSemaphoreHandleTypeFlags(obj.compatibleHandleTypes, "compatibleHandleTypes", 1);
22049 
22050     print_VkExternalSemaphoreFeatureFlags(obj.externalSemaphoreFeatures, "externalSemaphoreFeatures", 0);
22051 
22052     INDENT(-4);
22053     PRINT_SPACE
22054     if (commaNeeded)
22055         _OUT << "}," << std::endl;
22056     else
22057         _OUT << "}" << std::endl;
22058 }
print_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties * obj,const std::string & s,bool commaNeeded=true)22059 static void print_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties *obj, const std::string &s,
22060                                                 bool commaNeeded = true)
22061 {
22062     PRINT_SPACE
22063     _OUT << "{" << std::endl;
22064     INDENT(4);
22065 
22066     print_VkStructureType(obj->sType, "sType", 1);
22067 
22068     if (obj->pNext)
22069     {
22070         dumpPNextChain(obj->pNext);
22071     }
22072     else
22073     {
22074         PRINT_SPACE
22075         _OUT << "\"pNext\":"
22076              << "\"NULL\""
22077              << "," << std::endl;
22078     }
22079 
22080     print_VkExternalSemaphoreHandleTypeFlags(obj->exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1);
22081 
22082     print_VkExternalSemaphoreHandleTypeFlags(obj->compatibleHandleTypes, "compatibleHandleTypes", 1);
22083 
22084     print_VkExternalSemaphoreFeatureFlags(obj->externalSemaphoreFeatures, "externalSemaphoreFeatures", 0);
22085 
22086     INDENT(-4);
22087     PRINT_SPACE
22088     if (commaNeeded)
22089         _OUT << "}," << std::endl;
22090     else
22091         _OUT << "}" << std::endl;
22092 }
22093 
print_VkPhysicalDeviceMaintenance3Properties(VkPhysicalDeviceMaintenance3Properties obj,const std::string & s,bool commaNeeded=true)22094 static void print_VkPhysicalDeviceMaintenance3Properties(VkPhysicalDeviceMaintenance3Properties obj,
22095                                                          const std::string &s, bool commaNeeded = true)
22096 {
22097     PRINT_SPACE
22098     _OUT << "{" << std::endl;
22099     INDENT(4);
22100 
22101     print_VkStructureType(obj.sType, "sType", 1);
22102 
22103     if (obj.pNext)
22104     {
22105         dumpPNextChain(obj.pNext);
22106     }
22107     else
22108     {
22109         PRINT_SPACE
22110         _OUT << "\"pNext\":"
22111              << "\"NULL\""
22112              << "," << std::endl;
22113     }
22114 
22115     print_uint32_t(obj.maxPerSetDescriptors, "maxPerSetDescriptors", 1);
22116 
22117     print_VkDeviceSize(obj.maxMemoryAllocationSize, "maxMemoryAllocationSize", 0);
22118 
22119     INDENT(-4);
22120     PRINT_SPACE
22121     if (commaNeeded)
22122         _OUT << "}," << std::endl;
22123     else
22124         _OUT << "}" << std::endl;
22125 }
print_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties * obj,const std::string & s,bool commaNeeded=true)22126 static void print_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties *obj,
22127                                                          const std::string &s, bool commaNeeded = true)
22128 {
22129     PRINT_SPACE
22130     _OUT << "{" << std::endl;
22131     INDENT(4);
22132 
22133     print_VkStructureType(obj->sType, "sType", 1);
22134 
22135     if (obj->pNext)
22136     {
22137         dumpPNextChain(obj->pNext);
22138     }
22139     else
22140     {
22141         PRINT_SPACE
22142         _OUT << "\"pNext\":"
22143              << "\"NULL\""
22144              << "," << std::endl;
22145     }
22146 
22147     print_uint32_t(obj->maxPerSetDescriptors, "maxPerSetDescriptors", 1);
22148 
22149     print_VkDeviceSize(obj->maxMemoryAllocationSize, "maxMemoryAllocationSize", 0);
22150 
22151     INDENT(-4);
22152     PRINT_SPACE
22153     if (commaNeeded)
22154         _OUT << "}," << std::endl;
22155     else
22156         _OUT << "}" << std::endl;
22157 }
22158 
print_VkDescriptorSetLayoutSupport(VkDescriptorSetLayoutSupport obj,const std::string & s,bool commaNeeded=true)22159 static void print_VkDescriptorSetLayoutSupport(VkDescriptorSetLayoutSupport obj, const std::string &s,
22160                                                bool commaNeeded = true)
22161 {
22162     PRINT_SPACE
22163     _OUT << "{" << std::endl;
22164     INDENT(4);
22165 
22166     print_VkStructureType(obj.sType, "sType", 1);
22167 
22168     if (obj.pNext)
22169     {
22170         dumpPNextChain(obj.pNext);
22171     }
22172     else
22173     {
22174         PRINT_SPACE
22175         _OUT << "\"pNext\":"
22176              << "\"NULL\""
22177              << "," << std::endl;
22178     }
22179 
22180     print_VkBool32(obj.supported, "supported", 0);
22181 
22182     INDENT(-4);
22183     PRINT_SPACE
22184     if (commaNeeded)
22185         _OUT << "}," << std::endl;
22186     else
22187         _OUT << "}" << std::endl;
22188 }
print_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport * obj,const std::string & s,bool commaNeeded=true)22189 static void print_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport *obj, const std::string &s,
22190                                                bool commaNeeded = true)
22191 {
22192     PRINT_SPACE
22193     _OUT << "{" << std::endl;
22194     INDENT(4);
22195 
22196     print_VkStructureType(obj->sType, "sType", 1);
22197 
22198     if (obj->pNext)
22199     {
22200         dumpPNextChain(obj->pNext);
22201     }
22202     else
22203     {
22204         PRINT_SPACE
22205         _OUT << "\"pNext\":"
22206              << "\"NULL\""
22207              << "," << std::endl;
22208     }
22209 
22210     print_VkBool32(obj->supported, "supported", 0);
22211 
22212     INDENT(-4);
22213     PRINT_SPACE
22214     if (commaNeeded)
22215         _OUT << "}," << std::endl;
22216     else
22217         _OUT << "}" << std::endl;
22218 }
22219 
print_VkPhysicalDeviceShaderDrawParametersFeatures(VkPhysicalDeviceShaderDrawParametersFeatures obj,const std::string & s,bool commaNeeded=true)22220 static void print_VkPhysicalDeviceShaderDrawParametersFeatures(VkPhysicalDeviceShaderDrawParametersFeatures obj,
22221                                                                const std::string &s, bool commaNeeded = true)
22222 {
22223     PRINT_SPACE
22224     _OUT << "{" << std::endl;
22225     INDENT(4);
22226 
22227     print_VkStructureType(obj.sType, "sType", 1);
22228 
22229     if (obj.pNext)
22230     {
22231         dumpPNextChain(obj.pNext);
22232     }
22233     else
22234     {
22235         PRINT_SPACE
22236         _OUT << "\"pNext\":"
22237              << "\"NULL\""
22238              << "," << std::endl;
22239     }
22240 
22241     print_VkBool32(obj.shaderDrawParameters, "shaderDrawParameters", 0);
22242 
22243     INDENT(-4);
22244     PRINT_SPACE
22245     if (commaNeeded)
22246         _OUT << "}," << std::endl;
22247     else
22248         _OUT << "}" << std::endl;
22249 }
print_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures * obj,const std::string & s,bool commaNeeded=true)22250 static void print_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures *obj,
22251                                                                const std::string &s, bool commaNeeded = true)
22252 {
22253     PRINT_SPACE
22254     _OUT << "{" << std::endl;
22255     INDENT(4);
22256 
22257     print_VkStructureType(obj->sType, "sType", 1);
22258 
22259     if (obj->pNext)
22260     {
22261         dumpPNextChain(obj->pNext);
22262     }
22263     else
22264     {
22265         PRINT_SPACE
22266         _OUT << "\"pNext\":"
22267              << "\"NULL\""
22268              << "," << std::endl;
22269     }
22270 
22271     print_VkBool32(obj->shaderDrawParameters, "shaderDrawParameters", 0);
22272 
22273     INDENT(-4);
22274     PRINT_SPACE
22275     if (commaNeeded)
22276         _OUT << "}," << std::endl;
22277     else
22278         _OUT << "}" << std::endl;
22279 }
22280 
22281 typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures;
22282 
22283 static std::map<uint64_t, std::string> VkDriverId_map = {
22284     std::make_pair(1, "VK_DRIVER_ID_AMD_PROPRIETARY"),
22285     std::make_pair(2, "VK_DRIVER_ID_AMD_OPEN_SOURCE"),
22286     std::make_pair(3, "VK_DRIVER_ID_MESA_RADV"),
22287     std::make_pair(4, "VK_DRIVER_ID_NVIDIA_PROPRIETARY"),
22288     std::make_pair(5, "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS"),
22289     std::make_pair(6, "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA"),
22290     std::make_pair(7, "VK_DRIVER_ID_IMAGINATION_PROPRIETARY"),
22291     std::make_pair(8, "VK_DRIVER_ID_QUALCOMM_PROPRIETARY"),
22292     std::make_pair(9, "VK_DRIVER_ID_ARM_PROPRIETARY"),
22293     std::make_pair(10, "VK_DRIVER_ID_GOOGLE_SWIFTSHADER"),
22294     std::make_pair(11, "VK_DRIVER_ID_GGP_PROPRIETARY"),
22295     std::make_pair(12, "VK_DRIVER_ID_BROADCOM_PROPRIETARY"),
22296     std::make_pair(13, "VK_DRIVER_ID_MESA_LLVMPIPE"),
22297     std::make_pair(14, "VK_DRIVER_ID_MOLTENVK"),
22298     std::make_pair(15, "VK_DRIVER_ID_COREAVI_PROPRIETARY"),
22299     std::make_pair(16, "VK_DRIVER_ID_JUICE_PROPRIETARY"),
22300     std::make_pair(17, "VK_DRIVER_ID_VERISILICON_PROPRIETARY"),
22301     std::make_pair(18, "VK_DRIVER_ID_MESA_TURNIP"),
22302     std::make_pair(19, "VK_DRIVER_ID_MESA_V3DV"),
22303     std::make_pair(20, "VK_DRIVER_ID_MESA_PANVK"),
22304     std::make_pair(21, "VK_DRIVER_ID_SAMSUNG_PROPRIETARY"),
22305 };
print_VkDriverId(VkDriverId obj,const std::string & str,bool commaNeeded=true)22306 static void print_VkDriverId(VkDriverId obj, const std::string &str, bool commaNeeded = true)
22307 {
22308     PRINT_SPACE
22309     if (str != "")
22310         _OUT << "\"" << str << "\""
22311              << " : ";
22312     if (commaNeeded)
22313         _OUT << "\"" << VkDriverId_map[obj] << "\"," << std::endl;
22314     else
22315         _OUT << "\"" << VkDriverId_map[obj] << "\"" << std::endl;
22316 }
print_VkDriverId(const VkDriverId * obj,const std::string & str,bool commaNeeded=true)22317 static void print_VkDriverId(const VkDriverId *obj, const std::string &str, bool commaNeeded = true)
22318 {
22319     PRINT_SPACE
22320     if (str != "")
22321         _OUT << "\"" << str << "\""
22322              << " : ";
22323     if (commaNeeded)
22324         _OUT << "\"" << VkDriverId_map[*obj] << "\"," << std::endl;
22325     else
22326         _OUT << "\"" << VkDriverId_map[*obj] << "\"" << std::endl;
22327 }
22328 
22329 static std::map<uint64_t, std::string> VkShaderFloatControlsIndependence_map = {
22330     std::make_pair(0, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY"),
22331     std::make_pair(1, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL"),
22332     std::make_pair(2, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE"),
22333 };
print_VkShaderFloatControlsIndependence(VkShaderFloatControlsIndependence obj,const std::string & str,bool commaNeeded=true)22334 static void print_VkShaderFloatControlsIndependence(VkShaderFloatControlsIndependence obj, const std::string &str,
22335                                                     bool commaNeeded = true)
22336 {
22337     PRINT_SPACE
22338     if (str != "")
22339         _OUT << "\"" << str << "\""
22340              << " : ";
22341     if (commaNeeded)
22342         _OUT << "\"" << VkShaderFloatControlsIndependence_map[obj] << "\"," << std::endl;
22343     else
22344         _OUT << "\"" << VkShaderFloatControlsIndependence_map[obj] << "\"" << std::endl;
22345 }
print_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence * obj,const std::string & str,bool commaNeeded=true)22346 static void print_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence *obj,
22347                                                     const std::string &str, bool commaNeeded = true)
22348 {
22349     PRINT_SPACE
22350     if (str != "")
22351         _OUT << "\"" << str << "\""
22352              << " : ";
22353     if (commaNeeded)
22354         _OUT << "\"" << VkShaderFloatControlsIndependence_map[*obj] << "\"," << std::endl;
22355     else
22356         _OUT << "\"" << VkShaderFloatControlsIndependence_map[*obj] << "\"" << std::endl;
22357 }
22358 
22359 static std::map<uint64_t, std::string> VkResolveModeFlagBits_map = {
22360     std::make_pair(0, "VK_RESOLVE_MODE_NONE"),
22361     std::make_pair(1ULL << 0, "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT"),
22362     std::make_pair(1ULL << 1, "VK_RESOLVE_MODE_AVERAGE_BIT"),
22363     std::make_pair(1ULL << 2, "VK_RESOLVE_MODE_MIN_BIT"),
22364     std::make_pair(1ULL << 3, "VK_RESOLVE_MODE_MAX_BIT"),
22365 };
print_VkResolveModeFlagBits(VkResolveModeFlagBits obj,const std::string & str,bool commaNeeded=true)22366 static void print_VkResolveModeFlagBits(VkResolveModeFlagBits obj, const std::string &str, bool commaNeeded = true)
22367 {
22368     PRINT_SPACE
22369     if (str != "")
22370         _OUT << "\"" << str << "\""
22371              << " : ";
22372     if (commaNeeded)
22373         _OUT << "\"" << VkResolveModeFlagBits_map[obj] << "\"," << std::endl;
22374     else
22375         _OUT << "\"" << VkResolveModeFlagBits_map[obj] << "\"" << std::endl;
22376 }
print_VkResolveModeFlagBits(const VkResolveModeFlagBits * obj,const std::string & str,bool commaNeeded=true)22377 static void print_VkResolveModeFlagBits(const VkResolveModeFlagBits *obj, const std::string &str,
22378                                         bool commaNeeded = true)
22379 {
22380     PRINT_SPACE
22381     if (str != "")
22382         _OUT << "\"" << str << "\""
22383              << " : ";
22384     if (commaNeeded)
22385         _OUT << "\"" << VkResolveModeFlagBits_map[*obj] << "\"," << std::endl;
22386     else
22387         _OUT << "\"" << VkResolveModeFlagBits_map[*obj] << "\"" << std::endl;
22388 }
22389 
22390 static std::map<uint64_t, std::string> VkDescriptorBindingFlagBits_map = {
22391     std::make_pair(1ULL << 0, "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT"),
22392     std::make_pair(1ULL << 1, "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT"),
22393     std::make_pair(1ULL << 2, "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT"),
22394     std::make_pair(1ULL << 3, "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT"),
22395     std::make_pair(1ULL << 4, "VK_DESCRIPTOR_BINDING_RESERVED_4_BIT_QCOM"),
22396 };
print_VkDescriptorBindingFlagBits(VkDescriptorBindingFlagBits obj,const std::string & str,bool commaNeeded=true)22397 static void print_VkDescriptorBindingFlagBits(VkDescriptorBindingFlagBits obj, const std::string &str,
22398                                               bool commaNeeded = true)
22399 {
22400     PRINT_SPACE
22401     if (str != "")
22402         _OUT << "\"" << str << "\""
22403              << " : ";
22404     if (commaNeeded)
22405         _OUT << "\"" << VkDescriptorBindingFlagBits_map[obj] << "\"," << std::endl;
22406     else
22407         _OUT << "\"" << VkDescriptorBindingFlagBits_map[obj] << "\"" << std::endl;
22408 }
print_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits * obj,const std::string & str,bool commaNeeded=true)22409 static void print_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits *obj, const std::string &str,
22410                                               bool commaNeeded = true)
22411 {
22412     PRINT_SPACE
22413     if (str != "")
22414         _OUT << "\"" << str << "\""
22415              << " : ";
22416     if (commaNeeded)
22417         _OUT << "\"" << VkDescriptorBindingFlagBits_map[*obj] << "\"," << std::endl;
22418     else
22419         _OUT << "\"" << VkDescriptorBindingFlagBits_map[*obj] << "\"" << std::endl;
22420 }
22421 
22422 static std::map<uint64_t, std::string> VkSamplerReductionMode_map = {
22423     std::make_pair(0, "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE"),
22424     std::make_pair(1, "VK_SAMPLER_REDUCTION_MODE_MIN"),
22425     std::make_pair(2, "VK_SAMPLER_REDUCTION_MODE_MAX"),
22426 };
print_VkSamplerReductionMode(VkSamplerReductionMode obj,const std::string & str,bool commaNeeded=true)22427 static void print_VkSamplerReductionMode(VkSamplerReductionMode obj, const std::string &str, bool commaNeeded = true)
22428 {
22429     PRINT_SPACE
22430     if (str != "")
22431         _OUT << "\"" << str << "\""
22432              << " : ";
22433     if (commaNeeded)
22434         _OUT << "\"" << VkSamplerReductionMode_map[obj] << "\"," << std::endl;
22435     else
22436         _OUT << "\"" << VkSamplerReductionMode_map[obj] << "\"" << std::endl;
22437 }
print_VkSamplerReductionMode(const VkSamplerReductionMode * obj,const std::string & str,bool commaNeeded=true)22438 static void print_VkSamplerReductionMode(const VkSamplerReductionMode *obj, const std::string &str,
22439                                          bool commaNeeded = true)
22440 {
22441     PRINT_SPACE
22442     if (str != "")
22443         _OUT << "\"" << str << "\""
22444              << " : ";
22445     if (commaNeeded)
22446         _OUT << "\"" << VkSamplerReductionMode_map[*obj] << "\"," << std::endl;
22447     else
22448         _OUT << "\"" << VkSamplerReductionMode_map[*obj] << "\"" << std::endl;
22449 }
22450 
22451 static std::map<uint64_t, std::string> VkSemaphoreType_map = {
22452     std::make_pair(0, "VK_SEMAPHORE_TYPE_BINARY"),
22453     std::make_pair(1, "VK_SEMAPHORE_TYPE_TIMELINE"),
22454 };
print_VkSemaphoreType(VkSemaphoreType obj,const std::string & str,bool commaNeeded=true)22455 static void print_VkSemaphoreType(VkSemaphoreType obj, const std::string &str, bool commaNeeded = true)
22456 {
22457     PRINT_SPACE
22458     if (str != "")
22459         _OUT << "\"" << str << "\""
22460              << " : ";
22461     if (commaNeeded)
22462         _OUT << "\"" << VkSemaphoreType_map[obj] << "\"," << std::endl;
22463     else
22464         _OUT << "\"" << VkSemaphoreType_map[obj] << "\"" << std::endl;
22465 }
print_VkSemaphoreType(const VkSemaphoreType * obj,const std::string & str,bool commaNeeded=true)22466 static void print_VkSemaphoreType(const VkSemaphoreType *obj, const std::string &str, bool commaNeeded = true)
22467 {
22468     PRINT_SPACE
22469     if (str != "")
22470         _OUT << "\"" << str << "\""
22471              << " : ";
22472     if (commaNeeded)
22473         _OUT << "\"" << VkSemaphoreType_map[*obj] << "\"," << std::endl;
22474     else
22475         _OUT << "\"" << VkSemaphoreType_map[*obj] << "\"" << std::endl;
22476 }
22477 
22478 static std::map<uint64_t, std::string> VkSemaphoreWaitFlagBits_map = {
22479     std::make_pair(1ULL << 0, "VK_SEMAPHORE_WAIT_ANY_BIT"),
22480 };
print_VkSemaphoreWaitFlagBits(VkSemaphoreWaitFlagBits obj,const std::string & str,bool commaNeeded=true)22481 static void print_VkSemaphoreWaitFlagBits(VkSemaphoreWaitFlagBits obj, const std::string &str, bool commaNeeded = true)
22482 {
22483     PRINT_SPACE
22484     if (str != "")
22485         _OUT << "\"" << str << "\""
22486              << " : ";
22487     if (commaNeeded)
22488         _OUT << "\"" << VkSemaphoreWaitFlagBits_map[obj] << "\"," << std::endl;
22489     else
22490         _OUT << "\"" << VkSemaphoreWaitFlagBits_map[obj] << "\"" << std::endl;
22491 }
print_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits * obj,const std::string & str,bool commaNeeded=true)22492 static void print_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits *obj, const std::string &str,
22493                                           bool commaNeeded = true)
22494 {
22495     PRINT_SPACE
22496     if (str != "")
22497         _OUT << "\"" << str << "\""
22498              << " : ";
22499     if (commaNeeded)
22500         _OUT << "\"" << VkSemaphoreWaitFlagBits_map[*obj] << "\"," << std::endl;
22501     else
22502         _OUT << "\"" << VkSemaphoreWaitFlagBits_map[*obj] << "\"" << std::endl;
22503 }
22504 
print_VkResolveModeFlags(VkResolveModeFlags obj,const std::string & str,bool commaNeeded=true)22505 static void print_VkResolveModeFlags(VkResolveModeFlags obj, const std::string &str, bool commaNeeded = true)
22506 {
22507     PRINT_SPACE
22508     if (str != "")
22509         _OUT << "\"" << str << "\""
22510              << " : ";
22511     const int max_bits = 64; // We don't expect the number to be larger.
22512     std::bitset<max_bits> b(obj);
22513     _OUT << "\"";
22514     if (obj == 0)
22515         _OUT << "0";
22516     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
22517     {
22518         if (b[i] == 1)
22519         {
22520             bitCount++;
22521             if (bitCount < b.count())
22522                 _OUT << VkResolveModeFlagBits_map[1ULL << i] << " | ";
22523             else
22524                 _OUT << VkResolveModeFlagBits_map[1ULL << i];
22525         }
22526     }
22527     if (commaNeeded)
22528         _OUT << "\""
22529              << ",";
22530     else
22531         _OUT << "\""
22532              << "";
22533     _OUT << std::endl;
22534 }
print_VkResolveModeFlags(const VkResolveModeFlags * obj,const std::string & str,bool commaNeeded=true)22535 static void print_VkResolveModeFlags(const VkResolveModeFlags *obj, const std::string &str, bool commaNeeded = true)
22536 {
22537     PRINT_SPACE
22538     if (str != "")
22539         _OUT << "\"" << str << "\""
22540              << " : ";
22541     const int max_bits = 64; // We don't expect the number to be larger.
22542     std::bitset<max_bits> b(obj);
22543     _OUT << "\"";
22544     if (obj == 0)
22545         _OUT << "0";
22546     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
22547     {
22548         if (b[i] == 1)
22549         {
22550             bitCount++;
22551             if (bitCount < b.count())
22552                 _OUT << VkResolveModeFlagBits_map[1ULL << i] << " | ";
22553             else
22554                 _OUT << VkResolveModeFlagBits_map[1ULL << i];
22555         }
22556     }
22557     if (commaNeeded)
22558         _OUT << "\""
22559              << ",";
22560     else
22561         _OUT << "\""
22562              << "";
22563     _OUT << std::endl;
22564 }
22565 
print_VkDescriptorBindingFlags(VkDescriptorBindingFlags obj,const std::string & str,bool commaNeeded=true)22566 static void print_VkDescriptorBindingFlags(VkDescriptorBindingFlags obj, const std::string &str,
22567                                            bool commaNeeded = true)
22568 {
22569     PRINT_SPACE
22570     if (str != "")
22571         _OUT << "\"" << str << "\""
22572              << " : ";
22573     const int max_bits = 64; // We don't expect the number to be larger.
22574     std::bitset<max_bits> b(obj);
22575     _OUT << "\"";
22576     if (obj == 0)
22577         _OUT << "0";
22578     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
22579     {
22580         if (b[i] == 1)
22581         {
22582             bitCount++;
22583             if (bitCount < b.count())
22584                 _OUT << VkDescriptorBindingFlagBits_map[1ULL << i] << " | ";
22585             else
22586                 _OUT << VkDescriptorBindingFlagBits_map[1ULL << i];
22587         }
22588     }
22589     if (commaNeeded)
22590         _OUT << "\""
22591              << ",";
22592     else
22593         _OUT << "\""
22594              << "";
22595     _OUT << std::endl;
22596 }
print_VkDescriptorBindingFlags(const VkDescriptorBindingFlags * obj,const std::string & str,bool commaNeeded=true)22597 static void print_VkDescriptorBindingFlags(const VkDescriptorBindingFlags *obj, const std::string &str,
22598                                            bool commaNeeded = true)
22599 {
22600     PRINT_SPACE
22601     if (str != "")
22602         _OUT << "\"" << str << "\""
22603              << " : ";
22604     const int max_bits = 64; // We don't expect the number to be larger.
22605     std::bitset<max_bits> b(obj);
22606     _OUT << "\"";
22607     if (obj == 0)
22608         _OUT << "0";
22609     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
22610     {
22611         if (b[i] == 1)
22612         {
22613             bitCount++;
22614             if (bitCount < b.count())
22615                 _OUT << VkDescriptorBindingFlagBits_map[1ULL << i] << " | ";
22616             else
22617                 _OUT << VkDescriptorBindingFlagBits_map[1ULL << i];
22618         }
22619     }
22620     if (commaNeeded)
22621         _OUT << "\""
22622              << ",";
22623     else
22624         _OUT << "\""
22625              << "";
22626     _OUT << std::endl;
22627 }
22628 
print_VkSemaphoreWaitFlags(VkSemaphoreWaitFlags obj,const std::string & str,bool commaNeeded=true)22629 static void print_VkSemaphoreWaitFlags(VkSemaphoreWaitFlags obj, const std::string &str, bool commaNeeded = true)
22630 {
22631     PRINT_SPACE
22632     if (str != "")
22633         _OUT << "\"" << str << "\""
22634              << " : ";
22635     const int max_bits = 64; // We don't expect the number to be larger.
22636     std::bitset<max_bits> b(obj);
22637     _OUT << "\"";
22638     if (obj == 0)
22639         _OUT << "0";
22640     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
22641     {
22642         if (b[i] == 1)
22643         {
22644             bitCount++;
22645             if (bitCount < b.count())
22646                 _OUT << VkSemaphoreWaitFlagBits_map[1ULL << i] << " | ";
22647             else
22648                 _OUT << VkSemaphoreWaitFlagBits_map[1ULL << i];
22649         }
22650     }
22651     if (commaNeeded)
22652         _OUT << "\""
22653              << ",";
22654     else
22655         _OUT << "\""
22656              << "";
22657     _OUT << std::endl;
22658 }
print_VkSemaphoreWaitFlags(const VkSemaphoreWaitFlags * obj,const std::string & str,bool commaNeeded=true)22659 static void print_VkSemaphoreWaitFlags(const VkSemaphoreWaitFlags *obj, const std::string &str, bool commaNeeded = true)
22660 {
22661     PRINT_SPACE
22662     if (str != "")
22663         _OUT << "\"" << str << "\""
22664              << " : ";
22665     const int max_bits = 64; // We don't expect the number to be larger.
22666     std::bitset<max_bits> b(obj);
22667     _OUT << "\"";
22668     if (obj == 0)
22669         _OUT << "0";
22670     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
22671     {
22672         if (b[i] == 1)
22673         {
22674             bitCount++;
22675             if (bitCount < b.count())
22676                 _OUT << VkSemaphoreWaitFlagBits_map[1ULL << i] << " | ";
22677             else
22678                 _OUT << VkSemaphoreWaitFlagBits_map[1ULL << i];
22679         }
22680     }
22681     if (commaNeeded)
22682         _OUT << "\""
22683              << ",";
22684     else
22685         _OUT << "\""
22686              << "";
22687     _OUT << std::endl;
22688 }
22689 
print_VkPhysicalDeviceVulkan11Features(VkPhysicalDeviceVulkan11Features obj,const std::string & s,bool commaNeeded=true)22690 static void print_VkPhysicalDeviceVulkan11Features(VkPhysicalDeviceVulkan11Features obj, const std::string &s,
22691                                                    bool commaNeeded = true)
22692 {
22693     PRINT_SPACE
22694     _OUT << "{" << std::endl;
22695     INDENT(4);
22696 
22697     print_VkStructureType(obj.sType, "sType", 1);
22698 
22699     if (obj.pNext)
22700     {
22701         dumpPNextChain(obj.pNext);
22702     }
22703     else
22704     {
22705         PRINT_SPACE
22706         _OUT << "\"pNext\":"
22707              << "\"NULL\""
22708              << "," << std::endl;
22709     }
22710 
22711     print_VkBool32(obj.storageBuffer16BitAccess, "storageBuffer16BitAccess", 1);
22712 
22713     print_VkBool32(obj.uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1);
22714 
22715     print_VkBool32(obj.storagePushConstant16, "storagePushConstant16", 1);
22716 
22717     print_VkBool32(obj.storageInputOutput16, "storageInputOutput16", 1);
22718 
22719     print_VkBool32(obj.multiview, "multiview", 1);
22720 
22721     print_VkBool32(obj.multiviewGeometryShader, "multiviewGeometryShader", 1);
22722 
22723     print_VkBool32(obj.multiviewTessellationShader, "multiviewTessellationShader", 1);
22724 
22725     print_VkBool32(obj.variablePointersStorageBuffer, "variablePointersStorageBuffer", 1);
22726 
22727     print_VkBool32(obj.variablePointers, "variablePointers", 1);
22728 
22729     print_VkBool32(obj.protectedMemory, "protectedMemory", 1);
22730 
22731     print_VkBool32(obj.samplerYcbcrConversion, "samplerYcbcrConversion", 1);
22732 
22733     print_VkBool32(obj.shaderDrawParameters, "shaderDrawParameters", 0);
22734 
22735     INDENT(-4);
22736     PRINT_SPACE
22737     if (commaNeeded)
22738         _OUT << "}," << std::endl;
22739     else
22740         _OUT << "}" << std::endl;
22741 }
print_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features * obj,const std::string & s,bool commaNeeded=true)22742 static void print_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features *obj, const std::string &s,
22743                                                    bool commaNeeded = true)
22744 {
22745     PRINT_SPACE
22746     _OUT << "{" << std::endl;
22747     INDENT(4);
22748 
22749     print_VkStructureType(obj->sType, "sType", 1);
22750 
22751     if (obj->pNext)
22752     {
22753         dumpPNextChain(obj->pNext);
22754     }
22755     else
22756     {
22757         PRINT_SPACE
22758         _OUT << "\"pNext\":"
22759              << "\"NULL\""
22760              << "," << std::endl;
22761     }
22762 
22763     print_VkBool32(obj->storageBuffer16BitAccess, "storageBuffer16BitAccess", 1);
22764 
22765     print_VkBool32(obj->uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1);
22766 
22767     print_VkBool32(obj->storagePushConstant16, "storagePushConstant16", 1);
22768 
22769     print_VkBool32(obj->storageInputOutput16, "storageInputOutput16", 1);
22770 
22771     print_VkBool32(obj->multiview, "multiview", 1);
22772 
22773     print_VkBool32(obj->multiviewGeometryShader, "multiviewGeometryShader", 1);
22774 
22775     print_VkBool32(obj->multiviewTessellationShader, "multiviewTessellationShader", 1);
22776 
22777     print_VkBool32(obj->variablePointersStorageBuffer, "variablePointersStorageBuffer", 1);
22778 
22779     print_VkBool32(obj->variablePointers, "variablePointers", 1);
22780 
22781     print_VkBool32(obj->protectedMemory, "protectedMemory", 1);
22782 
22783     print_VkBool32(obj->samplerYcbcrConversion, "samplerYcbcrConversion", 1);
22784 
22785     print_VkBool32(obj->shaderDrawParameters, "shaderDrawParameters", 0);
22786 
22787     INDENT(-4);
22788     PRINT_SPACE
22789     if (commaNeeded)
22790         _OUT << "}," << std::endl;
22791     else
22792         _OUT << "}" << std::endl;
22793 }
22794 
print_VkPhysicalDeviceVulkan11Properties(VkPhysicalDeviceVulkan11Properties obj,const std::string & s,bool commaNeeded=true)22795 static void print_VkPhysicalDeviceVulkan11Properties(VkPhysicalDeviceVulkan11Properties obj, const std::string &s,
22796                                                      bool commaNeeded = true)
22797 {
22798     PRINT_SPACE
22799     _OUT << "{" << std::endl;
22800     INDENT(4);
22801 
22802     print_VkStructureType(obj.sType, "sType", 1);
22803 
22804     if (obj.pNext)
22805     {
22806         dumpPNextChain(obj.pNext);
22807     }
22808     else
22809     {
22810         PRINT_SPACE
22811         _OUT << "\"pNext\":"
22812              << "\"NULL\""
22813              << "," << std::endl;
22814     }
22815 
22816     PRINT_SPACE
22817     _OUT << "\"deviceUUID\":" << std::endl;
22818     PRINT_SPACE
22819     _OUT << "[" << std::endl;
22820     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
22821     {
22822         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
22823         print_uint8_t(obj.deviceUUID[i], "", isCommaNeeded);
22824     }
22825     PRINT_SPACE
22826     _OUT << "]"
22827          << "," << std::endl;
22828 
22829     PRINT_SPACE
22830     _OUT << "\"driverUUID\":" << std::endl;
22831     PRINT_SPACE
22832     _OUT << "[" << std::endl;
22833     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
22834     {
22835         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
22836         print_uint8_t(obj.driverUUID[i], "", isCommaNeeded);
22837     }
22838     PRINT_SPACE
22839     _OUT << "]"
22840          << "," << std::endl;
22841 
22842     PRINT_SPACE
22843     _OUT << "\"deviceLUID\":" << std::endl;
22844     PRINT_SPACE
22845     _OUT << "[" << std::endl;
22846     for (unsigned int i = 0; i < VK_LUID_SIZE; i++)
22847     {
22848         bool isCommaNeeded = (i + 1) != VK_LUID_SIZE;
22849         print_uint8_t(obj.deviceLUID[i], "", isCommaNeeded);
22850     }
22851     PRINT_SPACE
22852     _OUT << "]"
22853          << "," << std::endl;
22854 
22855     print_uint32_t(obj.deviceNodeMask, "deviceNodeMask", 1);
22856 
22857     print_VkBool32(obj.deviceLUIDValid, "deviceLUIDValid", 1);
22858 
22859     print_uint32_t(obj.subgroupSize, "subgroupSize", 1);
22860 
22861     print_VkShaderStageFlags(obj.subgroupSupportedStages, "subgroupSupportedStages", 1);
22862 
22863     print_VkSubgroupFeatureFlags(obj.subgroupSupportedOperations, "subgroupSupportedOperations", 1);
22864 
22865     print_VkBool32(obj.subgroupQuadOperationsInAllStages, "subgroupQuadOperationsInAllStages", 1);
22866 
22867     print_VkPointClippingBehavior(obj.pointClippingBehavior, "pointClippingBehavior", 1);
22868 
22869     print_uint32_t(obj.maxMultiviewViewCount, "maxMultiviewViewCount", 1);
22870 
22871     print_uint32_t(obj.maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 1);
22872 
22873     print_VkBool32(obj.protectedNoFault, "protectedNoFault", 1);
22874 
22875     print_uint32_t(obj.maxPerSetDescriptors, "maxPerSetDescriptors", 1);
22876 
22877     print_VkDeviceSize(obj.maxMemoryAllocationSize, "maxMemoryAllocationSize", 0);
22878 
22879     INDENT(-4);
22880     PRINT_SPACE
22881     if (commaNeeded)
22882         _OUT << "}," << std::endl;
22883     else
22884         _OUT << "}" << std::endl;
22885 }
print_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties * obj,const std::string & s,bool commaNeeded=true)22886 static void print_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties *obj,
22887                                                      const std::string &s, bool commaNeeded = true)
22888 {
22889     PRINT_SPACE
22890     _OUT << "{" << std::endl;
22891     INDENT(4);
22892 
22893     print_VkStructureType(obj->sType, "sType", 1);
22894 
22895     if (obj->pNext)
22896     {
22897         dumpPNextChain(obj->pNext);
22898     }
22899     else
22900     {
22901         PRINT_SPACE
22902         _OUT << "\"pNext\":"
22903              << "\"NULL\""
22904              << "," << std::endl;
22905     }
22906 
22907     PRINT_SPACE
22908     _OUT << "\"deviceUUID\":" << std::endl;
22909     PRINT_SPACE
22910     _OUT << "[" << std::endl;
22911     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
22912     {
22913         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
22914         print_uint8_t(obj->deviceUUID[i], "", isCommaNeeded);
22915     }
22916     PRINT_SPACE
22917     _OUT << "]"
22918          << "," << std::endl;
22919 
22920     PRINT_SPACE
22921     _OUT << "\"driverUUID\":" << std::endl;
22922     PRINT_SPACE
22923     _OUT << "[" << std::endl;
22924     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
22925     {
22926         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
22927         print_uint8_t(obj->driverUUID[i], "", isCommaNeeded);
22928     }
22929     PRINT_SPACE
22930     _OUT << "]"
22931          << "," << std::endl;
22932 
22933     PRINT_SPACE
22934     _OUT << "\"deviceLUID\":" << std::endl;
22935     PRINT_SPACE
22936     _OUT << "[" << std::endl;
22937     for (unsigned int i = 0; i < VK_LUID_SIZE; i++)
22938     {
22939         bool isCommaNeeded = (i + 1) != VK_LUID_SIZE;
22940         print_uint8_t(obj->deviceLUID[i], "", isCommaNeeded);
22941     }
22942     PRINT_SPACE
22943     _OUT << "]"
22944          << "," << std::endl;
22945 
22946     print_uint32_t(obj->deviceNodeMask, "deviceNodeMask", 1);
22947 
22948     print_VkBool32(obj->deviceLUIDValid, "deviceLUIDValid", 1);
22949 
22950     print_uint32_t(obj->subgroupSize, "subgroupSize", 1);
22951 
22952     print_VkShaderStageFlags(obj->subgroupSupportedStages, "subgroupSupportedStages", 1);
22953 
22954     print_VkSubgroupFeatureFlags(obj->subgroupSupportedOperations, "subgroupSupportedOperations", 1);
22955 
22956     print_VkBool32(obj->subgroupQuadOperationsInAllStages, "subgroupQuadOperationsInAllStages", 1);
22957 
22958     print_VkPointClippingBehavior(obj->pointClippingBehavior, "pointClippingBehavior", 1);
22959 
22960     print_uint32_t(obj->maxMultiviewViewCount, "maxMultiviewViewCount", 1);
22961 
22962     print_uint32_t(obj->maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 1);
22963 
22964     print_VkBool32(obj->protectedNoFault, "protectedNoFault", 1);
22965 
22966     print_uint32_t(obj->maxPerSetDescriptors, "maxPerSetDescriptors", 1);
22967 
22968     print_VkDeviceSize(obj->maxMemoryAllocationSize, "maxMemoryAllocationSize", 0);
22969 
22970     INDENT(-4);
22971     PRINT_SPACE
22972     if (commaNeeded)
22973         _OUT << "}," << std::endl;
22974     else
22975         _OUT << "}" << std::endl;
22976 }
22977 
print_VkPhysicalDeviceVulkan12Features(VkPhysicalDeviceVulkan12Features obj,const std::string & s,bool commaNeeded=true)22978 static void print_VkPhysicalDeviceVulkan12Features(VkPhysicalDeviceVulkan12Features obj, const std::string &s,
22979                                                    bool commaNeeded = true)
22980 {
22981     PRINT_SPACE
22982     _OUT << "{" << std::endl;
22983     INDENT(4);
22984 
22985     print_VkStructureType(obj.sType, "sType", 1);
22986 
22987     if (obj.pNext)
22988     {
22989         dumpPNextChain(obj.pNext);
22990     }
22991     else
22992     {
22993         PRINT_SPACE
22994         _OUT << "\"pNext\":"
22995              << "\"NULL\""
22996              << "," << std::endl;
22997     }
22998 
22999     print_VkBool32(obj.samplerMirrorClampToEdge, "samplerMirrorClampToEdge", 1);
23000 
23001     print_VkBool32(obj.drawIndirectCount, "drawIndirectCount", 1);
23002 
23003     print_VkBool32(obj.storageBuffer8BitAccess, "storageBuffer8BitAccess", 1);
23004 
23005     print_VkBool32(obj.uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1);
23006 
23007     print_VkBool32(obj.storagePushConstant8, "storagePushConstant8", 1);
23008 
23009     print_VkBool32(obj.shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1);
23010 
23011     print_VkBool32(obj.shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 1);
23012 
23013     print_VkBool32(obj.shaderFloat16, "shaderFloat16", 1);
23014 
23015     print_VkBool32(obj.shaderInt8, "shaderInt8", 1);
23016 
23017     print_VkBool32(obj.descriptorIndexing, "descriptorIndexing", 1);
23018 
23019     print_VkBool32(obj.shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1);
23020 
23021     print_VkBool32(obj.shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing", 1);
23022 
23023     print_VkBool32(obj.shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing", 1);
23024 
23025     print_VkBool32(obj.shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1);
23026 
23027     print_VkBool32(obj.shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1);
23028 
23029     print_VkBool32(obj.shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1);
23030 
23031     print_VkBool32(obj.shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1);
23032 
23033     print_VkBool32(obj.shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing", 1);
23034 
23035     print_VkBool32(obj.shaderUniformTexelBufferArrayNonUniformIndexing,
23036                    "shaderUniformTexelBufferArrayNonUniformIndexing", 1);
23037 
23038     print_VkBool32(obj.shaderStorageTexelBufferArrayNonUniformIndexing,
23039                    "shaderStorageTexelBufferArrayNonUniformIndexing", 1);
23040 
23041     print_VkBool32(obj.descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind",
23042                    1);
23043 
23044     print_VkBool32(obj.descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind", 1);
23045 
23046     print_VkBool32(obj.descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind", 1);
23047 
23048     print_VkBool32(obj.descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind",
23049                    1);
23050 
23051     print_VkBool32(obj.descriptorBindingUniformTexelBufferUpdateAfterBind,
23052                    "descriptorBindingUniformTexelBufferUpdateAfterBind", 1);
23053 
23054     print_VkBool32(obj.descriptorBindingStorageTexelBufferUpdateAfterBind,
23055                    "descriptorBindingStorageTexelBufferUpdateAfterBind", 1);
23056 
23057     print_VkBool32(obj.descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1);
23058 
23059     print_VkBool32(obj.descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1);
23060 
23061     print_VkBool32(obj.descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1);
23062 
23063     print_VkBool32(obj.runtimeDescriptorArray, "runtimeDescriptorArray", 1);
23064 
23065     print_VkBool32(obj.samplerFilterMinmax, "samplerFilterMinmax", 1);
23066 
23067     print_VkBool32(obj.scalarBlockLayout, "scalarBlockLayout", 1);
23068 
23069     print_VkBool32(obj.imagelessFramebuffer, "imagelessFramebuffer", 1);
23070 
23071     print_VkBool32(obj.uniformBufferStandardLayout, "uniformBufferStandardLayout", 1);
23072 
23073     print_VkBool32(obj.shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 1);
23074 
23075     print_VkBool32(obj.separateDepthStencilLayouts, "separateDepthStencilLayouts", 1);
23076 
23077     print_VkBool32(obj.hostQueryReset, "hostQueryReset", 1);
23078 
23079     print_VkBool32(obj.timelineSemaphore, "timelineSemaphore", 1);
23080 
23081     print_VkBool32(obj.bufferDeviceAddress, "bufferDeviceAddress", 1);
23082 
23083     print_VkBool32(obj.bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1);
23084 
23085     print_VkBool32(obj.bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 1);
23086 
23087     print_VkBool32(obj.vulkanMemoryModel, "vulkanMemoryModel", 1);
23088 
23089     print_VkBool32(obj.vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1);
23090 
23091     print_VkBool32(obj.vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains",
23092                    1);
23093 
23094     print_VkBool32(obj.shaderOutputViewportIndex, "shaderOutputViewportIndex", 1);
23095 
23096     print_VkBool32(obj.shaderOutputLayer, "shaderOutputLayer", 1);
23097 
23098     print_VkBool32(obj.subgroupBroadcastDynamicId, "subgroupBroadcastDynamicId", 0);
23099 
23100     INDENT(-4);
23101     PRINT_SPACE
23102     if (commaNeeded)
23103         _OUT << "}," << std::endl;
23104     else
23105         _OUT << "}" << std::endl;
23106 }
print_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features * obj,const std::string & s,bool commaNeeded=true)23107 static void print_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features *obj, const std::string &s,
23108                                                    bool commaNeeded = true)
23109 {
23110     PRINT_SPACE
23111     _OUT << "{" << std::endl;
23112     INDENT(4);
23113 
23114     print_VkStructureType(obj->sType, "sType", 1);
23115 
23116     if (obj->pNext)
23117     {
23118         dumpPNextChain(obj->pNext);
23119     }
23120     else
23121     {
23122         PRINT_SPACE
23123         _OUT << "\"pNext\":"
23124              << "\"NULL\""
23125              << "," << std::endl;
23126     }
23127 
23128     print_VkBool32(obj->samplerMirrorClampToEdge, "samplerMirrorClampToEdge", 1);
23129 
23130     print_VkBool32(obj->drawIndirectCount, "drawIndirectCount", 1);
23131 
23132     print_VkBool32(obj->storageBuffer8BitAccess, "storageBuffer8BitAccess", 1);
23133 
23134     print_VkBool32(obj->uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1);
23135 
23136     print_VkBool32(obj->storagePushConstant8, "storagePushConstant8", 1);
23137 
23138     print_VkBool32(obj->shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1);
23139 
23140     print_VkBool32(obj->shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 1);
23141 
23142     print_VkBool32(obj->shaderFloat16, "shaderFloat16", 1);
23143 
23144     print_VkBool32(obj->shaderInt8, "shaderInt8", 1);
23145 
23146     print_VkBool32(obj->descriptorIndexing, "descriptorIndexing", 1);
23147 
23148     print_VkBool32(obj->shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1);
23149 
23150     print_VkBool32(obj->shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing",
23151                    1);
23152 
23153     print_VkBool32(obj->shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing",
23154                    1);
23155 
23156     print_VkBool32(obj->shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1);
23157 
23158     print_VkBool32(obj->shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1);
23159 
23160     print_VkBool32(obj->shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1);
23161 
23162     print_VkBool32(obj->shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1);
23163 
23164     print_VkBool32(obj->shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing",
23165                    1);
23166 
23167     print_VkBool32(obj->shaderUniformTexelBufferArrayNonUniformIndexing,
23168                    "shaderUniformTexelBufferArrayNonUniformIndexing", 1);
23169 
23170     print_VkBool32(obj->shaderStorageTexelBufferArrayNonUniformIndexing,
23171                    "shaderStorageTexelBufferArrayNonUniformIndexing", 1);
23172 
23173     print_VkBool32(obj->descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind",
23174                    1);
23175 
23176     print_VkBool32(obj->descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind",
23177                    1);
23178 
23179     print_VkBool32(obj->descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind",
23180                    1);
23181 
23182     print_VkBool32(obj->descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind",
23183                    1);
23184 
23185     print_VkBool32(obj->descriptorBindingUniformTexelBufferUpdateAfterBind,
23186                    "descriptorBindingUniformTexelBufferUpdateAfterBind", 1);
23187 
23188     print_VkBool32(obj->descriptorBindingStorageTexelBufferUpdateAfterBind,
23189                    "descriptorBindingStorageTexelBufferUpdateAfterBind", 1);
23190 
23191     print_VkBool32(obj->descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1);
23192 
23193     print_VkBool32(obj->descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1);
23194 
23195     print_VkBool32(obj->descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1);
23196 
23197     print_VkBool32(obj->runtimeDescriptorArray, "runtimeDescriptorArray", 1);
23198 
23199     print_VkBool32(obj->samplerFilterMinmax, "samplerFilterMinmax", 1);
23200 
23201     print_VkBool32(obj->scalarBlockLayout, "scalarBlockLayout", 1);
23202 
23203     print_VkBool32(obj->imagelessFramebuffer, "imagelessFramebuffer", 1);
23204 
23205     print_VkBool32(obj->uniformBufferStandardLayout, "uniformBufferStandardLayout", 1);
23206 
23207     print_VkBool32(obj->shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 1);
23208 
23209     print_VkBool32(obj->separateDepthStencilLayouts, "separateDepthStencilLayouts", 1);
23210 
23211     print_VkBool32(obj->hostQueryReset, "hostQueryReset", 1);
23212 
23213     print_VkBool32(obj->timelineSemaphore, "timelineSemaphore", 1);
23214 
23215     print_VkBool32(obj->bufferDeviceAddress, "bufferDeviceAddress", 1);
23216 
23217     print_VkBool32(obj->bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1);
23218 
23219     print_VkBool32(obj->bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 1);
23220 
23221     print_VkBool32(obj->vulkanMemoryModel, "vulkanMemoryModel", 1);
23222 
23223     print_VkBool32(obj->vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1);
23224 
23225     print_VkBool32(obj->vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains",
23226                    1);
23227 
23228     print_VkBool32(obj->shaderOutputViewportIndex, "shaderOutputViewportIndex", 1);
23229 
23230     print_VkBool32(obj->shaderOutputLayer, "shaderOutputLayer", 1);
23231 
23232     print_VkBool32(obj->subgroupBroadcastDynamicId, "subgroupBroadcastDynamicId", 0);
23233 
23234     INDENT(-4);
23235     PRINT_SPACE
23236     if (commaNeeded)
23237         _OUT << "}," << std::endl;
23238     else
23239         _OUT << "}" << std::endl;
23240 }
23241 
print_VkConformanceVersion(VkConformanceVersion obj,const std::string & s,bool commaNeeded=true)23242 static void print_VkConformanceVersion(VkConformanceVersion obj, const std::string &s, bool commaNeeded = true)
23243 {
23244     PRINT_SPACE
23245     _OUT << "{" << std::endl;
23246     INDENT(4);
23247 
23248     print_uint8_t(obj.major, "major", 1);
23249 
23250     print_uint8_t(obj.minor, "minor", 1);
23251 
23252     print_uint8_t(obj.subminor, "subminor", 1);
23253 
23254     print_uint8_t(obj.patch, "patch", 0);
23255 
23256     INDENT(-4);
23257     PRINT_SPACE
23258     if (commaNeeded)
23259         _OUT << "}," << std::endl;
23260     else
23261         _OUT << "}" << std::endl;
23262 }
print_VkConformanceVersion(const VkConformanceVersion * obj,const std::string & s,bool commaNeeded=true)23263 static void print_VkConformanceVersion(const VkConformanceVersion *obj, const std::string &s, bool commaNeeded = true)
23264 {
23265     PRINT_SPACE
23266     _OUT << "{" << std::endl;
23267     INDENT(4);
23268 
23269     print_uint8_t(obj->major, "major", 1);
23270 
23271     print_uint8_t(obj->minor, "minor", 1);
23272 
23273     print_uint8_t(obj->subminor, "subminor", 1);
23274 
23275     print_uint8_t(obj->patch, "patch", 0);
23276 
23277     INDENT(-4);
23278     PRINT_SPACE
23279     if (commaNeeded)
23280         _OUT << "}," << std::endl;
23281     else
23282         _OUT << "}" << std::endl;
23283 }
23284 
print_VkPhysicalDeviceVulkan12Properties(VkPhysicalDeviceVulkan12Properties obj,const std::string & s,bool commaNeeded=true)23285 static void print_VkPhysicalDeviceVulkan12Properties(VkPhysicalDeviceVulkan12Properties obj, const std::string &s,
23286                                                      bool commaNeeded = true)
23287 {
23288     PRINT_SPACE
23289     _OUT << "{" << std::endl;
23290     INDENT(4);
23291 
23292     print_VkStructureType(obj.sType, "sType", 1);
23293 
23294     if (obj.pNext)
23295     {
23296         dumpPNextChain(obj.pNext);
23297     }
23298     else
23299     {
23300         PRINT_SPACE
23301         _OUT << "\"pNext\":"
23302              << "\"NULL\""
23303              << "," << std::endl;
23304     }
23305 
23306     print_VkDriverId(obj.driverID, "driverID", 1);
23307 
23308     PRINT_SPACE
23309     _OUT << "\"driverName\":" << std::endl;
23310     PRINT_SPACE
23311     _OUT << "[" << std::endl;
23312     for (unsigned int i = 0; i < VK_MAX_DRIVER_NAME_SIZE; i++)
23313     {
23314         bool isCommaNeeded = (i + 1) != VK_MAX_DRIVER_NAME_SIZE;
23315         print_char(obj.driverName[i], "", isCommaNeeded);
23316     }
23317     PRINT_SPACE
23318     _OUT << "]"
23319          << "," << std::endl;
23320 
23321     PRINT_SPACE
23322     _OUT << "\"driverInfo\":" << std::endl;
23323     PRINT_SPACE
23324     _OUT << "[" << std::endl;
23325     for (unsigned int i = 0; i < VK_MAX_DRIVER_INFO_SIZE; i++)
23326     {
23327         bool isCommaNeeded = (i + 1) != VK_MAX_DRIVER_INFO_SIZE;
23328         print_char(obj.driverInfo[i], "", isCommaNeeded);
23329     }
23330     PRINT_SPACE
23331     _OUT << "]"
23332          << "," << std::endl;
23333 
23334     PRINT_SPACE
23335     _OUT << "\"conformanceVersion\": " << std::endl;
23336     {
23337         print_VkConformanceVersion(obj.conformanceVersion, "conformanceVersion", 1);
23338     }
23339 
23340     print_VkShaderFloatControlsIndependence(obj.denormBehaviorIndependence, "denormBehaviorIndependence", 1);
23341 
23342     print_VkShaderFloatControlsIndependence(obj.roundingModeIndependence, "roundingModeIndependence", 1);
23343 
23344     print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1);
23345 
23346     print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1);
23347 
23348     print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1);
23349 
23350     print_VkBool32(obj.shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1);
23351 
23352     print_VkBool32(obj.shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1);
23353 
23354     print_VkBool32(obj.shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1);
23355 
23356     print_VkBool32(obj.shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1);
23357 
23358     print_VkBool32(obj.shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1);
23359 
23360     print_VkBool32(obj.shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1);
23361 
23362     print_VkBool32(obj.shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1);
23363 
23364     print_VkBool32(obj.shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1);
23365 
23366     print_VkBool32(obj.shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1);
23367 
23368     print_VkBool32(obj.shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1);
23369 
23370     print_VkBool32(obj.shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1);
23371 
23372     print_VkBool32(obj.shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 1);
23373 
23374     print_uint32_t(obj.maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1);
23375 
23376     print_VkBool32(obj.shaderUniformBufferArrayNonUniformIndexingNative,
23377                    "shaderUniformBufferArrayNonUniformIndexingNative", 1);
23378 
23379     print_VkBool32(obj.shaderSampledImageArrayNonUniformIndexingNative,
23380                    "shaderSampledImageArrayNonUniformIndexingNative", 1);
23381 
23382     print_VkBool32(obj.shaderStorageBufferArrayNonUniformIndexingNative,
23383                    "shaderStorageBufferArrayNonUniformIndexingNative", 1);
23384 
23385     print_VkBool32(obj.shaderStorageImageArrayNonUniformIndexingNative,
23386                    "shaderStorageImageArrayNonUniformIndexingNative", 1);
23387 
23388     print_VkBool32(obj.shaderInputAttachmentArrayNonUniformIndexingNative,
23389                    "shaderInputAttachmentArrayNonUniformIndexingNative", 1);
23390 
23391     print_VkBool32(obj.robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1);
23392 
23393     print_VkBool32(obj.quadDivergentImplicitLod, "quadDivergentImplicitLod", 1);
23394 
23395     print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers", 1);
23396 
23397     print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers,
23398                    "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1);
23399 
23400     print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers,
23401                    "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1);
23402 
23403     print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindSampledImages,
23404                    "maxPerStageDescriptorUpdateAfterBindSampledImages", 1);
23405 
23406     print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindStorageImages,
23407                    "maxPerStageDescriptorUpdateAfterBindStorageImages", 1);
23408 
23409     print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindInputAttachments,
23410                    "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1);
23411 
23412     print_uint32_t(obj.maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1);
23413 
23414     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1);
23415 
23416     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers",
23417                    1);
23418 
23419     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
23420                    "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1);
23421 
23422     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers",
23423                    1);
23424 
23425     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
23426                    "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1);
23427 
23428     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages", 1);
23429 
23430     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages", 1);
23431 
23432     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindInputAttachments,
23433                    "maxDescriptorSetUpdateAfterBindInputAttachments", 1);
23434 
23435     print_VkResolveModeFlags(obj.supportedDepthResolveModes, "supportedDepthResolveModes", 1);
23436 
23437     print_VkResolveModeFlags(obj.supportedStencilResolveModes, "supportedStencilResolveModes", 1);
23438 
23439     print_VkBool32(obj.independentResolveNone, "independentResolveNone", 1);
23440 
23441     print_VkBool32(obj.independentResolve, "independentResolve", 1);
23442 
23443     print_VkBool32(obj.filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1);
23444 
23445     print_VkBool32(obj.filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 1);
23446 
23447     print_uint64_t(obj.maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 1);
23448 
23449     print_VkSampleCountFlags(obj.framebufferIntegerColorSampleCounts, "framebufferIntegerColorSampleCounts", 0);
23450 
23451     INDENT(-4);
23452     PRINT_SPACE
23453     if (commaNeeded)
23454         _OUT << "}," << std::endl;
23455     else
23456         _OUT << "}" << std::endl;
23457 }
print_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties * obj,const std::string & s,bool commaNeeded=true)23458 static void print_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties *obj,
23459                                                      const std::string &s, bool commaNeeded = true)
23460 {
23461     PRINT_SPACE
23462     _OUT << "{" << std::endl;
23463     INDENT(4);
23464 
23465     print_VkStructureType(obj->sType, "sType", 1);
23466 
23467     if (obj->pNext)
23468     {
23469         dumpPNextChain(obj->pNext);
23470     }
23471     else
23472     {
23473         PRINT_SPACE
23474         _OUT << "\"pNext\":"
23475              << "\"NULL\""
23476              << "," << std::endl;
23477     }
23478 
23479     print_VkDriverId(obj->driverID, "driverID", 1);
23480 
23481     PRINT_SPACE
23482     _OUT << "\"driverName\":" << std::endl;
23483     PRINT_SPACE
23484     _OUT << "[" << std::endl;
23485     for (unsigned int i = 0; i < VK_MAX_DRIVER_NAME_SIZE; i++)
23486     {
23487         bool isCommaNeeded = (i + 1) != VK_MAX_DRIVER_NAME_SIZE;
23488         print_char(obj->driverName[i], "", isCommaNeeded);
23489     }
23490     PRINT_SPACE
23491     _OUT << "]"
23492          << "," << std::endl;
23493 
23494     PRINT_SPACE
23495     _OUT << "\"driverInfo\":" << std::endl;
23496     PRINT_SPACE
23497     _OUT << "[" << std::endl;
23498     for (unsigned int i = 0; i < VK_MAX_DRIVER_INFO_SIZE; i++)
23499     {
23500         bool isCommaNeeded = (i + 1) != VK_MAX_DRIVER_INFO_SIZE;
23501         print_char(obj->driverInfo[i], "", isCommaNeeded);
23502     }
23503     PRINT_SPACE
23504     _OUT << "]"
23505          << "," << std::endl;
23506 
23507     PRINT_SPACE
23508     _OUT << "\"conformanceVersion\": " << std::endl;
23509     {
23510         print_VkConformanceVersion(obj->conformanceVersion, "conformanceVersion", 1);
23511     }
23512 
23513     print_VkShaderFloatControlsIndependence(obj->denormBehaviorIndependence, "denormBehaviorIndependence", 1);
23514 
23515     print_VkShaderFloatControlsIndependence(obj->roundingModeIndependence, "roundingModeIndependence", 1);
23516 
23517     print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1);
23518 
23519     print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1);
23520 
23521     print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1);
23522 
23523     print_VkBool32(obj->shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1);
23524 
23525     print_VkBool32(obj->shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1);
23526 
23527     print_VkBool32(obj->shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1);
23528 
23529     print_VkBool32(obj->shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1);
23530 
23531     print_VkBool32(obj->shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1);
23532 
23533     print_VkBool32(obj->shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1);
23534 
23535     print_VkBool32(obj->shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1);
23536 
23537     print_VkBool32(obj->shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1);
23538 
23539     print_VkBool32(obj->shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1);
23540 
23541     print_VkBool32(obj->shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1);
23542 
23543     print_VkBool32(obj->shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1);
23544 
23545     print_VkBool32(obj->shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 1);
23546 
23547     print_uint32_t(obj->maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1);
23548 
23549     print_VkBool32(obj->shaderUniformBufferArrayNonUniformIndexingNative,
23550                    "shaderUniformBufferArrayNonUniformIndexingNative", 1);
23551 
23552     print_VkBool32(obj->shaderSampledImageArrayNonUniformIndexingNative,
23553                    "shaderSampledImageArrayNonUniformIndexingNative", 1);
23554 
23555     print_VkBool32(obj->shaderStorageBufferArrayNonUniformIndexingNative,
23556                    "shaderStorageBufferArrayNonUniformIndexingNative", 1);
23557 
23558     print_VkBool32(obj->shaderStorageImageArrayNonUniformIndexingNative,
23559                    "shaderStorageImageArrayNonUniformIndexingNative", 1);
23560 
23561     print_VkBool32(obj->shaderInputAttachmentArrayNonUniformIndexingNative,
23562                    "shaderInputAttachmentArrayNonUniformIndexingNative", 1);
23563 
23564     print_VkBool32(obj->robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1);
23565 
23566     print_VkBool32(obj->quadDivergentImplicitLod, "quadDivergentImplicitLod", 1);
23567 
23568     print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers",
23569                    1);
23570 
23571     print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindUniformBuffers,
23572                    "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1);
23573 
23574     print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindStorageBuffers,
23575                    "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1);
23576 
23577     print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindSampledImages,
23578                    "maxPerStageDescriptorUpdateAfterBindSampledImages", 1);
23579 
23580     print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindStorageImages,
23581                    "maxPerStageDescriptorUpdateAfterBindStorageImages", 1);
23582 
23583     print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindInputAttachments,
23584                    "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1);
23585 
23586     print_uint32_t(obj->maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1);
23587 
23588     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1);
23589 
23590     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers",
23591                    1);
23592 
23593     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
23594                    "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1);
23595 
23596     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers",
23597                    1);
23598 
23599     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
23600                    "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1);
23601 
23602     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages",
23603                    1);
23604 
23605     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages",
23606                    1);
23607 
23608     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindInputAttachments,
23609                    "maxDescriptorSetUpdateAfterBindInputAttachments", 1);
23610 
23611     print_VkResolveModeFlags(obj->supportedDepthResolveModes, "supportedDepthResolveModes", 1);
23612 
23613     print_VkResolveModeFlags(obj->supportedStencilResolveModes, "supportedStencilResolveModes", 1);
23614 
23615     print_VkBool32(obj->independentResolveNone, "independentResolveNone", 1);
23616 
23617     print_VkBool32(obj->independentResolve, "independentResolve", 1);
23618 
23619     print_VkBool32(obj->filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1);
23620 
23621     print_VkBool32(obj->filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 1);
23622 
23623     print_uint64_t(obj->maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 1);
23624 
23625     print_VkSampleCountFlags(obj->framebufferIntegerColorSampleCounts, "framebufferIntegerColorSampleCounts", 0);
23626 
23627     INDENT(-4);
23628     PRINT_SPACE
23629     if (commaNeeded)
23630         _OUT << "}," << std::endl;
23631     else
23632         _OUT << "}" << std::endl;
23633 }
23634 
print_VkImageFormatListCreateInfo(VkImageFormatListCreateInfo obj,const std::string & s,bool commaNeeded=true)23635 static void print_VkImageFormatListCreateInfo(VkImageFormatListCreateInfo obj, const std::string &s,
23636                                               bool commaNeeded = true)
23637 {
23638     PRINT_SPACE
23639     _OUT << "{" << std::endl;
23640     INDENT(4);
23641 
23642     print_VkStructureType(obj.sType, "sType", 1);
23643 
23644     if (obj.pNext)
23645     {
23646         dumpPNextChain(obj.pNext);
23647     }
23648     else
23649     {
23650         PRINT_SPACE
23651         _OUT << "\"pNext\":"
23652              << "\"NULL\""
23653              << "," << std::endl;
23654     }
23655 
23656     print_uint32_t(obj.viewFormatCount, "viewFormatCount", 1);
23657 
23658     PRINT_SPACE
23659     _OUT << "\"pViewFormats\":" << std::endl;
23660     PRINT_SPACE
23661     if (obj.pViewFormats)
23662     {
23663         _OUT << "[" << std::endl;
23664         for (unsigned int i = 0; i < obj.viewFormatCount; i++)
23665         {
23666             bool isCommaNeeded = (i + 1) != obj.viewFormatCount;
23667             print_VkFormat(obj.pViewFormats[i], "", isCommaNeeded);
23668         }
23669         PRINT_SPACE
23670         _OUT << "]"
23671              << "" << std::endl;
23672     }
23673     else
23674     {
23675         _OUT << "\"NULL\""
23676              << "" << std::endl;
23677     }
23678 
23679     INDENT(-4);
23680     PRINT_SPACE
23681     if (commaNeeded)
23682         _OUT << "}," << std::endl;
23683     else
23684         _OUT << "}" << std::endl;
23685 }
print_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo * obj,const std::string & s,bool commaNeeded=true)23686 static void print_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo *obj, const std::string &s,
23687                                               bool commaNeeded = true)
23688 {
23689     PRINT_SPACE
23690     _OUT << "{" << std::endl;
23691     INDENT(4);
23692 
23693     print_VkStructureType(obj->sType, "sType", 1);
23694 
23695     if (obj->pNext)
23696     {
23697         dumpPNextChain(obj->pNext);
23698     }
23699     else
23700     {
23701         PRINT_SPACE
23702         _OUT << "\"pNext\":"
23703              << "\"NULL\""
23704              << "," << std::endl;
23705     }
23706 
23707     print_uint32_t(obj->viewFormatCount, "viewFormatCount", 1);
23708 
23709     PRINT_SPACE
23710     _OUT << "\"pViewFormats\":" << std::endl;
23711     PRINT_SPACE
23712     if (obj->pViewFormats)
23713     {
23714         _OUT << "[" << std::endl;
23715         for (unsigned int i = 0; i < obj->viewFormatCount; i++)
23716         {
23717             bool isCommaNeeded = (i + 1) != obj->viewFormatCount;
23718             print_VkFormat(obj->pViewFormats[i], "", isCommaNeeded);
23719         }
23720         PRINT_SPACE
23721         _OUT << "]"
23722              << "" << std::endl;
23723     }
23724     else
23725     {
23726         _OUT << "\"NULL\""
23727              << "" << std::endl;
23728     }
23729 
23730     INDENT(-4);
23731     PRINT_SPACE
23732     if (commaNeeded)
23733         _OUT << "}," << std::endl;
23734     else
23735         _OUT << "}" << std::endl;
23736 }
23737 
print_VkAttachmentDescription2(VkAttachmentDescription2 obj,const std::string & s,bool commaNeeded=true)23738 static void print_VkAttachmentDescription2(VkAttachmentDescription2 obj, const std::string &s, bool commaNeeded = true)
23739 {
23740     PRINT_SPACE
23741     _OUT << "{" << std::endl;
23742     INDENT(4);
23743 
23744     print_VkStructureType(obj.sType, "sType", 1);
23745 
23746     if (obj.pNext)
23747     {
23748         dumpPNextChain(obj.pNext);
23749     }
23750     else
23751     {
23752         PRINT_SPACE
23753         _OUT << "\"pNext\":"
23754              << "\"NULL\""
23755              << "," << std::endl;
23756     }
23757 
23758     print_VkAttachmentDescriptionFlags(obj.flags, "flags", 1);
23759 
23760     print_VkFormat(obj.format, "format", 1);
23761 
23762     print_VkSampleCountFlagBits(obj.samples, "samples", 1);
23763 
23764     print_VkAttachmentLoadOp(obj.loadOp, "loadOp", 1);
23765 
23766     print_VkAttachmentStoreOp(obj.storeOp, "storeOp", 1);
23767 
23768     print_VkAttachmentLoadOp(obj.stencilLoadOp, "stencilLoadOp", 1);
23769 
23770     print_VkAttachmentStoreOp(obj.stencilStoreOp, "stencilStoreOp", 1);
23771 
23772     print_VkImageLayout(obj.initialLayout, "initialLayout", 1);
23773 
23774     print_VkImageLayout(obj.finalLayout, "finalLayout", 0);
23775 
23776     INDENT(-4);
23777     PRINT_SPACE
23778     if (commaNeeded)
23779         _OUT << "}," << std::endl;
23780     else
23781         _OUT << "}" << std::endl;
23782 }
print_VkAttachmentDescription2(const VkAttachmentDescription2 * obj,const std::string & s,bool commaNeeded=true)23783 static void print_VkAttachmentDescription2(const VkAttachmentDescription2 *obj, const std::string &s,
23784                                            bool commaNeeded = true)
23785 {
23786     PRINT_SPACE
23787     _OUT << "{" << std::endl;
23788     INDENT(4);
23789 
23790     print_VkStructureType(obj->sType, "sType", 1);
23791 
23792     if (obj->pNext)
23793     {
23794         dumpPNextChain(obj->pNext);
23795     }
23796     else
23797     {
23798         PRINT_SPACE
23799         _OUT << "\"pNext\":"
23800              << "\"NULL\""
23801              << "," << std::endl;
23802     }
23803 
23804     print_VkAttachmentDescriptionFlags(obj->flags, "flags", 1);
23805 
23806     print_VkFormat(obj->format, "format", 1);
23807 
23808     print_VkSampleCountFlagBits(obj->samples, "samples", 1);
23809 
23810     print_VkAttachmentLoadOp(obj->loadOp, "loadOp", 1);
23811 
23812     print_VkAttachmentStoreOp(obj->storeOp, "storeOp", 1);
23813 
23814     print_VkAttachmentLoadOp(obj->stencilLoadOp, "stencilLoadOp", 1);
23815 
23816     print_VkAttachmentStoreOp(obj->stencilStoreOp, "stencilStoreOp", 1);
23817 
23818     print_VkImageLayout(obj->initialLayout, "initialLayout", 1);
23819 
23820     print_VkImageLayout(obj->finalLayout, "finalLayout", 0);
23821 
23822     INDENT(-4);
23823     PRINT_SPACE
23824     if (commaNeeded)
23825         _OUT << "}," << std::endl;
23826     else
23827         _OUT << "}" << std::endl;
23828 }
23829 
print_VkAttachmentReference2(VkAttachmentReference2 obj,const std::string & s,bool commaNeeded=true)23830 static void print_VkAttachmentReference2(VkAttachmentReference2 obj, const std::string &s, bool commaNeeded = true)
23831 {
23832     PRINT_SPACE
23833     _OUT << "{" << std::endl;
23834     INDENT(4);
23835 
23836     print_VkStructureType(obj.sType, "sType", 1);
23837 
23838     if (obj.pNext)
23839     {
23840         dumpPNextChain(obj.pNext);
23841     }
23842     else
23843     {
23844         PRINT_SPACE
23845         _OUT << "\"pNext\":"
23846              << "\"NULL\""
23847              << "," << std::endl;
23848     }
23849 
23850     print_uint32_t(obj.attachment, "attachment", 1);
23851 
23852     print_VkImageLayout(obj.layout, "layout", 1);
23853 
23854     print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 0);
23855 
23856     INDENT(-4);
23857     PRINT_SPACE
23858     if (commaNeeded)
23859         _OUT << "}," << std::endl;
23860     else
23861         _OUT << "}" << std::endl;
23862 }
print_VkAttachmentReference2(const VkAttachmentReference2 * obj,const std::string & s,bool commaNeeded=true)23863 static void print_VkAttachmentReference2(const VkAttachmentReference2 *obj, const std::string &s,
23864                                          bool commaNeeded = true)
23865 {
23866     PRINT_SPACE
23867     _OUT << "{" << std::endl;
23868     INDENT(4);
23869 
23870     print_VkStructureType(obj->sType, "sType", 1);
23871 
23872     if (obj->pNext)
23873     {
23874         dumpPNextChain(obj->pNext);
23875     }
23876     else
23877     {
23878         PRINT_SPACE
23879         _OUT << "\"pNext\":"
23880              << "\"NULL\""
23881              << "," << std::endl;
23882     }
23883 
23884     print_uint32_t(obj->attachment, "attachment", 1);
23885 
23886     print_VkImageLayout(obj->layout, "layout", 1);
23887 
23888     print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 0);
23889 
23890     INDENT(-4);
23891     PRINT_SPACE
23892     if (commaNeeded)
23893         _OUT << "}," << std::endl;
23894     else
23895         _OUT << "}" << std::endl;
23896 }
23897 
print_VkSubpassDescription2(VkSubpassDescription2 obj,const std::string & s,bool commaNeeded=true)23898 static void print_VkSubpassDescription2(VkSubpassDescription2 obj, const std::string &s, bool commaNeeded = true)
23899 {
23900     PRINT_SPACE
23901     _OUT << "{" << std::endl;
23902     INDENT(4);
23903 
23904     print_VkStructureType(obj.sType, "sType", 1);
23905 
23906     if (obj.pNext)
23907     {
23908         dumpPNextChain(obj.pNext);
23909     }
23910     else
23911     {
23912         PRINT_SPACE
23913         _OUT << "\"pNext\":"
23914              << "\"NULL\""
23915              << "," << std::endl;
23916     }
23917 
23918     print_VkSubpassDescriptionFlags(obj.flags, "flags", 1);
23919 
23920     print_VkPipelineBindPoint(obj.pipelineBindPoint, "pipelineBindPoint", 1);
23921 
23922     print_uint32_t(obj.viewMask, "viewMask", 1);
23923 
23924     print_uint32_t(obj.inputAttachmentCount, "inputAttachmentCount", 1);
23925 
23926     PRINT_SPACE
23927     _OUT << "\"pInputAttachments\": " << std::endl;
23928     if (obj.pInputAttachments)
23929     {
23930         PRINT_SPACE
23931         _OUT << "[" << std::endl;
23932         for (unsigned int i = 0; i < obj.inputAttachmentCount; i++)
23933         {
23934             if (i + 1 == obj.inputAttachmentCount)
23935                 print_VkAttachmentReference2(obj.pInputAttachments[i], "pInputAttachments", 0);
23936             else
23937                 print_VkAttachmentReference2(obj.pInputAttachments[i], "pInputAttachments", 1);
23938         }
23939         PRINT_SPACE
23940         _OUT << "]," << std::endl;
23941     }
23942     else
23943     {
23944         PRINT_SPACE _OUT << "\"NULL\""
23945                          << "," << std::endl;
23946     }
23947 
23948     print_uint32_t(obj.colorAttachmentCount, "colorAttachmentCount", 1);
23949 
23950     PRINT_SPACE
23951     _OUT << "\"pColorAttachments\": " << std::endl;
23952     if (obj.pColorAttachments)
23953     {
23954         PRINT_SPACE
23955         _OUT << "[" << std::endl;
23956         for (unsigned int i = 0; i < obj.colorAttachmentCount; i++)
23957         {
23958             if (i + 1 == obj.colorAttachmentCount)
23959                 print_VkAttachmentReference2(obj.pColorAttachments[i], "pColorAttachments", 0);
23960             else
23961                 print_VkAttachmentReference2(obj.pColorAttachments[i], "pColorAttachments", 1);
23962         }
23963         PRINT_SPACE
23964         _OUT << "]," << std::endl;
23965     }
23966     else
23967     {
23968         PRINT_SPACE _OUT << "\"NULL\""
23969                          << "," << std::endl;
23970     }
23971 
23972     PRINT_SPACE
23973     _OUT << "\"pResolveAttachments\": " << std::endl;
23974     if (obj.pResolveAttachments)
23975     {
23976         PRINT_SPACE
23977         _OUT << "[" << std::endl;
23978         for (unsigned int i = 0; i < obj.colorAttachmentCount; i++)
23979         {
23980             if (i + 1 == obj.colorAttachmentCount)
23981                 print_VkAttachmentReference2(obj.pResolveAttachments[i], "pResolveAttachments", 0);
23982             else
23983                 print_VkAttachmentReference2(obj.pResolveAttachments[i], "pResolveAttachments", 1);
23984         }
23985         PRINT_SPACE
23986         _OUT << "]," << std::endl;
23987     }
23988     else
23989     {
23990         PRINT_SPACE _OUT << "\"NULL\""
23991                          << "," << std::endl;
23992     }
23993 
23994     PRINT_SPACE
23995     _OUT << "\"pDepthStencilAttachment\": " << std::endl;
23996     if (obj.pDepthStencilAttachment)
23997     {
23998         print_VkAttachmentReference2(obj.pDepthStencilAttachment, "pDepthStencilAttachment", 1);
23999     }
24000     else
24001     {
24002         PRINT_SPACE _OUT << "\"NULL\""
24003                          << "," << std::endl;
24004     }
24005 
24006     print_uint32_t(obj.preserveAttachmentCount, "preserveAttachmentCount", 1);
24007 
24008     PRINT_SPACE
24009     _OUT << "\"pPreserveAttachments\":" << std::endl;
24010     PRINT_SPACE
24011     if (obj.pPreserveAttachments)
24012     {
24013         _OUT << "[" << std::endl;
24014         for (unsigned int i = 0; i < obj.preserveAttachmentCount; i++)
24015         {
24016             bool isCommaNeeded = (i + 1) != obj.preserveAttachmentCount;
24017             print_uint32_t(obj.pPreserveAttachments[i], "", isCommaNeeded);
24018         }
24019         PRINT_SPACE
24020         _OUT << "]"
24021              << "" << std::endl;
24022     }
24023     else
24024     {
24025         _OUT << "\"NULL\""
24026              << "" << std::endl;
24027     }
24028 
24029     INDENT(-4);
24030     PRINT_SPACE
24031     if (commaNeeded)
24032         _OUT << "}," << std::endl;
24033     else
24034         _OUT << "}" << std::endl;
24035 }
print_VkSubpassDescription2(const VkSubpassDescription2 * obj,const std::string & s,bool commaNeeded=true)24036 static void print_VkSubpassDescription2(const VkSubpassDescription2 *obj, const std::string &s, bool commaNeeded = true)
24037 {
24038     PRINT_SPACE
24039     _OUT << "{" << std::endl;
24040     INDENT(4);
24041 
24042     print_VkStructureType(obj->sType, "sType", 1);
24043 
24044     if (obj->pNext)
24045     {
24046         dumpPNextChain(obj->pNext);
24047     }
24048     else
24049     {
24050         PRINT_SPACE
24051         _OUT << "\"pNext\":"
24052              << "\"NULL\""
24053              << "," << std::endl;
24054     }
24055 
24056     print_VkSubpassDescriptionFlags(obj->flags, "flags", 1);
24057 
24058     print_VkPipelineBindPoint(obj->pipelineBindPoint, "pipelineBindPoint", 1);
24059 
24060     print_uint32_t(obj->viewMask, "viewMask", 1);
24061 
24062     print_uint32_t(obj->inputAttachmentCount, "inputAttachmentCount", 1);
24063 
24064     PRINT_SPACE
24065     _OUT << "\"pInputAttachments\": " << std::endl;
24066     if (obj->pInputAttachments)
24067     {
24068         PRINT_SPACE
24069         _OUT << "[" << std::endl;
24070         for (unsigned int i = 0; i < obj->inputAttachmentCount; i++)
24071         {
24072             if (i + 1 == obj->inputAttachmentCount)
24073                 print_VkAttachmentReference2(obj->pInputAttachments[i], "pInputAttachments", 0);
24074             else
24075                 print_VkAttachmentReference2(obj->pInputAttachments[i], "pInputAttachments", 1);
24076         }
24077         PRINT_SPACE
24078         _OUT << "]," << std::endl;
24079     }
24080     else
24081     {
24082         PRINT_SPACE _OUT << "\"NULL\""
24083                          << "," << std::endl;
24084     }
24085 
24086     print_uint32_t(obj->colorAttachmentCount, "colorAttachmentCount", 1);
24087 
24088     PRINT_SPACE
24089     _OUT << "\"pColorAttachments\": " << std::endl;
24090     if (obj->pColorAttachments)
24091     {
24092         PRINT_SPACE
24093         _OUT << "[" << std::endl;
24094         for (unsigned int i = 0; i < obj->colorAttachmentCount; i++)
24095         {
24096             if (i + 1 == obj->colorAttachmentCount)
24097                 print_VkAttachmentReference2(obj->pColorAttachments[i], "pColorAttachments", 0);
24098             else
24099                 print_VkAttachmentReference2(obj->pColorAttachments[i], "pColorAttachments", 1);
24100         }
24101         PRINT_SPACE
24102         _OUT << "]," << std::endl;
24103     }
24104     else
24105     {
24106         PRINT_SPACE _OUT << "\"NULL\""
24107                          << "," << std::endl;
24108     }
24109 
24110     PRINT_SPACE
24111     _OUT << "\"pResolveAttachments\": " << std::endl;
24112     if (obj->pResolveAttachments)
24113     {
24114         PRINT_SPACE
24115         _OUT << "[" << std::endl;
24116         for (unsigned int i = 0; i < obj->colorAttachmentCount; i++)
24117         {
24118             if (i + 1 == obj->colorAttachmentCount)
24119                 print_VkAttachmentReference2(obj->pResolveAttachments[i], "pResolveAttachments", 0);
24120             else
24121                 print_VkAttachmentReference2(obj->pResolveAttachments[i], "pResolveAttachments", 1);
24122         }
24123         PRINT_SPACE
24124         _OUT << "]," << std::endl;
24125     }
24126     else
24127     {
24128         PRINT_SPACE _OUT << "\"NULL\""
24129                          << "," << std::endl;
24130     }
24131 
24132     PRINT_SPACE
24133     _OUT << "\"pDepthStencilAttachment\": " << std::endl;
24134     if (obj->pDepthStencilAttachment)
24135     {
24136         print_VkAttachmentReference2(obj->pDepthStencilAttachment, "pDepthStencilAttachment", 1);
24137     }
24138     else
24139     {
24140         PRINT_SPACE _OUT << "\"NULL\""
24141                          << "," << std::endl;
24142     }
24143 
24144     print_uint32_t(obj->preserveAttachmentCount, "preserveAttachmentCount", 1);
24145 
24146     PRINT_SPACE
24147     _OUT << "\"pPreserveAttachments\":" << std::endl;
24148     PRINT_SPACE
24149     if (obj->pPreserveAttachments)
24150     {
24151         _OUT << "[" << std::endl;
24152         for (unsigned int i = 0; i < obj->preserveAttachmentCount; i++)
24153         {
24154             bool isCommaNeeded = (i + 1) != obj->preserveAttachmentCount;
24155             print_uint32_t(obj->pPreserveAttachments[i], "", isCommaNeeded);
24156         }
24157         PRINT_SPACE
24158         _OUT << "]"
24159              << "" << std::endl;
24160     }
24161     else
24162     {
24163         _OUT << "\"NULL\""
24164              << "" << std::endl;
24165     }
24166 
24167     INDENT(-4);
24168     PRINT_SPACE
24169     if (commaNeeded)
24170         _OUT << "}," << std::endl;
24171     else
24172         _OUT << "}" << std::endl;
24173 }
24174 
print_VkSubpassDependency2(VkSubpassDependency2 obj,const std::string & s,bool commaNeeded=true)24175 static void print_VkSubpassDependency2(VkSubpassDependency2 obj, const std::string &s, bool commaNeeded = true)
24176 {
24177     PRINT_SPACE
24178     _OUT << "{" << std::endl;
24179     INDENT(4);
24180 
24181     print_VkStructureType(obj.sType, "sType", 1);
24182 
24183     if (obj.pNext)
24184     {
24185         dumpPNextChain(obj.pNext);
24186     }
24187     else
24188     {
24189         PRINT_SPACE
24190         _OUT << "\"pNext\":"
24191              << "\"NULL\""
24192              << "," << std::endl;
24193     }
24194 
24195     print_uint32_t(obj.srcSubpass, "srcSubpass", 1);
24196 
24197     print_uint32_t(obj.dstSubpass, "dstSubpass", 1);
24198 
24199     print_VkPipelineStageFlags(obj.srcStageMask, "srcStageMask", 1);
24200 
24201     print_VkPipelineStageFlags(obj.dstStageMask, "dstStageMask", 1);
24202 
24203     print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1);
24204 
24205     print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 1);
24206 
24207     print_VkDependencyFlags(obj.dependencyFlags, "dependencyFlags", 1);
24208 
24209     print_int32_t(obj.viewOffset, "viewOffset", 0);
24210 
24211     INDENT(-4);
24212     PRINT_SPACE
24213     if (commaNeeded)
24214         _OUT << "}," << std::endl;
24215     else
24216         _OUT << "}" << std::endl;
24217 }
print_VkSubpassDependency2(const VkSubpassDependency2 * obj,const std::string & s,bool commaNeeded=true)24218 static void print_VkSubpassDependency2(const VkSubpassDependency2 *obj, const std::string &s, bool commaNeeded = true)
24219 {
24220     PRINT_SPACE
24221     _OUT << "{" << std::endl;
24222     INDENT(4);
24223 
24224     print_VkStructureType(obj->sType, "sType", 1);
24225 
24226     if (obj->pNext)
24227     {
24228         dumpPNextChain(obj->pNext);
24229     }
24230     else
24231     {
24232         PRINT_SPACE
24233         _OUT << "\"pNext\":"
24234              << "\"NULL\""
24235              << "," << std::endl;
24236     }
24237 
24238     print_uint32_t(obj->srcSubpass, "srcSubpass", 1);
24239 
24240     print_uint32_t(obj->dstSubpass, "dstSubpass", 1);
24241 
24242     print_VkPipelineStageFlags(obj->srcStageMask, "srcStageMask", 1);
24243 
24244     print_VkPipelineStageFlags(obj->dstStageMask, "dstStageMask", 1);
24245 
24246     print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1);
24247 
24248     print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 1);
24249 
24250     print_VkDependencyFlags(obj->dependencyFlags, "dependencyFlags", 1);
24251 
24252     print_int32_t(obj->viewOffset, "viewOffset", 0);
24253 
24254     INDENT(-4);
24255     PRINT_SPACE
24256     if (commaNeeded)
24257         _OUT << "}," << std::endl;
24258     else
24259         _OUT << "}" << std::endl;
24260 }
24261 
print_VkRenderPassCreateInfo2(VkRenderPassCreateInfo2 obj,const std::string & s,bool commaNeeded=true)24262 static void print_VkRenderPassCreateInfo2(VkRenderPassCreateInfo2 obj, const std::string &s, bool commaNeeded = true)
24263 {
24264     PRINT_SPACE
24265     _OUT << "{" << std::endl;
24266     INDENT(4);
24267 
24268     print_VkStructureType(obj.sType, "sType", 1);
24269 
24270     if (obj.pNext)
24271     {
24272         dumpPNextChain(obj.pNext);
24273     }
24274     else
24275     {
24276         PRINT_SPACE
24277         _OUT << "\"pNext\":"
24278              << "\"NULL\""
24279              << "," << std::endl;
24280     }
24281 
24282     print_VkRenderPassCreateFlags(obj.flags, "flags", 1);
24283 
24284     print_uint32_t(obj.attachmentCount, "attachmentCount", 1);
24285 
24286     PRINT_SPACE
24287     _OUT << "\"pAttachments\": " << std::endl;
24288     if (obj.pAttachments)
24289     {
24290         PRINT_SPACE
24291         _OUT << "[" << std::endl;
24292         for (unsigned int i = 0; i < obj.attachmentCount; i++)
24293         {
24294             if (i + 1 == obj.attachmentCount)
24295                 print_VkAttachmentDescription2(obj.pAttachments[i], "pAttachments", 0);
24296             else
24297                 print_VkAttachmentDescription2(obj.pAttachments[i], "pAttachments", 1);
24298         }
24299         PRINT_SPACE
24300         _OUT << "]," << std::endl;
24301     }
24302     else
24303     {
24304         PRINT_SPACE _OUT << "\"NULL\""
24305                          << "," << std::endl;
24306     }
24307 
24308     print_uint32_t(obj.subpassCount, "subpassCount", 1);
24309 
24310     PRINT_SPACE
24311     _OUT << "\"pSubpasses\": " << std::endl;
24312     if (obj.pSubpasses)
24313     {
24314         PRINT_SPACE
24315         _OUT << "[" << std::endl;
24316         for (unsigned int i = 0; i < obj.subpassCount; i++)
24317         {
24318             if (i + 1 == obj.subpassCount)
24319                 print_VkSubpassDescription2(obj.pSubpasses[i], "pSubpasses", 0);
24320             else
24321                 print_VkSubpassDescription2(obj.pSubpasses[i], "pSubpasses", 1);
24322         }
24323         PRINT_SPACE
24324         _OUT << "]," << std::endl;
24325     }
24326     else
24327     {
24328         PRINT_SPACE _OUT << "\"NULL\""
24329                          << "," << std::endl;
24330     }
24331 
24332     print_uint32_t(obj.dependencyCount, "dependencyCount", 1);
24333 
24334     PRINT_SPACE
24335     _OUT << "\"pDependencies\": " << std::endl;
24336     if (obj.pDependencies)
24337     {
24338         PRINT_SPACE
24339         _OUT << "[" << std::endl;
24340         for (unsigned int i = 0; i < obj.dependencyCount; i++)
24341         {
24342             if (i + 1 == obj.dependencyCount)
24343                 print_VkSubpassDependency2(obj.pDependencies[i], "pDependencies", 0);
24344             else
24345                 print_VkSubpassDependency2(obj.pDependencies[i], "pDependencies", 1);
24346         }
24347         PRINT_SPACE
24348         _OUT << "]," << std::endl;
24349     }
24350     else
24351     {
24352         PRINT_SPACE _OUT << "\"NULL\""
24353                          << "," << std::endl;
24354     }
24355 
24356     print_uint32_t(obj.correlatedViewMaskCount, "correlatedViewMaskCount", 1);
24357 
24358     PRINT_SPACE
24359     _OUT << "\"pCorrelatedViewMasks\":" << std::endl;
24360     PRINT_SPACE
24361     if (obj.pCorrelatedViewMasks)
24362     {
24363         _OUT << "[" << std::endl;
24364         for (unsigned int i = 0; i < obj.correlatedViewMaskCount; i++)
24365         {
24366             bool isCommaNeeded = (i + 1) != obj.correlatedViewMaskCount;
24367             print_uint32_t(obj.pCorrelatedViewMasks[i], "", isCommaNeeded);
24368         }
24369         PRINT_SPACE
24370         _OUT << "]"
24371              << "" << std::endl;
24372     }
24373     else
24374     {
24375         _OUT << "\"NULL\""
24376              << "" << std::endl;
24377     }
24378 
24379     INDENT(-4);
24380     PRINT_SPACE
24381     if (commaNeeded)
24382         _OUT << "}," << std::endl;
24383     else
24384         _OUT << "}" << std::endl;
24385 }
print_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2 * obj,const std::string & s,bool commaNeeded=true)24386 static void print_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2 *obj, const std::string &s,
24387                                           bool commaNeeded = true)
24388 {
24389     PRINT_SPACE
24390     _OUT << "{" << std::endl;
24391     INDENT(4);
24392 
24393     print_VkStructureType(obj->sType, "sType", 1);
24394 
24395     if (obj->pNext)
24396     {
24397         dumpPNextChain(obj->pNext);
24398     }
24399     else
24400     {
24401         PRINT_SPACE
24402         _OUT << "\"pNext\":"
24403              << "\"NULL\""
24404              << "," << std::endl;
24405     }
24406 
24407     print_VkRenderPassCreateFlags(obj->flags, "flags", 1);
24408 
24409     print_uint32_t(obj->attachmentCount, "attachmentCount", 1);
24410 
24411     PRINT_SPACE
24412     _OUT << "\"pAttachments\": " << std::endl;
24413     if (obj->pAttachments)
24414     {
24415         PRINT_SPACE
24416         _OUT << "[" << std::endl;
24417         for (unsigned int i = 0; i < obj->attachmentCount; i++)
24418         {
24419             if (i + 1 == obj->attachmentCount)
24420                 print_VkAttachmentDescription2(obj->pAttachments[i], "pAttachments", 0);
24421             else
24422                 print_VkAttachmentDescription2(obj->pAttachments[i], "pAttachments", 1);
24423         }
24424         PRINT_SPACE
24425         _OUT << "]," << std::endl;
24426     }
24427     else
24428     {
24429         PRINT_SPACE _OUT << "\"NULL\""
24430                          << "," << std::endl;
24431     }
24432 
24433     print_uint32_t(obj->subpassCount, "subpassCount", 1);
24434 
24435     PRINT_SPACE
24436     _OUT << "\"pSubpasses\": " << std::endl;
24437     if (obj->pSubpasses)
24438     {
24439         PRINT_SPACE
24440         _OUT << "[" << std::endl;
24441         for (unsigned int i = 0; i < obj->subpassCount; i++)
24442         {
24443             if (i + 1 == obj->subpassCount)
24444                 print_VkSubpassDescription2(obj->pSubpasses[i], "pSubpasses", 0);
24445             else
24446                 print_VkSubpassDescription2(obj->pSubpasses[i], "pSubpasses", 1);
24447         }
24448         PRINT_SPACE
24449         _OUT << "]," << std::endl;
24450     }
24451     else
24452     {
24453         PRINT_SPACE _OUT << "\"NULL\""
24454                          << "," << std::endl;
24455     }
24456 
24457     print_uint32_t(obj->dependencyCount, "dependencyCount", 1);
24458 
24459     PRINT_SPACE
24460     _OUT << "\"pDependencies\": " << std::endl;
24461     if (obj->pDependencies)
24462     {
24463         PRINT_SPACE
24464         _OUT << "[" << std::endl;
24465         for (unsigned int i = 0; i < obj->dependencyCount; i++)
24466         {
24467             if (i + 1 == obj->dependencyCount)
24468                 print_VkSubpassDependency2(obj->pDependencies[i], "pDependencies", 0);
24469             else
24470                 print_VkSubpassDependency2(obj->pDependencies[i], "pDependencies", 1);
24471         }
24472         PRINT_SPACE
24473         _OUT << "]," << std::endl;
24474     }
24475     else
24476     {
24477         PRINT_SPACE _OUT << "\"NULL\""
24478                          << "," << std::endl;
24479     }
24480 
24481     print_uint32_t(obj->correlatedViewMaskCount, "correlatedViewMaskCount", 1);
24482 
24483     PRINT_SPACE
24484     _OUT << "\"pCorrelatedViewMasks\":" << std::endl;
24485     PRINT_SPACE
24486     if (obj->pCorrelatedViewMasks)
24487     {
24488         _OUT << "[" << std::endl;
24489         for (unsigned int i = 0; i < obj->correlatedViewMaskCount; i++)
24490         {
24491             bool isCommaNeeded = (i + 1) != obj->correlatedViewMaskCount;
24492             print_uint32_t(obj->pCorrelatedViewMasks[i], "", isCommaNeeded);
24493         }
24494         PRINT_SPACE
24495         _OUT << "]"
24496              << "" << std::endl;
24497     }
24498     else
24499     {
24500         _OUT << "\"NULL\""
24501              << "" << std::endl;
24502     }
24503 
24504     INDENT(-4);
24505     PRINT_SPACE
24506     if (commaNeeded)
24507         _OUT << "}," << std::endl;
24508     else
24509         _OUT << "}" << std::endl;
24510 }
24511 
print_VkSubpassBeginInfo(VkSubpassBeginInfo obj,const std::string & s,bool commaNeeded=true)24512 static void print_VkSubpassBeginInfo(VkSubpassBeginInfo obj, const std::string &s, bool commaNeeded = true)
24513 {
24514     PRINT_SPACE
24515     _OUT << "{" << std::endl;
24516     INDENT(4);
24517 
24518     print_VkStructureType(obj.sType, "sType", 1);
24519 
24520     if (obj.pNext)
24521     {
24522         dumpPNextChain(obj.pNext);
24523     }
24524     else
24525     {
24526         PRINT_SPACE
24527         _OUT << "\"pNext\":"
24528              << "\"NULL\""
24529              << "," << std::endl;
24530     }
24531 
24532     print_VkSubpassContents(obj.contents, "contents", 0);
24533 
24534     INDENT(-4);
24535     PRINT_SPACE
24536     if (commaNeeded)
24537         _OUT << "}," << std::endl;
24538     else
24539         _OUT << "}" << std::endl;
24540 }
print_VkSubpassBeginInfo(const VkSubpassBeginInfo * obj,const std::string & s,bool commaNeeded=true)24541 static void print_VkSubpassBeginInfo(const VkSubpassBeginInfo *obj, const std::string &s, bool commaNeeded = true)
24542 {
24543     PRINT_SPACE
24544     _OUT << "{" << std::endl;
24545     INDENT(4);
24546 
24547     print_VkStructureType(obj->sType, "sType", 1);
24548 
24549     if (obj->pNext)
24550     {
24551         dumpPNextChain(obj->pNext);
24552     }
24553     else
24554     {
24555         PRINT_SPACE
24556         _OUT << "\"pNext\":"
24557              << "\"NULL\""
24558              << "," << std::endl;
24559     }
24560 
24561     print_VkSubpassContents(obj->contents, "contents", 0);
24562 
24563     INDENT(-4);
24564     PRINT_SPACE
24565     if (commaNeeded)
24566         _OUT << "}," << std::endl;
24567     else
24568         _OUT << "}" << std::endl;
24569 }
24570 
print_VkSubpassEndInfo(VkSubpassEndInfo obj,const std::string & s,bool commaNeeded=true)24571 static void print_VkSubpassEndInfo(VkSubpassEndInfo obj, const std::string &s, bool commaNeeded = true)
24572 {
24573     PRINT_SPACE
24574     _OUT << "{" << std::endl;
24575     INDENT(4);
24576 
24577     print_VkStructureType(obj.sType, "sType", 1);
24578 
24579     if (obj.pNext)
24580     {
24581         dumpPNextChain(obj.pNext);
24582     }
24583     else
24584     {
24585         PRINT_SPACE
24586         _OUT << "\"pNext\":"
24587              << "\"NULL\""
24588              << "," << std::endl;
24589     }
24590 
24591     INDENT(-4);
24592     PRINT_SPACE
24593     if (commaNeeded)
24594         _OUT << "}," << std::endl;
24595     else
24596         _OUT << "}" << std::endl;
24597 }
print_VkSubpassEndInfo(const VkSubpassEndInfo * obj,const std::string & s,bool commaNeeded=true)24598 static void print_VkSubpassEndInfo(const VkSubpassEndInfo *obj, const std::string &s, bool commaNeeded = true)
24599 {
24600     PRINT_SPACE
24601     _OUT << "{" << std::endl;
24602     INDENT(4);
24603 
24604     print_VkStructureType(obj->sType, "sType", 1);
24605 
24606     if (obj->pNext)
24607     {
24608         dumpPNextChain(obj->pNext);
24609     }
24610     else
24611     {
24612         PRINT_SPACE
24613         _OUT << "\"pNext\":"
24614              << "\"NULL\""
24615              << "," << std::endl;
24616     }
24617 
24618     INDENT(-4);
24619     PRINT_SPACE
24620     if (commaNeeded)
24621         _OUT << "}," << std::endl;
24622     else
24623         _OUT << "}" << std::endl;
24624 }
24625 
print_VkPhysicalDevice8BitStorageFeatures(VkPhysicalDevice8BitStorageFeatures obj,const std::string & s,bool commaNeeded=true)24626 static void print_VkPhysicalDevice8BitStorageFeatures(VkPhysicalDevice8BitStorageFeatures obj, const std::string &s,
24627                                                       bool commaNeeded = true)
24628 {
24629     PRINT_SPACE
24630     _OUT << "{" << std::endl;
24631     INDENT(4);
24632 
24633     print_VkStructureType(obj.sType, "sType", 1);
24634 
24635     if (obj.pNext)
24636     {
24637         dumpPNextChain(obj.pNext);
24638     }
24639     else
24640     {
24641         PRINT_SPACE
24642         _OUT << "\"pNext\":"
24643              << "\"NULL\""
24644              << "," << std::endl;
24645     }
24646 
24647     print_VkBool32(obj.storageBuffer8BitAccess, "storageBuffer8BitAccess", 1);
24648 
24649     print_VkBool32(obj.uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1);
24650 
24651     print_VkBool32(obj.storagePushConstant8, "storagePushConstant8", 0);
24652 
24653     INDENT(-4);
24654     PRINT_SPACE
24655     if (commaNeeded)
24656         _OUT << "}," << std::endl;
24657     else
24658         _OUT << "}" << std::endl;
24659 }
print_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures * obj,const std::string & s,bool commaNeeded=true)24660 static void print_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures *obj,
24661                                                       const std::string &s, bool commaNeeded = true)
24662 {
24663     PRINT_SPACE
24664     _OUT << "{" << std::endl;
24665     INDENT(4);
24666 
24667     print_VkStructureType(obj->sType, "sType", 1);
24668 
24669     if (obj->pNext)
24670     {
24671         dumpPNextChain(obj->pNext);
24672     }
24673     else
24674     {
24675         PRINT_SPACE
24676         _OUT << "\"pNext\":"
24677              << "\"NULL\""
24678              << "," << std::endl;
24679     }
24680 
24681     print_VkBool32(obj->storageBuffer8BitAccess, "storageBuffer8BitAccess", 1);
24682 
24683     print_VkBool32(obj->uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1);
24684 
24685     print_VkBool32(obj->storagePushConstant8, "storagePushConstant8", 0);
24686 
24687     INDENT(-4);
24688     PRINT_SPACE
24689     if (commaNeeded)
24690         _OUT << "}," << std::endl;
24691     else
24692         _OUT << "}" << std::endl;
24693 }
24694 
print_VkPhysicalDeviceDriverProperties(VkPhysicalDeviceDriverProperties obj,const std::string & s,bool commaNeeded=true)24695 static void print_VkPhysicalDeviceDriverProperties(VkPhysicalDeviceDriverProperties obj, const std::string &s,
24696                                                    bool commaNeeded = true)
24697 {
24698     PRINT_SPACE
24699     _OUT << "{" << std::endl;
24700     INDENT(4);
24701 
24702     print_VkStructureType(obj.sType, "sType", 1);
24703 
24704     if (obj.pNext)
24705     {
24706         dumpPNextChain(obj.pNext);
24707     }
24708     else
24709     {
24710         PRINT_SPACE
24711         _OUT << "\"pNext\":"
24712              << "\"NULL\""
24713              << "," << std::endl;
24714     }
24715 
24716     print_VkDriverId(obj.driverID, "driverID", 1);
24717 
24718     PRINT_SPACE
24719     _OUT << "\"driverName\":" << std::endl;
24720     PRINT_SPACE
24721     _OUT << "[" << std::endl;
24722     for (unsigned int i = 0; i < VK_MAX_DRIVER_NAME_SIZE; i++)
24723     {
24724         bool isCommaNeeded = (i + 1) != VK_MAX_DRIVER_NAME_SIZE;
24725         print_char(obj.driverName[i], "", isCommaNeeded);
24726     }
24727     PRINT_SPACE
24728     _OUT << "]"
24729          << "," << std::endl;
24730 
24731     PRINT_SPACE
24732     _OUT << "\"driverInfo\":" << std::endl;
24733     PRINT_SPACE
24734     _OUT << "[" << std::endl;
24735     for (unsigned int i = 0; i < VK_MAX_DRIVER_INFO_SIZE; i++)
24736     {
24737         bool isCommaNeeded = (i + 1) != VK_MAX_DRIVER_INFO_SIZE;
24738         print_char(obj.driverInfo[i], "", isCommaNeeded);
24739     }
24740     PRINT_SPACE
24741     _OUT << "]"
24742          << "," << std::endl;
24743 
24744     PRINT_SPACE
24745     _OUT << "\"conformanceVersion\": " << std::endl;
24746     {
24747         print_VkConformanceVersion(obj.conformanceVersion, "conformanceVersion", 0);
24748     }
24749 
24750     INDENT(-4);
24751     PRINT_SPACE
24752     if (commaNeeded)
24753         _OUT << "}," << std::endl;
24754     else
24755         _OUT << "}" << std::endl;
24756 }
print_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties * obj,const std::string & s,bool commaNeeded=true)24757 static void print_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties *obj, const std::string &s,
24758                                                    bool commaNeeded = true)
24759 {
24760     PRINT_SPACE
24761     _OUT << "{" << std::endl;
24762     INDENT(4);
24763 
24764     print_VkStructureType(obj->sType, "sType", 1);
24765 
24766     if (obj->pNext)
24767     {
24768         dumpPNextChain(obj->pNext);
24769     }
24770     else
24771     {
24772         PRINT_SPACE
24773         _OUT << "\"pNext\":"
24774              << "\"NULL\""
24775              << "," << std::endl;
24776     }
24777 
24778     print_VkDriverId(obj->driverID, "driverID", 1);
24779 
24780     PRINT_SPACE
24781     _OUT << "\"driverName\":" << std::endl;
24782     PRINT_SPACE
24783     _OUT << "[" << std::endl;
24784     for (unsigned int i = 0; i < VK_MAX_DRIVER_NAME_SIZE; i++)
24785     {
24786         bool isCommaNeeded = (i + 1) != VK_MAX_DRIVER_NAME_SIZE;
24787         print_char(obj->driverName[i], "", isCommaNeeded);
24788     }
24789     PRINT_SPACE
24790     _OUT << "]"
24791          << "," << std::endl;
24792 
24793     PRINT_SPACE
24794     _OUT << "\"driverInfo\":" << std::endl;
24795     PRINT_SPACE
24796     _OUT << "[" << std::endl;
24797     for (unsigned int i = 0; i < VK_MAX_DRIVER_INFO_SIZE; i++)
24798     {
24799         bool isCommaNeeded = (i + 1) != VK_MAX_DRIVER_INFO_SIZE;
24800         print_char(obj->driverInfo[i], "", isCommaNeeded);
24801     }
24802     PRINT_SPACE
24803     _OUT << "]"
24804          << "," << std::endl;
24805 
24806     PRINT_SPACE
24807     _OUT << "\"conformanceVersion\": " << std::endl;
24808     {
24809         print_VkConformanceVersion(obj->conformanceVersion, "conformanceVersion", 0);
24810     }
24811 
24812     INDENT(-4);
24813     PRINT_SPACE
24814     if (commaNeeded)
24815         _OUT << "}," << std::endl;
24816     else
24817         _OUT << "}" << std::endl;
24818 }
24819 
print_VkPhysicalDeviceShaderAtomicInt64Features(VkPhysicalDeviceShaderAtomicInt64Features obj,const std::string & s,bool commaNeeded=true)24820 static void print_VkPhysicalDeviceShaderAtomicInt64Features(VkPhysicalDeviceShaderAtomicInt64Features obj,
24821                                                             const std::string &s, bool commaNeeded = true)
24822 {
24823     PRINT_SPACE
24824     _OUT << "{" << std::endl;
24825     INDENT(4);
24826 
24827     print_VkStructureType(obj.sType, "sType", 1);
24828 
24829     if (obj.pNext)
24830     {
24831         dumpPNextChain(obj.pNext);
24832     }
24833     else
24834     {
24835         PRINT_SPACE
24836         _OUT << "\"pNext\":"
24837              << "\"NULL\""
24838              << "," << std::endl;
24839     }
24840 
24841     print_VkBool32(obj.shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1);
24842 
24843     print_VkBool32(obj.shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 0);
24844 
24845     INDENT(-4);
24846     PRINT_SPACE
24847     if (commaNeeded)
24848         _OUT << "}," << std::endl;
24849     else
24850         _OUT << "}" << std::endl;
24851 }
print_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features * obj,const std::string & s,bool commaNeeded=true)24852 static void print_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features *obj,
24853                                                             const std::string &s, bool commaNeeded = true)
24854 {
24855     PRINT_SPACE
24856     _OUT << "{" << std::endl;
24857     INDENT(4);
24858 
24859     print_VkStructureType(obj->sType, "sType", 1);
24860 
24861     if (obj->pNext)
24862     {
24863         dumpPNextChain(obj->pNext);
24864     }
24865     else
24866     {
24867         PRINT_SPACE
24868         _OUT << "\"pNext\":"
24869              << "\"NULL\""
24870              << "," << std::endl;
24871     }
24872 
24873     print_VkBool32(obj->shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1);
24874 
24875     print_VkBool32(obj->shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 0);
24876 
24877     INDENT(-4);
24878     PRINT_SPACE
24879     if (commaNeeded)
24880         _OUT << "}," << std::endl;
24881     else
24882         _OUT << "}" << std::endl;
24883 }
24884 
print_VkPhysicalDeviceShaderFloat16Int8Features(VkPhysicalDeviceShaderFloat16Int8Features obj,const std::string & s,bool commaNeeded=true)24885 static void print_VkPhysicalDeviceShaderFloat16Int8Features(VkPhysicalDeviceShaderFloat16Int8Features obj,
24886                                                             const std::string &s, bool commaNeeded = true)
24887 {
24888     PRINT_SPACE
24889     _OUT << "{" << std::endl;
24890     INDENT(4);
24891 
24892     print_VkStructureType(obj.sType, "sType", 1);
24893 
24894     if (obj.pNext)
24895     {
24896         dumpPNextChain(obj.pNext);
24897     }
24898     else
24899     {
24900         PRINT_SPACE
24901         _OUT << "\"pNext\":"
24902              << "\"NULL\""
24903              << "," << std::endl;
24904     }
24905 
24906     print_VkBool32(obj.shaderFloat16, "shaderFloat16", 1);
24907 
24908     print_VkBool32(obj.shaderInt8, "shaderInt8", 0);
24909 
24910     INDENT(-4);
24911     PRINT_SPACE
24912     if (commaNeeded)
24913         _OUT << "}," << std::endl;
24914     else
24915         _OUT << "}" << std::endl;
24916 }
print_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features * obj,const std::string & s,bool commaNeeded=true)24917 static void print_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features *obj,
24918                                                             const std::string &s, bool commaNeeded = true)
24919 {
24920     PRINT_SPACE
24921     _OUT << "{" << std::endl;
24922     INDENT(4);
24923 
24924     print_VkStructureType(obj->sType, "sType", 1);
24925 
24926     if (obj->pNext)
24927     {
24928         dumpPNextChain(obj->pNext);
24929     }
24930     else
24931     {
24932         PRINT_SPACE
24933         _OUT << "\"pNext\":"
24934              << "\"NULL\""
24935              << "," << std::endl;
24936     }
24937 
24938     print_VkBool32(obj->shaderFloat16, "shaderFloat16", 1);
24939 
24940     print_VkBool32(obj->shaderInt8, "shaderInt8", 0);
24941 
24942     INDENT(-4);
24943     PRINT_SPACE
24944     if (commaNeeded)
24945         _OUT << "}," << std::endl;
24946     else
24947         _OUT << "}" << std::endl;
24948 }
24949 
print_VkPhysicalDeviceFloatControlsProperties(VkPhysicalDeviceFloatControlsProperties obj,const std::string & s,bool commaNeeded=true)24950 static void print_VkPhysicalDeviceFloatControlsProperties(VkPhysicalDeviceFloatControlsProperties obj,
24951                                                           const std::string &s, bool commaNeeded = true)
24952 {
24953     PRINT_SPACE
24954     _OUT << "{" << std::endl;
24955     INDENT(4);
24956 
24957     print_VkStructureType(obj.sType, "sType", 1);
24958 
24959     if (obj.pNext)
24960     {
24961         dumpPNextChain(obj.pNext);
24962     }
24963     else
24964     {
24965         PRINT_SPACE
24966         _OUT << "\"pNext\":"
24967              << "\"NULL\""
24968              << "," << std::endl;
24969     }
24970 
24971     print_VkShaderFloatControlsIndependence(obj.denormBehaviorIndependence, "denormBehaviorIndependence", 1);
24972 
24973     print_VkShaderFloatControlsIndependence(obj.roundingModeIndependence, "roundingModeIndependence", 1);
24974 
24975     print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1);
24976 
24977     print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1);
24978 
24979     print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1);
24980 
24981     print_VkBool32(obj.shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1);
24982 
24983     print_VkBool32(obj.shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1);
24984 
24985     print_VkBool32(obj.shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1);
24986 
24987     print_VkBool32(obj.shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1);
24988 
24989     print_VkBool32(obj.shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1);
24990 
24991     print_VkBool32(obj.shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1);
24992 
24993     print_VkBool32(obj.shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1);
24994 
24995     print_VkBool32(obj.shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1);
24996 
24997     print_VkBool32(obj.shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1);
24998 
24999     print_VkBool32(obj.shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1);
25000 
25001     print_VkBool32(obj.shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1);
25002 
25003     print_VkBool32(obj.shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 0);
25004 
25005     INDENT(-4);
25006     PRINT_SPACE
25007     if (commaNeeded)
25008         _OUT << "}," << std::endl;
25009     else
25010         _OUT << "}" << std::endl;
25011 }
print_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties * obj,const std::string & s,bool commaNeeded=true)25012 static void print_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties *obj,
25013                                                           const std::string &s, bool commaNeeded = true)
25014 {
25015     PRINT_SPACE
25016     _OUT << "{" << std::endl;
25017     INDENT(4);
25018 
25019     print_VkStructureType(obj->sType, "sType", 1);
25020 
25021     if (obj->pNext)
25022     {
25023         dumpPNextChain(obj->pNext);
25024     }
25025     else
25026     {
25027         PRINT_SPACE
25028         _OUT << "\"pNext\":"
25029              << "\"NULL\""
25030              << "," << std::endl;
25031     }
25032 
25033     print_VkShaderFloatControlsIndependence(obj->denormBehaviorIndependence, "denormBehaviorIndependence", 1);
25034 
25035     print_VkShaderFloatControlsIndependence(obj->roundingModeIndependence, "roundingModeIndependence", 1);
25036 
25037     print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1);
25038 
25039     print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1);
25040 
25041     print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1);
25042 
25043     print_VkBool32(obj->shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1);
25044 
25045     print_VkBool32(obj->shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1);
25046 
25047     print_VkBool32(obj->shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1);
25048 
25049     print_VkBool32(obj->shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1);
25050 
25051     print_VkBool32(obj->shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1);
25052 
25053     print_VkBool32(obj->shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1);
25054 
25055     print_VkBool32(obj->shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1);
25056 
25057     print_VkBool32(obj->shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1);
25058 
25059     print_VkBool32(obj->shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1);
25060 
25061     print_VkBool32(obj->shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1);
25062 
25063     print_VkBool32(obj->shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1);
25064 
25065     print_VkBool32(obj->shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 0);
25066 
25067     INDENT(-4);
25068     PRINT_SPACE
25069     if (commaNeeded)
25070         _OUT << "}," << std::endl;
25071     else
25072         _OUT << "}" << std::endl;
25073 }
25074 
print_VkDescriptorSetLayoutBindingFlagsCreateInfo(VkDescriptorSetLayoutBindingFlagsCreateInfo obj,const std::string & s,bool commaNeeded=true)25075 static void print_VkDescriptorSetLayoutBindingFlagsCreateInfo(VkDescriptorSetLayoutBindingFlagsCreateInfo obj,
25076                                                               const std::string &s, bool commaNeeded = true)
25077 {
25078     PRINT_SPACE
25079     _OUT << "{" << std::endl;
25080     INDENT(4);
25081 
25082     print_VkStructureType(obj.sType, "sType", 1);
25083 
25084     if (obj.pNext)
25085     {
25086         dumpPNextChain(obj.pNext);
25087     }
25088     else
25089     {
25090         PRINT_SPACE
25091         _OUT << "\"pNext\":"
25092              << "\"NULL\""
25093              << "," << std::endl;
25094     }
25095 
25096     print_uint32_t(obj.bindingCount, "bindingCount", 1);
25097 
25098     PRINT_SPACE
25099     _OUT << "\"pBindingFlags\":" << std::endl;
25100     PRINT_SPACE
25101     if (obj.pBindingFlags)
25102     {
25103         _OUT << "[" << std::endl;
25104         for (unsigned int i = 0; i < obj.bindingCount; i++)
25105         {
25106             bool isCommaNeeded = (i + 1) != obj.bindingCount;
25107             print_VkDescriptorBindingFlags(obj.pBindingFlags[i], "", isCommaNeeded);
25108         }
25109         PRINT_SPACE
25110         _OUT << "]"
25111              << "" << std::endl;
25112     }
25113     else
25114     {
25115         _OUT << "\"NULL\""
25116              << "" << std::endl;
25117     }
25118 
25119     INDENT(-4);
25120     PRINT_SPACE
25121     if (commaNeeded)
25122         _OUT << "}," << std::endl;
25123     else
25124         _OUT << "}" << std::endl;
25125 }
print_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo * obj,const std::string & s,bool commaNeeded=true)25126 static void print_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo *obj,
25127                                                               const std::string &s, bool commaNeeded = true)
25128 {
25129     PRINT_SPACE
25130     _OUT << "{" << std::endl;
25131     INDENT(4);
25132 
25133     print_VkStructureType(obj->sType, "sType", 1);
25134 
25135     if (obj->pNext)
25136     {
25137         dumpPNextChain(obj->pNext);
25138     }
25139     else
25140     {
25141         PRINT_SPACE
25142         _OUT << "\"pNext\":"
25143              << "\"NULL\""
25144              << "," << std::endl;
25145     }
25146 
25147     print_uint32_t(obj->bindingCount, "bindingCount", 1);
25148 
25149     PRINT_SPACE
25150     _OUT << "\"pBindingFlags\":" << std::endl;
25151     PRINT_SPACE
25152     if (obj->pBindingFlags)
25153     {
25154         _OUT << "[" << std::endl;
25155         for (unsigned int i = 0; i < obj->bindingCount; i++)
25156         {
25157             bool isCommaNeeded = (i + 1) != obj->bindingCount;
25158             print_VkDescriptorBindingFlags(obj->pBindingFlags[i], "", isCommaNeeded);
25159         }
25160         PRINT_SPACE
25161         _OUT << "]"
25162              << "" << std::endl;
25163     }
25164     else
25165     {
25166         _OUT << "\"NULL\""
25167              << "" << std::endl;
25168     }
25169 
25170     INDENT(-4);
25171     PRINT_SPACE
25172     if (commaNeeded)
25173         _OUT << "}," << std::endl;
25174     else
25175         _OUT << "}" << std::endl;
25176 }
25177 
print_VkPhysicalDeviceDescriptorIndexingFeatures(VkPhysicalDeviceDescriptorIndexingFeatures obj,const std::string & s,bool commaNeeded=true)25178 static void print_VkPhysicalDeviceDescriptorIndexingFeatures(VkPhysicalDeviceDescriptorIndexingFeatures obj,
25179                                                              const std::string &s, bool commaNeeded = true)
25180 {
25181     PRINT_SPACE
25182     _OUT << "{" << std::endl;
25183     INDENT(4);
25184 
25185     print_VkStructureType(obj.sType, "sType", 1);
25186 
25187     if (obj.pNext)
25188     {
25189         dumpPNextChain(obj.pNext);
25190     }
25191     else
25192     {
25193         PRINT_SPACE
25194         _OUT << "\"pNext\":"
25195              << "\"NULL\""
25196              << "," << std::endl;
25197     }
25198 
25199     print_VkBool32(obj.shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1);
25200 
25201     print_VkBool32(obj.shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing", 1);
25202 
25203     print_VkBool32(obj.shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing", 1);
25204 
25205     print_VkBool32(obj.shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1);
25206 
25207     print_VkBool32(obj.shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1);
25208 
25209     print_VkBool32(obj.shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1);
25210 
25211     print_VkBool32(obj.shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1);
25212 
25213     print_VkBool32(obj.shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing", 1);
25214 
25215     print_VkBool32(obj.shaderUniformTexelBufferArrayNonUniformIndexing,
25216                    "shaderUniformTexelBufferArrayNonUniformIndexing", 1);
25217 
25218     print_VkBool32(obj.shaderStorageTexelBufferArrayNonUniformIndexing,
25219                    "shaderStorageTexelBufferArrayNonUniformIndexing", 1);
25220 
25221     print_VkBool32(obj.descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind",
25222                    1);
25223 
25224     print_VkBool32(obj.descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind", 1);
25225 
25226     print_VkBool32(obj.descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind", 1);
25227 
25228     print_VkBool32(obj.descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind",
25229                    1);
25230 
25231     print_VkBool32(obj.descriptorBindingUniformTexelBufferUpdateAfterBind,
25232                    "descriptorBindingUniformTexelBufferUpdateAfterBind", 1);
25233 
25234     print_VkBool32(obj.descriptorBindingStorageTexelBufferUpdateAfterBind,
25235                    "descriptorBindingStorageTexelBufferUpdateAfterBind", 1);
25236 
25237     print_VkBool32(obj.descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1);
25238 
25239     print_VkBool32(obj.descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1);
25240 
25241     print_VkBool32(obj.descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1);
25242 
25243     print_VkBool32(obj.runtimeDescriptorArray, "runtimeDescriptorArray", 0);
25244 
25245     INDENT(-4);
25246     PRINT_SPACE
25247     if (commaNeeded)
25248         _OUT << "}," << std::endl;
25249     else
25250         _OUT << "}" << std::endl;
25251 }
print_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures * obj,const std::string & s,bool commaNeeded=true)25252 static void print_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures *obj,
25253                                                              const std::string &s, bool commaNeeded = true)
25254 {
25255     PRINT_SPACE
25256     _OUT << "{" << std::endl;
25257     INDENT(4);
25258 
25259     print_VkStructureType(obj->sType, "sType", 1);
25260 
25261     if (obj->pNext)
25262     {
25263         dumpPNextChain(obj->pNext);
25264     }
25265     else
25266     {
25267         PRINT_SPACE
25268         _OUT << "\"pNext\":"
25269              << "\"NULL\""
25270              << "," << std::endl;
25271     }
25272 
25273     print_VkBool32(obj->shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1);
25274 
25275     print_VkBool32(obj->shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing",
25276                    1);
25277 
25278     print_VkBool32(obj->shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing",
25279                    1);
25280 
25281     print_VkBool32(obj->shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1);
25282 
25283     print_VkBool32(obj->shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1);
25284 
25285     print_VkBool32(obj->shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1);
25286 
25287     print_VkBool32(obj->shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1);
25288 
25289     print_VkBool32(obj->shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing",
25290                    1);
25291 
25292     print_VkBool32(obj->shaderUniformTexelBufferArrayNonUniformIndexing,
25293                    "shaderUniformTexelBufferArrayNonUniformIndexing", 1);
25294 
25295     print_VkBool32(obj->shaderStorageTexelBufferArrayNonUniformIndexing,
25296                    "shaderStorageTexelBufferArrayNonUniformIndexing", 1);
25297 
25298     print_VkBool32(obj->descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind",
25299                    1);
25300 
25301     print_VkBool32(obj->descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind",
25302                    1);
25303 
25304     print_VkBool32(obj->descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind",
25305                    1);
25306 
25307     print_VkBool32(obj->descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind",
25308                    1);
25309 
25310     print_VkBool32(obj->descriptorBindingUniformTexelBufferUpdateAfterBind,
25311                    "descriptorBindingUniformTexelBufferUpdateAfterBind", 1);
25312 
25313     print_VkBool32(obj->descriptorBindingStorageTexelBufferUpdateAfterBind,
25314                    "descriptorBindingStorageTexelBufferUpdateAfterBind", 1);
25315 
25316     print_VkBool32(obj->descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1);
25317 
25318     print_VkBool32(obj->descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1);
25319 
25320     print_VkBool32(obj->descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1);
25321 
25322     print_VkBool32(obj->runtimeDescriptorArray, "runtimeDescriptorArray", 0);
25323 
25324     INDENT(-4);
25325     PRINT_SPACE
25326     if (commaNeeded)
25327         _OUT << "}," << std::endl;
25328     else
25329         _OUT << "}" << std::endl;
25330 }
25331 
print_VkPhysicalDeviceDescriptorIndexingProperties(VkPhysicalDeviceDescriptorIndexingProperties obj,const std::string & s,bool commaNeeded=true)25332 static void print_VkPhysicalDeviceDescriptorIndexingProperties(VkPhysicalDeviceDescriptorIndexingProperties obj,
25333                                                                const std::string &s, bool commaNeeded = true)
25334 {
25335     PRINT_SPACE
25336     _OUT << "{" << std::endl;
25337     INDENT(4);
25338 
25339     print_VkStructureType(obj.sType, "sType", 1);
25340 
25341     if (obj.pNext)
25342     {
25343         dumpPNextChain(obj.pNext);
25344     }
25345     else
25346     {
25347         PRINT_SPACE
25348         _OUT << "\"pNext\":"
25349              << "\"NULL\""
25350              << "," << std::endl;
25351     }
25352 
25353     print_uint32_t(obj.maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1);
25354 
25355     print_VkBool32(obj.shaderUniformBufferArrayNonUniformIndexingNative,
25356                    "shaderUniformBufferArrayNonUniformIndexingNative", 1);
25357 
25358     print_VkBool32(obj.shaderSampledImageArrayNonUniformIndexingNative,
25359                    "shaderSampledImageArrayNonUniformIndexingNative", 1);
25360 
25361     print_VkBool32(obj.shaderStorageBufferArrayNonUniformIndexingNative,
25362                    "shaderStorageBufferArrayNonUniformIndexingNative", 1);
25363 
25364     print_VkBool32(obj.shaderStorageImageArrayNonUniformIndexingNative,
25365                    "shaderStorageImageArrayNonUniformIndexingNative", 1);
25366 
25367     print_VkBool32(obj.shaderInputAttachmentArrayNonUniformIndexingNative,
25368                    "shaderInputAttachmentArrayNonUniformIndexingNative", 1);
25369 
25370     print_VkBool32(obj.robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1);
25371 
25372     print_VkBool32(obj.quadDivergentImplicitLod, "quadDivergentImplicitLod", 1);
25373 
25374     print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers", 1);
25375 
25376     print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers,
25377                    "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1);
25378 
25379     print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers,
25380                    "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1);
25381 
25382     print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindSampledImages,
25383                    "maxPerStageDescriptorUpdateAfterBindSampledImages", 1);
25384 
25385     print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindStorageImages,
25386                    "maxPerStageDescriptorUpdateAfterBindStorageImages", 1);
25387 
25388     print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindInputAttachments,
25389                    "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1);
25390 
25391     print_uint32_t(obj.maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1);
25392 
25393     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1);
25394 
25395     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers",
25396                    1);
25397 
25398     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
25399                    "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1);
25400 
25401     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers",
25402                    1);
25403 
25404     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
25405                    "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1);
25406 
25407     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages", 1);
25408 
25409     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages", 1);
25410 
25411     print_uint32_t(obj.maxDescriptorSetUpdateAfterBindInputAttachments,
25412                    "maxDescriptorSetUpdateAfterBindInputAttachments", 0);
25413 
25414     INDENT(-4);
25415     PRINT_SPACE
25416     if (commaNeeded)
25417         _OUT << "}," << std::endl;
25418     else
25419         _OUT << "}" << std::endl;
25420 }
print_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties * obj,const std::string & s,bool commaNeeded=true)25421 static void print_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties *obj,
25422                                                                const std::string &s, bool commaNeeded = true)
25423 {
25424     PRINT_SPACE
25425     _OUT << "{" << std::endl;
25426     INDENT(4);
25427 
25428     print_VkStructureType(obj->sType, "sType", 1);
25429 
25430     if (obj->pNext)
25431     {
25432         dumpPNextChain(obj->pNext);
25433     }
25434     else
25435     {
25436         PRINT_SPACE
25437         _OUT << "\"pNext\":"
25438              << "\"NULL\""
25439              << "," << std::endl;
25440     }
25441 
25442     print_uint32_t(obj->maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1);
25443 
25444     print_VkBool32(obj->shaderUniformBufferArrayNonUniformIndexingNative,
25445                    "shaderUniformBufferArrayNonUniformIndexingNative", 1);
25446 
25447     print_VkBool32(obj->shaderSampledImageArrayNonUniformIndexingNative,
25448                    "shaderSampledImageArrayNonUniformIndexingNative", 1);
25449 
25450     print_VkBool32(obj->shaderStorageBufferArrayNonUniformIndexingNative,
25451                    "shaderStorageBufferArrayNonUniformIndexingNative", 1);
25452 
25453     print_VkBool32(obj->shaderStorageImageArrayNonUniformIndexingNative,
25454                    "shaderStorageImageArrayNonUniformIndexingNative", 1);
25455 
25456     print_VkBool32(obj->shaderInputAttachmentArrayNonUniformIndexingNative,
25457                    "shaderInputAttachmentArrayNonUniformIndexingNative", 1);
25458 
25459     print_VkBool32(obj->robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1);
25460 
25461     print_VkBool32(obj->quadDivergentImplicitLod, "quadDivergentImplicitLod", 1);
25462 
25463     print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers",
25464                    1);
25465 
25466     print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindUniformBuffers,
25467                    "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1);
25468 
25469     print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindStorageBuffers,
25470                    "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1);
25471 
25472     print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindSampledImages,
25473                    "maxPerStageDescriptorUpdateAfterBindSampledImages", 1);
25474 
25475     print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindStorageImages,
25476                    "maxPerStageDescriptorUpdateAfterBindStorageImages", 1);
25477 
25478     print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindInputAttachments,
25479                    "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1);
25480 
25481     print_uint32_t(obj->maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1);
25482 
25483     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1);
25484 
25485     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers",
25486                    1);
25487 
25488     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
25489                    "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1);
25490 
25491     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers",
25492                    1);
25493 
25494     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
25495                    "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1);
25496 
25497     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages",
25498                    1);
25499 
25500     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages",
25501                    1);
25502 
25503     print_uint32_t(obj->maxDescriptorSetUpdateAfterBindInputAttachments,
25504                    "maxDescriptorSetUpdateAfterBindInputAttachments", 0);
25505 
25506     INDENT(-4);
25507     PRINT_SPACE
25508     if (commaNeeded)
25509         _OUT << "}," << std::endl;
25510     else
25511         _OUT << "}" << std::endl;
25512 }
25513 
print_VkDescriptorSetVariableDescriptorCountAllocateInfo(VkDescriptorSetVariableDescriptorCountAllocateInfo obj,const std::string & s,bool commaNeeded=true)25514 static void print_VkDescriptorSetVariableDescriptorCountAllocateInfo(
25515     VkDescriptorSetVariableDescriptorCountAllocateInfo obj, const std::string &s, bool commaNeeded = true)
25516 {
25517     PRINT_SPACE
25518     _OUT << "{" << std::endl;
25519     INDENT(4);
25520 
25521     print_VkStructureType(obj.sType, "sType", 1);
25522 
25523     if (obj.pNext)
25524     {
25525         dumpPNextChain(obj.pNext);
25526     }
25527     else
25528     {
25529         PRINT_SPACE
25530         _OUT << "\"pNext\":"
25531              << "\"NULL\""
25532              << "," << std::endl;
25533     }
25534 
25535     print_uint32_t(obj.descriptorSetCount, "descriptorSetCount", 1);
25536 
25537     PRINT_SPACE
25538     _OUT << "\"pDescriptorCounts\":" << std::endl;
25539     PRINT_SPACE
25540     if (obj.pDescriptorCounts)
25541     {
25542         _OUT << "[" << std::endl;
25543         for (unsigned int i = 0; i < obj.descriptorSetCount; i++)
25544         {
25545             bool isCommaNeeded = (i + 1) != obj.descriptorSetCount;
25546             print_uint32_t(obj.pDescriptorCounts[i], "", isCommaNeeded);
25547         }
25548         PRINT_SPACE
25549         _OUT << "]"
25550              << "" << std::endl;
25551     }
25552     else
25553     {
25554         _OUT << "\"NULL\""
25555              << "" << std::endl;
25556     }
25557 
25558     INDENT(-4);
25559     PRINT_SPACE
25560     if (commaNeeded)
25561         _OUT << "}," << std::endl;
25562     else
25563         _OUT << "}" << std::endl;
25564 }
print_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo * obj,const std::string & s,bool commaNeeded=true)25565 static void print_VkDescriptorSetVariableDescriptorCountAllocateInfo(
25566     const VkDescriptorSetVariableDescriptorCountAllocateInfo *obj, const std::string &s, bool commaNeeded = true)
25567 {
25568     PRINT_SPACE
25569     _OUT << "{" << std::endl;
25570     INDENT(4);
25571 
25572     print_VkStructureType(obj->sType, "sType", 1);
25573 
25574     if (obj->pNext)
25575     {
25576         dumpPNextChain(obj->pNext);
25577     }
25578     else
25579     {
25580         PRINT_SPACE
25581         _OUT << "\"pNext\":"
25582              << "\"NULL\""
25583              << "," << std::endl;
25584     }
25585 
25586     print_uint32_t(obj->descriptorSetCount, "descriptorSetCount", 1);
25587 
25588     PRINT_SPACE
25589     _OUT << "\"pDescriptorCounts\":" << std::endl;
25590     PRINT_SPACE
25591     if (obj->pDescriptorCounts)
25592     {
25593         _OUT << "[" << std::endl;
25594         for (unsigned int i = 0; i < obj->descriptorSetCount; i++)
25595         {
25596             bool isCommaNeeded = (i + 1) != obj->descriptorSetCount;
25597             print_uint32_t(obj->pDescriptorCounts[i], "", isCommaNeeded);
25598         }
25599         PRINT_SPACE
25600         _OUT << "]"
25601              << "" << std::endl;
25602     }
25603     else
25604     {
25605         _OUT << "\"NULL\""
25606              << "" << std::endl;
25607     }
25608 
25609     INDENT(-4);
25610     PRINT_SPACE
25611     if (commaNeeded)
25612         _OUT << "}," << std::endl;
25613     else
25614         _OUT << "}" << std::endl;
25615 }
25616 
print_VkDescriptorSetVariableDescriptorCountLayoutSupport(VkDescriptorSetVariableDescriptorCountLayoutSupport obj,const std::string & s,bool commaNeeded=true)25617 static void print_VkDescriptorSetVariableDescriptorCountLayoutSupport(
25618     VkDescriptorSetVariableDescriptorCountLayoutSupport obj, const std::string &s, bool commaNeeded = true)
25619 {
25620     PRINT_SPACE
25621     _OUT << "{" << std::endl;
25622     INDENT(4);
25623 
25624     print_VkStructureType(obj.sType, "sType", 1);
25625 
25626     if (obj.pNext)
25627     {
25628         dumpPNextChain(obj.pNext);
25629     }
25630     else
25631     {
25632         PRINT_SPACE
25633         _OUT << "\"pNext\":"
25634              << "\"NULL\""
25635              << "," << std::endl;
25636     }
25637 
25638     print_uint32_t(obj.maxVariableDescriptorCount, "maxVariableDescriptorCount", 0);
25639 
25640     INDENT(-4);
25641     PRINT_SPACE
25642     if (commaNeeded)
25643         _OUT << "}," << std::endl;
25644     else
25645         _OUT << "}" << std::endl;
25646 }
print_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport * obj,const std::string & s,bool commaNeeded=true)25647 static void print_VkDescriptorSetVariableDescriptorCountLayoutSupport(
25648     const VkDescriptorSetVariableDescriptorCountLayoutSupport *obj, const std::string &s, bool commaNeeded = true)
25649 {
25650     PRINT_SPACE
25651     _OUT << "{" << std::endl;
25652     INDENT(4);
25653 
25654     print_VkStructureType(obj->sType, "sType", 1);
25655 
25656     if (obj->pNext)
25657     {
25658         dumpPNextChain(obj->pNext);
25659     }
25660     else
25661     {
25662         PRINT_SPACE
25663         _OUT << "\"pNext\":"
25664              << "\"NULL\""
25665              << "," << std::endl;
25666     }
25667 
25668     print_uint32_t(obj->maxVariableDescriptorCount, "maxVariableDescriptorCount", 0);
25669 
25670     INDENT(-4);
25671     PRINT_SPACE
25672     if (commaNeeded)
25673         _OUT << "}," << std::endl;
25674     else
25675         _OUT << "}" << std::endl;
25676 }
25677 
print_VkSubpassDescriptionDepthStencilResolve(VkSubpassDescriptionDepthStencilResolve obj,const std::string & s,bool commaNeeded=true)25678 static void print_VkSubpassDescriptionDepthStencilResolve(VkSubpassDescriptionDepthStencilResolve obj,
25679                                                           const std::string &s, bool commaNeeded = true)
25680 {
25681     PRINT_SPACE
25682     _OUT << "{" << std::endl;
25683     INDENT(4);
25684 
25685     print_VkStructureType(obj.sType, "sType", 1);
25686 
25687     if (obj.pNext)
25688     {
25689         dumpPNextChain(obj.pNext);
25690     }
25691     else
25692     {
25693         PRINT_SPACE
25694         _OUT << "\"pNext\":"
25695              << "\"NULL\""
25696              << "," << std::endl;
25697     }
25698 
25699     print_VkResolveModeFlagBits(obj.depthResolveMode, "depthResolveMode", 1);
25700 
25701     print_VkResolveModeFlagBits(obj.stencilResolveMode, "stencilResolveMode", 1);
25702 
25703     PRINT_SPACE
25704     _OUT << "\"pDepthStencilResolveAttachment\": " << std::endl;
25705     if (obj.pDepthStencilResolveAttachment)
25706     {
25707         print_VkAttachmentReference2(obj.pDepthStencilResolveAttachment, "pDepthStencilResolveAttachment", 0);
25708     }
25709     else
25710     {
25711         PRINT_SPACE _OUT << "\"NULL\""
25712                          << "" << std::endl;
25713     }
25714 
25715     INDENT(-4);
25716     PRINT_SPACE
25717     if (commaNeeded)
25718         _OUT << "}," << std::endl;
25719     else
25720         _OUT << "}" << std::endl;
25721 }
print_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve * obj,const std::string & s,bool commaNeeded=true)25722 static void print_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve *obj,
25723                                                           const std::string &s, bool commaNeeded = true)
25724 {
25725     PRINT_SPACE
25726     _OUT << "{" << std::endl;
25727     INDENT(4);
25728 
25729     print_VkStructureType(obj->sType, "sType", 1);
25730 
25731     if (obj->pNext)
25732     {
25733         dumpPNextChain(obj->pNext);
25734     }
25735     else
25736     {
25737         PRINT_SPACE
25738         _OUT << "\"pNext\":"
25739              << "\"NULL\""
25740              << "," << std::endl;
25741     }
25742 
25743     print_VkResolveModeFlagBits(obj->depthResolveMode, "depthResolveMode", 1);
25744 
25745     print_VkResolveModeFlagBits(obj->stencilResolveMode, "stencilResolveMode", 1);
25746 
25747     PRINT_SPACE
25748     _OUT << "\"pDepthStencilResolveAttachment\": " << std::endl;
25749     if (obj->pDepthStencilResolveAttachment)
25750     {
25751         print_VkAttachmentReference2(obj->pDepthStencilResolveAttachment, "pDepthStencilResolveAttachment", 0);
25752     }
25753     else
25754     {
25755         PRINT_SPACE _OUT << "\"NULL\""
25756                          << "" << std::endl;
25757     }
25758 
25759     INDENT(-4);
25760     PRINT_SPACE
25761     if (commaNeeded)
25762         _OUT << "}," << std::endl;
25763     else
25764         _OUT << "}" << std::endl;
25765 }
25766 
print_VkPhysicalDeviceDepthStencilResolveProperties(VkPhysicalDeviceDepthStencilResolveProperties obj,const std::string & s,bool commaNeeded=true)25767 static void print_VkPhysicalDeviceDepthStencilResolveProperties(VkPhysicalDeviceDepthStencilResolveProperties obj,
25768                                                                 const std::string &s, bool commaNeeded = true)
25769 {
25770     PRINT_SPACE
25771     _OUT << "{" << std::endl;
25772     INDENT(4);
25773 
25774     print_VkStructureType(obj.sType, "sType", 1);
25775 
25776     if (obj.pNext)
25777     {
25778         dumpPNextChain(obj.pNext);
25779     }
25780     else
25781     {
25782         PRINT_SPACE
25783         _OUT << "\"pNext\":"
25784              << "\"NULL\""
25785              << "," << std::endl;
25786     }
25787 
25788     print_VkResolveModeFlags(obj.supportedDepthResolveModes, "supportedDepthResolveModes", 1);
25789 
25790     print_VkResolveModeFlags(obj.supportedStencilResolveModes, "supportedStencilResolveModes", 1);
25791 
25792     print_VkBool32(obj.independentResolveNone, "independentResolveNone", 1);
25793 
25794     print_VkBool32(obj.independentResolve, "independentResolve", 0);
25795 
25796     INDENT(-4);
25797     PRINT_SPACE
25798     if (commaNeeded)
25799         _OUT << "}," << std::endl;
25800     else
25801         _OUT << "}" << std::endl;
25802 }
print_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties * obj,const std::string & s,bool commaNeeded=true)25803 static void print_VkPhysicalDeviceDepthStencilResolveProperties(
25804     const VkPhysicalDeviceDepthStencilResolveProperties *obj, const std::string &s, bool commaNeeded = true)
25805 {
25806     PRINT_SPACE
25807     _OUT << "{" << std::endl;
25808     INDENT(4);
25809 
25810     print_VkStructureType(obj->sType, "sType", 1);
25811 
25812     if (obj->pNext)
25813     {
25814         dumpPNextChain(obj->pNext);
25815     }
25816     else
25817     {
25818         PRINT_SPACE
25819         _OUT << "\"pNext\":"
25820              << "\"NULL\""
25821              << "," << std::endl;
25822     }
25823 
25824     print_VkResolveModeFlags(obj->supportedDepthResolveModes, "supportedDepthResolveModes", 1);
25825 
25826     print_VkResolveModeFlags(obj->supportedStencilResolveModes, "supportedStencilResolveModes", 1);
25827 
25828     print_VkBool32(obj->independentResolveNone, "independentResolveNone", 1);
25829 
25830     print_VkBool32(obj->independentResolve, "independentResolve", 0);
25831 
25832     INDENT(-4);
25833     PRINT_SPACE
25834     if (commaNeeded)
25835         _OUT << "}," << std::endl;
25836     else
25837         _OUT << "}" << std::endl;
25838 }
25839 
print_VkPhysicalDeviceScalarBlockLayoutFeatures(VkPhysicalDeviceScalarBlockLayoutFeatures obj,const std::string & s,bool commaNeeded=true)25840 static void print_VkPhysicalDeviceScalarBlockLayoutFeatures(VkPhysicalDeviceScalarBlockLayoutFeatures obj,
25841                                                             const std::string &s, bool commaNeeded = true)
25842 {
25843     PRINT_SPACE
25844     _OUT << "{" << std::endl;
25845     INDENT(4);
25846 
25847     print_VkStructureType(obj.sType, "sType", 1);
25848 
25849     if (obj.pNext)
25850     {
25851         dumpPNextChain(obj.pNext);
25852     }
25853     else
25854     {
25855         PRINT_SPACE
25856         _OUT << "\"pNext\":"
25857              << "\"NULL\""
25858              << "," << std::endl;
25859     }
25860 
25861     print_VkBool32(obj.scalarBlockLayout, "scalarBlockLayout", 0);
25862 
25863     INDENT(-4);
25864     PRINT_SPACE
25865     if (commaNeeded)
25866         _OUT << "}," << std::endl;
25867     else
25868         _OUT << "}" << std::endl;
25869 }
print_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures * obj,const std::string & s,bool commaNeeded=true)25870 static void print_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures *obj,
25871                                                             const std::string &s, bool commaNeeded = true)
25872 {
25873     PRINT_SPACE
25874     _OUT << "{" << std::endl;
25875     INDENT(4);
25876 
25877     print_VkStructureType(obj->sType, "sType", 1);
25878 
25879     if (obj->pNext)
25880     {
25881         dumpPNextChain(obj->pNext);
25882     }
25883     else
25884     {
25885         PRINT_SPACE
25886         _OUT << "\"pNext\":"
25887              << "\"NULL\""
25888              << "," << std::endl;
25889     }
25890 
25891     print_VkBool32(obj->scalarBlockLayout, "scalarBlockLayout", 0);
25892 
25893     INDENT(-4);
25894     PRINT_SPACE
25895     if (commaNeeded)
25896         _OUT << "}," << std::endl;
25897     else
25898         _OUT << "}" << std::endl;
25899 }
25900 
print_VkImageStencilUsageCreateInfo(VkImageStencilUsageCreateInfo obj,const std::string & s,bool commaNeeded=true)25901 static void print_VkImageStencilUsageCreateInfo(VkImageStencilUsageCreateInfo obj, const std::string &s,
25902                                                 bool commaNeeded = true)
25903 {
25904     PRINT_SPACE
25905     _OUT << "{" << std::endl;
25906     INDENT(4);
25907 
25908     print_VkStructureType(obj.sType, "sType", 1);
25909 
25910     if (obj.pNext)
25911     {
25912         dumpPNextChain(obj.pNext);
25913     }
25914     else
25915     {
25916         PRINT_SPACE
25917         _OUT << "\"pNext\":"
25918              << "\"NULL\""
25919              << "," << std::endl;
25920     }
25921 
25922     print_VkImageUsageFlags(obj.stencilUsage, "stencilUsage", 0);
25923 
25924     INDENT(-4);
25925     PRINT_SPACE
25926     if (commaNeeded)
25927         _OUT << "}," << std::endl;
25928     else
25929         _OUT << "}" << std::endl;
25930 }
print_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo * obj,const std::string & s,bool commaNeeded=true)25931 static void print_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo *obj, const std::string &s,
25932                                                 bool commaNeeded = true)
25933 {
25934     PRINT_SPACE
25935     _OUT << "{" << std::endl;
25936     INDENT(4);
25937 
25938     print_VkStructureType(obj->sType, "sType", 1);
25939 
25940     if (obj->pNext)
25941     {
25942         dumpPNextChain(obj->pNext);
25943     }
25944     else
25945     {
25946         PRINT_SPACE
25947         _OUT << "\"pNext\":"
25948              << "\"NULL\""
25949              << "," << std::endl;
25950     }
25951 
25952     print_VkImageUsageFlags(obj->stencilUsage, "stencilUsage", 0);
25953 
25954     INDENT(-4);
25955     PRINT_SPACE
25956     if (commaNeeded)
25957         _OUT << "}," << std::endl;
25958     else
25959         _OUT << "}" << std::endl;
25960 }
25961 
print_VkSamplerReductionModeCreateInfo(VkSamplerReductionModeCreateInfo obj,const std::string & s,bool commaNeeded=true)25962 static void print_VkSamplerReductionModeCreateInfo(VkSamplerReductionModeCreateInfo obj, const std::string &s,
25963                                                    bool commaNeeded = true)
25964 {
25965     PRINT_SPACE
25966     _OUT << "{" << std::endl;
25967     INDENT(4);
25968 
25969     print_VkStructureType(obj.sType, "sType", 1);
25970 
25971     if (obj.pNext)
25972     {
25973         dumpPNextChain(obj.pNext);
25974     }
25975     else
25976     {
25977         PRINT_SPACE
25978         _OUT << "\"pNext\":"
25979              << "\"NULL\""
25980              << "," << std::endl;
25981     }
25982 
25983     print_VkSamplerReductionMode(obj.reductionMode, "reductionMode", 0);
25984 
25985     INDENT(-4);
25986     PRINT_SPACE
25987     if (commaNeeded)
25988         _OUT << "}," << std::endl;
25989     else
25990         _OUT << "}" << std::endl;
25991 }
print_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo * obj,const std::string & s,bool commaNeeded=true)25992 static void print_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo *obj, const std::string &s,
25993                                                    bool commaNeeded = true)
25994 {
25995     PRINT_SPACE
25996     _OUT << "{" << std::endl;
25997     INDENT(4);
25998 
25999     print_VkStructureType(obj->sType, "sType", 1);
26000 
26001     if (obj->pNext)
26002     {
26003         dumpPNextChain(obj->pNext);
26004     }
26005     else
26006     {
26007         PRINT_SPACE
26008         _OUT << "\"pNext\":"
26009              << "\"NULL\""
26010              << "," << std::endl;
26011     }
26012 
26013     print_VkSamplerReductionMode(obj->reductionMode, "reductionMode", 0);
26014 
26015     INDENT(-4);
26016     PRINT_SPACE
26017     if (commaNeeded)
26018         _OUT << "}," << std::endl;
26019     else
26020         _OUT << "}" << std::endl;
26021 }
26022 
print_VkPhysicalDeviceSamplerFilterMinmaxProperties(VkPhysicalDeviceSamplerFilterMinmaxProperties obj,const std::string & s,bool commaNeeded=true)26023 static void print_VkPhysicalDeviceSamplerFilterMinmaxProperties(VkPhysicalDeviceSamplerFilterMinmaxProperties obj,
26024                                                                 const std::string &s, bool commaNeeded = true)
26025 {
26026     PRINT_SPACE
26027     _OUT << "{" << std::endl;
26028     INDENT(4);
26029 
26030     print_VkStructureType(obj.sType, "sType", 1);
26031 
26032     if (obj.pNext)
26033     {
26034         dumpPNextChain(obj.pNext);
26035     }
26036     else
26037     {
26038         PRINT_SPACE
26039         _OUT << "\"pNext\":"
26040              << "\"NULL\""
26041              << "," << std::endl;
26042     }
26043 
26044     print_VkBool32(obj.filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1);
26045 
26046     print_VkBool32(obj.filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 0);
26047 
26048     INDENT(-4);
26049     PRINT_SPACE
26050     if (commaNeeded)
26051         _OUT << "}," << std::endl;
26052     else
26053         _OUT << "}" << std::endl;
26054 }
print_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties * obj,const std::string & s,bool commaNeeded=true)26055 static void print_VkPhysicalDeviceSamplerFilterMinmaxProperties(
26056     const VkPhysicalDeviceSamplerFilterMinmaxProperties *obj, const std::string &s, bool commaNeeded = true)
26057 {
26058     PRINT_SPACE
26059     _OUT << "{" << std::endl;
26060     INDENT(4);
26061 
26062     print_VkStructureType(obj->sType, "sType", 1);
26063 
26064     if (obj->pNext)
26065     {
26066         dumpPNextChain(obj->pNext);
26067     }
26068     else
26069     {
26070         PRINT_SPACE
26071         _OUT << "\"pNext\":"
26072              << "\"NULL\""
26073              << "," << std::endl;
26074     }
26075 
26076     print_VkBool32(obj->filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1);
26077 
26078     print_VkBool32(obj->filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 0);
26079 
26080     INDENT(-4);
26081     PRINT_SPACE
26082     if (commaNeeded)
26083         _OUT << "}," << std::endl;
26084     else
26085         _OUT << "}" << std::endl;
26086 }
26087 
print_VkPhysicalDeviceVulkanMemoryModelFeatures(VkPhysicalDeviceVulkanMemoryModelFeatures obj,const std::string & s,bool commaNeeded=true)26088 static void print_VkPhysicalDeviceVulkanMemoryModelFeatures(VkPhysicalDeviceVulkanMemoryModelFeatures obj,
26089                                                             const std::string &s, bool commaNeeded = true)
26090 {
26091     PRINT_SPACE
26092     _OUT << "{" << std::endl;
26093     INDENT(4);
26094 
26095     print_VkStructureType(obj.sType, "sType", 1);
26096 
26097     if (obj.pNext)
26098     {
26099         dumpPNextChain(obj.pNext);
26100     }
26101     else
26102     {
26103         PRINT_SPACE
26104         _OUT << "\"pNext\":"
26105              << "\"NULL\""
26106              << "," << std::endl;
26107     }
26108 
26109     print_VkBool32(obj.vulkanMemoryModel, "vulkanMemoryModel", 1);
26110 
26111     print_VkBool32(obj.vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1);
26112 
26113     print_VkBool32(obj.vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains",
26114                    0);
26115 
26116     INDENT(-4);
26117     PRINT_SPACE
26118     if (commaNeeded)
26119         _OUT << "}," << std::endl;
26120     else
26121         _OUT << "}" << std::endl;
26122 }
print_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures * obj,const std::string & s,bool commaNeeded=true)26123 static void print_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures *obj,
26124                                                             const std::string &s, bool commaNeeded = true)
26125 {
26126     PRINT_SPACE
26127     _OUT << "{" << std::endl;
26128     INDENT(4);
26129 
26130     print_VkStructureType(obj->sType, "sType", 1);
26131 
26132     if (obj->pNext)
26133     {
26134         dumpPNextChain(obj->pNext);
26135     }
26136     else
26137     {
26138         PRINT_SPACE
26139         _OUT << "\"pNext\":"
26140              << "\"NULL\""
26141              << "," << std::endl;
26142     }
26143 
26144     print_VkBool32(obj->vulkanMemoryModel, "vulkanMemoryModel", 1);
26145 
26146     print_VkBool32(obj->vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1);
26147 
26148     print_VkBool32(obj->vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains",
26149                    0);
26150 
26151     INDENT(-4);
26152     PRINT_SPACE
26153     if (commaNeeded)
26154         _OUT << "}," << std::endl;
26155     else
26156         _OUT << "}" << std::endl;
26157 }
26158 
print_VkPhysicalDeviceImagelessFramebufferFeatures(VkPhysicalDeviceImagelessFramebufferFeatures obj,const std::string & s,bool commaNeeded=true)26159 static void print_VkPhysicalDeviceImagelessFramebufferFeatures(VkPhysicalDeviceImagelessFramebufferFeatures obj,
26160                                                                const std::string &s, bool commaNeeded = true)
26161 {
26162     PRINT_SPACE
26163     _OUT << "{" << std::endl;
26164     INDENT(4);
26165 
26166     print_VkStructureType(obj.sType, "sType", 1);
26167 
26168     if (obj.pNext)
26169     {
26170         dumpPNextChain(obj.pNext);
26171     }
26172     else
26173     {
26174         PRINT_SPACE
26175         _OUT << "\"pNext\":"
26176              << "\"NULL\""
26177              << "," << std::endl;
26178     }
26179 
26180     print_VkBool32(obj.imagelessFramebuffer, "imagelessFramebuffer", 0);
26181 
26182     INDENT(-4);
26183     PRINT_SPACE
26184     if (commaNeeded)
26185         _OUT << "}," << std::endl;
26186     else
26187         _OUT << "}" << std::endl;
26188 }
print_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures * obj,const std::string & s,bool commaNeeded=true)26189 static void print_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures *obj,
26190                                                                const std::string &s, bool commaNeeded = true)
26191 {
26192     PRINT_SPACE
26193     _OUT << "{" << std::endl;
26194     INDENT(4);
26195 
26196     print_VkStructureType(obj->sType, "sType", 1);
26197 
26198     if (obj->pNext)
26199     {
26200         dumpPNextChain(obj->pNext);
26201     }
26202     else
26203     {
26204         PRINT_SPACE
26205         _OUT << "\"pNext\":"
26206              << "\"NULL\""
26207              << "," << std::endl;
26208     }
26209 
26210     print_VkBool32(obj->imagelessFramebuffer, "imagelessFramebuffer", 0);
26211 
26212     INDENT(-4);
26213     PRINT_SPACE
26214     if (commaNeeded)
26215         _OUT << "}," << std::endl;
26216     else
26217         _OUT << "}" << std::endl;
26218 }
26219 
print_VkFramebufferAttachmentImageInfo(VkFramebufferAttachmentImageInfo obj,const std::string & s,bool commaNeeded=true)26220 static void print_VkFramebufferAttachmentImageInfo(VkFramebufferAttachmentImageInfo obj, const std::string &s,
26221                                                    bool commaNeeded = true)
26222 {
26223     PRINT_SPACE
26224     _OUT << "{" << std::endl;
26225     INDENT(4);
26226 
26227     print_VkStructureType(obj.sType, "sType", 1);
26228 
26229     if (obj.pNext)
26230     {
26231         dumpPNextChain(obj.pNext);
26232     }
26233     else
26234     {
26235         PRINT_SPACE
26236         _OUT << "\"pNext\":"
26237              << "\"NULL\""
26238              << "," << std::endl;
26239     }
26240 
26241     print_VkImageCreateFlags(obj.flags, "flags", 1);
26242 
26243     print_VkImageUsageFlags(obj.usage, "usage", 1);
26244 
26245     print_uint32_t(obj.width, "width", 1);
26246 
26247     print_uint32_t(obj.height, "height", 1);
26248 
26249     print_uint32_t(obj.layerCount, "layerCount", 1);
26250 
26251     print_uint32_t(obj.viewFormatCount, "viewFormatCount", 1);
26252 
26253     PRINT_SPACE
26254     _OUT << "\"pViewFormats\":" << std::endl;
26255     PRINT_SPACE
26256     if (obj.pViewFormats)
26257     {
26258         _OUT << "[" << std::endl;
26259         for (unsigned int i = 0; i < obj.viewFormatCount; i++)
26260         {
26261             bool isCommaNeeded = (i + 1) != obj.viewFormatCount;
26262             print_VkFormat(obj.pViewFormats[i], "", isCommaNeeded);
26263         }
26264         PRINT_SPACE
26265         _OUT << "]"
26266              << "" << std::endl;
26267     }
26268     else
26269     {
26270         _OUT << "\"NULL\""
26271              << "" << std::endl;
26272     }
26273 
26274     INDENT(-4);
26275     PRINT_SPACE
26276     if (commaNeeded)
26277         _OUT << "}," << std::endl;
26278     else
26279         _OUT << "}" << std::endl;
26280 }
print_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo * obj,const std::string & s,bool commaNeeded=true)26281 static void print_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo *obj, const std::string &s,
26282                                                    bool commaNeeded = true)
26283 {
26284     PRINT_SPACE
26285     _OUT << "{" << std::endl;
26286     INDENT(4);
26287 
26288     print_VkStructureType(obj->sType, "sType", 1);
26289 
26290     if (obj->pNext)
26291     {
26292         dumpPNextChain(obj->pNext);
26293     }
26294     else
26295     {
26296         PRINT_SPACE
26297         _OUT << "\"pNext\":"
26298              << "\"NULL\""
26299              << "," << std::endl;
26300     }
26301 
26302     print_VkImageCreateFlags(obj->flags, "flags", 1);
26303 
26304     print_VkImageUsageFlags(obj->usage, "usage", 1);
26305 
26306     print_uint32_t(obj->width, "width", 1);
26307 
26308     print_uint32_t(obj->height, "height", 1);
26309 
26310     print_uint32_t(obj->layerCount, "layerCount", 1);
26311 
26312     print_uint32_t(obj->viewFormatCount, "viewFormatCount", 1);
26313 
26314     PRINT_SPACE
26315     _OUT << "\"pViewFormats\":" << std::endl;
26316     PRINT_SPACE
26317     if (obj->pViewFormats)
26318     {
26319         _OUT << "[" << std::endl;
26320         for (unsigned int i = 0; i < obj->viewFormatCount; i++)
26321         {
26322             bool isCommaNeeded = (i + 1) != obj->viewFormatCount;
26323             print_VkFormat(obj->pViewFormats[i], "", isCommaNeeded);
26324         }
26325         PRINT_SPACE
26326         _OUT << "]"
26327              << "" << std::endl;
26328     }
26329     else
26330     {
26331         _OUT << "\"NULL\""
26332              << "" << std::endl;
26333     }
26334 
26335     INDENT(-4);
26336     PRINT_SPACE
26337     if (commaNeeded)
26338         _OUT << "}," << std::endl;
26339     else
26340         _OUT << "}" << std::endl;
26341 }
26342 
print_VkFramebufferAttachmentsCreateInfo(VkFramebufferAttachmentsCreateInfo obj,const std::string & s,bool commaNeeded=true)26343 static void print_VkFramebufferAttachmentsCreateInfo(VkFramebufferAttachmentsCreateInfo obj, const std::string &s,
26344                                                      bool commaNeeded = true)
26345 {
26346     PRINT_SPACE
26347     _OUT << "{" << std::endl;
26348     INDENT(4);
26349 
26350     print_VkStructureType(obj.sType, "sType", 1);
26351 
26352     if (obj.pNext)
26353     {
26354         dumpPNextChain(obj.pNext);
26355     }
26356     else
26357     {
26358         PRINT_SPACE
26359         _OUT << "\"pNext\":"
26360              << "\"NULL\""
26361              << "," << std::endl;
26362     }
26363 
26364     print_uint32_t(obj.attachmentImageInfoCount, "attachmentImageInfoCount", 1);
26365 
26366     PRINT_SPACE
26367     _OUT << "\"pAttachmentImageInfos\": " << std::endl;
26368     if (obj.pAttachmentImageInfos)
26369     {
26370         PRINT_SPACE
26371         _OUT << "[" << std::endl;
26372         for (unsigned int i = 0; i < obj.attachmentImageInfoCount; i++)
26373         {
26374             if (i + 1 == obj.attachmentImageInfoCount)
26375                 print_VkFramebufferAttachmentImageInfo(obj.pAttachmentImageInfos[i], "pAttachmentImageInfos", 0);
26376             else
26377                 print_VkFramebufferAttachmentImageInfo(obj.pAttachmentImageInfos[i], "pAttachmentImageInfos", 1);
26378         }
26379         PRINT_SPACE
26380         _OUT << "]" << std::endl;
26381     }
26382     else
26383     {
26384         PRINT_SPACE _OUT << "\"NULL\""
26385                          << "" << std::endl;
26386     }
26387 
26388     INDENT(-4);
26389     PRINT_SPACE
26390     if (commaNeeded)
26391         _OUT << "}," << std::endl;
26392     else
26393         _OUT << "}" << std::endl;
26394 }
print_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo * obj,const std::string & s,bool commaNeeded=true)26395 static void print_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo *obj,
26396                                                      const std::string &s, bool commaNeeded = true)
26397 {
26398     PRINT_SPACE
26399     _OUT << "{" << std::endl;
26400     INDENT(4);
26401 
26402     print_VkStructureType(obj->sType, "sType", 1);
26403 
26404     if (obj->pNext)
26405     {
26406         dumpPNextChain(obj->pNext);
26407     }
26408     else
26409     {
26410         PRINT_SPACE
26411         _OUT << "\"pNext\":"
26412              << "\"NULL\""
26413              << "," << std::endl;
26414     }
26415 
26416     print_uint32_t(obj->attachmentImageInfoCount, "attachmentImageInfoCount", 1);
26417 
26418     PRINT_SPACE
26419     _OUT << "\"pAttachmentImageInfos\": " << std::endl;
26420     if (obj->pAttachmentImageInfos)
26421     {
26422         PRINT_SPACE
26423         _OUT << "[" << std::endl;
26424         for (unsigned int i = 0; i < obj->attachmentImageInfoCount; i++)
26425         {
26426             if (i + 1 == obj->attachmentImageInfoCount)
26427                 print_VkFramebufferAttachmentImageInfo(obj->pAttachmentImageInfos[i], "pAttachmentImageInfos", 0);
26428             else
26429                 print_VkFramebufferAttachmentImageInfo(obj->pAttachmentImageInfos[i], "pAttachmentImageInfos", 1);
26430         }
26431         PRINT_SPACE
26432         _OUT << "]" << std::endl;
26433     }
26434     else
26435     {
26436         PRINT_SPACE _OUT << "\"NULL\""
26437                          << "" << std::endl;
26438     }
26439 
26440     INDENT(-4);
26441     PRINT_SPACE
26442     if (commaNeeded)
26443         _OUT << "}," << std::endl;
26444     else
26445         _OUT << "}" << std::endl;
26446 }
26447 
print_VkRenderPassAttachmentBeginInfo(VkRenderPassAttachmentBeginInfo obj,const std::string & s,bool commaNeeded=true)26448 static void print_VkRenderPassAttachmentBeginInfo(VkRenderPassAttachmentBeginInfo obj, const std::string &s,
26449                                                   bool commaNeeded = true)
26450 {
26451     PRINT_SPACE
26452     _OUT << "{" << std::endl;
26453     INDENT(4);
26454 
26455     print_VkStructureType(obj.sType, "sType", 1);
26456 
26457     if (obj.pNext)
26458     {
26459         dumpPNextChain(obj.pNext);
26460     }
26461     else
26462     {
26463         PRINT_SPACE
26464         _OUT << "\"pNext\":"
26465              << "\"NULL\""
26466              << "," << std::endl;
26467     }
26468 
26469     print_uint32_t(obj.attachmentCount, "attachmentCount", 1);
26470 
26471     PRINT_SPACE
26472     _OUT << "\"pAttachments\":" << std::endl;
26473     PRINT_SPACE
26474     if (obj.pAttachments)
26475     {
26476         _OUT << "[" << std::endl;
26477         for (unsigned int i = 0; i < obj.attachmentCount; i++)
26478         {
26479             std::stringstream tmp;
26480             tmp << "pAttachments"
26481                 << "_" << i;
26482             bool isCommaNeeded = (i + 1) != obj.attachmentCount;
26483             print_VkImageView(obj.pAttachments[i], tmp.str(), isCommaNeeded);
26484         }
26485         PRINT_SPACE
26486         _OUT << "]"
26487              << "" << std::endl;
26488     }
26489     else
26490     {
26491         _OUT << "\"NULL\""
26492              << "" << std::endl;
26493     }
26494 
26495     INDENT(-4);
26496     PRINT_SPACE
26497     if (commaNeeded)
26498         _OUT << "}," << std::endl;
26499     else
26500         _OUT << "}" << std::endl;
26501 }
print_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo * obj,const std::string & s,bool commaNeeded=true)26502 static void print_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo *obj, const std::string &s,
26503                                                   bool commaNeeded = true)
26504 {
26505     PRINT_SPACE
26506     _OUT << "{" << std::endl;
26507     INDENT(4);
26508 
26509     print_VkStructureType(obj->sType, "sType", 1);
26510 
26511     if (obj->pNext)
26512     {
26513         dumpPNextChain(obj->pNext);
26514     }
26515     else
26516     {
26517         PRINT_SPACE
26518         _OUT << "\"pNext\":"
26519              << "\"NULL\""
26520              << "," << std::endl;
26521     }
26522 
26523     print_uint32_t(obj->attachmentCount, "attachmentCount", 1);
26524 
26525     PRINT_SPACE
26526     _OUT << "\"pAttachments\":" << std::endl;
26527     PRINT_SPACE
26528     if (obj->pAttachments)
26529     {
26530         _OUT << "[" << std::endl;
26531         for (unsigned int i = 0; i < obj->attachmentCount; i++)
26532         {
26533             std::stringstream tmp;
26534             tmp << "pAttachments"
26535                 << "_" << i;
26536             bool isCommaNeeded = (i + 1) != obj->attachmentCount;
26537             print_VkImageView(obj->pAttachments[i], tmp.str(), isCommaNeeded);
26538         }
26539         PRINT_SPACE
26540         _OUT << "]"
26541              << "" << std::endl;
26542     }
26543     else
26544     {
26545         _OUT << "\"NULL\""
26546              << "" << std::endl;
26547     }
26548 
26549     INDENT(-4);
26550     PRINT_SPACE
26551     if (commaNeeded)
26552         _OUT << "}," << std::endl;
26553     else
26554         _OUT << "}" << std::endl;
26555 }
26556 
print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(VkPhysicalDeviceUniformBufferStandardLayoutFeatures obj,const std::string & s,bool commaNeeded=true)26557 static void print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
26558     VkPhysicalDeviceUniformBufferStandardLayoutFeatures obj, const std::string &s, bool commaNeeded = true)
26559 {
26560     PRINT_SPACE
26561     _OUT << "{" << std::endl;
26562     INDENT(4);
26563 
26564     print_VkStructureType(obj.sType, "sType", 1);
26565 
26566     if (obj.pNext)
26567     {
26568         dumpPNextChain(obj.pNext);
26569     }
26570     else
26571     {
26572         PRINT_SPACE
26573         _OUT << "\"pNext\":"
26574              << "\"NULL\""
26575              << "," << std::endl;
26576     }
26577 
26578     print_VkBool32(obj.uniformBufferStandardLayout, "uniformBufferStandardLayout", 0);
26579 
26580     INDENT(-4);
26581     PRINT_SPACE
26582     if (commaNeeded)
26583         _OUT << "}," << std::endl;
26584     else
26585         _OUT << "}" << std::endl;
26586 }
print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * obj,const std::string & s,bool commaNeeded=true)26587 static void print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
26588     const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *obj, const std::string &s, bool commaNeeded = true)
26589 {
26590     PRINT_SPACE
26591     _OUT << "{" << std::endl;
26592     INDENT(4);
26593 
26594     print_VkStructureType(obj->sType, "sType", 1);
26595 
26596     if (obj->pNext)
26597     {
26598         dumpPNextChain(obj->pNext);
26599     }
26600     else
26601     {
26602         PRINT_SPACE
26603         _OUT << "\"pNext\":"
26604              << "\"NULL\""
26605              << "," << std::endl;
26606     }
26607 
26608     print_VkBool32(obj->uniformBufferStandardLayout, "uniformBufferStandardLayout", 0);
26609 
26610     INDENT(-4);
26611     PRINT_SPACE
26612     if (commaNeeded)
26613         _OUT << "}," << std::endl;
26614     else
26615         _OUT << "}" << std::endl;
26616 }
26617 
print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures obj,const std::string & s,bool commaNeeded=true)26618 static void print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
26619     VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures obj, const std::string &s, bool commaNeeded = true)
26620 {
26621     PRINT_SPACE
26622     _OUT << "{" << std::endl;
26623     INDENT(4);
26624 
26625     print_VkStructureType(obj.sType, "sType", 1);
26626 
26627     if (obj.pNext)
26628     {
26629         dumpPNextChain(obj.pNext);
26630     }
26631     else
26632     {
26633         PRINT_SPACE
26634         _OUT << "\"pNext\":"
26635              << "\"NULL\""
26636              << "," << std::endl;
26637     }
26638 
26639     print_VkBool32(obj.shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 0);
26640 
26641     INDENT(-4);
26642     PRINT_SPACE
26643     if (commaNeeded)
26644         _OUT << "}," << std::endl;
26645     else
26646         _OUT << "}" << std::endl;
26647 }
print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * obj,const std::string & s,bool commaNeeded=true)26648 static void print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
26649     const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *obj, const std::string &s, bool commaNeeded = true)
26650 {
26651     PRINT_SPACE
26652     _OUT << "{" << std::endl;
26653     INDENT(4);
26654 
26655     print_VkStructureType(obj->sType, "sType", 1);
26656 
26657     if (obj->pNext)
26658     {
26659         dumpPNextChain(obj->pNext);
26660     }
26661     else
26662     {
26663         PRINT_SPACE
26664         _OUT << "\"pNext\":"
26665              << "\"NULL\""
26666              << "," << std::endl;
26667     }
26668 
26669     print_VkBool32(obj->shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 0);
26670 
26671     INDENT(-4);
26672     PRINT_SPACE
26673     if (commaNeeded)
26674         _OUT << "}," << std::endl;
26675     else
26676         _OUT << "}" << std::endl;
26677 }
26678 
print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures obj,const std::string & s,bool commaNeeded=true)26679 static void print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
26680     VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures obj, const std::string &s, bool commaNeeded = true)
26681 {
26682     PRINT_SPACE
26683     _OUT << "{" << std::endl;
26684     INDENT(4);
26685 
26686     print_VkStructureType(obj.sType, "sType", 1);
26687 
26688     if (obj.pNext)
26689     {
26690         dumpPNextChain(obj.pNext);
26691     }
26692     else
26693     {
26694         PRINT_SPACE
26695         _OUT << "\"pNext\":"
26696              << "\"NULL\""
26697              << "," << std::endl;
26698     }
26699 
26700     print_VkBool32(obj.separateDepthStencilLayouts, "separateDepthStencilLayouts", 0);
26701 
26702     INDENT(-4);
26703     PRINT_SPACE
26704     if (commaNeeded)
26705         _OUT << "}," << std::endl;
26706     else
26707         _OUT << "}" << std::endl;
26708 }
print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * obj,const std::string & s,bool commaNeeded=true)26709 static void print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
26710     const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *obj, const std::string &s, bool commaNeeded = true)
26711 {
26712     PRINT_SPACE
26713     _OUT << "{" << std::endl;
26714     INDENT(4);
26715 
26716     print_VkStructureType(obj->sType, "sType", 1);
26717 
26718     if (obj->pNext)
26719     {
26720         dumpPNextChain(obj->pNext);
26721     }
26722     else
26723     {
26724         PRINT_SPACE
26725         _OUT << "\"pNext\":"
26726              << "\"NULL\""
26727              << "," << std::endl;
26728     }
26729 
26730     print_VkBool32(obj->separateDepthStencilLayouts, "separateDepthStencilLayouts", 0);
26731 
26732     INDENT(-4);
26733     PRINT_SPACE
26734     if (commaNeeded)
26735         _OUT << "}," << std::endl;
26736     else
26737         _OUT << "}" << std::endl;
26738 }
26739 
print_VkAttachmentReferenceStencilLayout(VkAttachmentReferenceStencilLayout obj,const std::string & s,bool commaNeeded=true)26740 static void print_VkAttachmentReferenceStencilLayout(VkAttachmentReferenceStencilLayout obj, const std::string &s,
26741                                                      bool commaNeeded = true)
26742 {
26743     PRINT_SPACE
26744     _OUT << "{" << std::endl;
26745     INDENT(4);
26746 
26747     print_VkStructureType(obj.sType, "sType", 1);
26748 
26749     if (obj.pNext)
26750     {
26751         dumpPNextChain(obj.pNext);
26752     }
26753     else
26754     {
26755         PRINT_SPACE
26756         _OUT << "\"pNext\":"
26757              << "\"NULL\""
26758              << "," << std::endl;
26759     }
26760 
26761     print_VkImageLayout(obj.stencilLayout, "stencilLayout", 0);
26762 
26763     INDENT(-4);
26764     PRINT_SPACE
26765     if (commaNeeded)
26766         _OUT << "}," << std::endl;
26767     else
26768         _OUT << "}" << std::endl;
26769 }
print_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout * obj,const std::string & s,bool commaNeeded=true)26770 static void print_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout *obj,
26771                                                      const std::string &s, bool commaNeeded = true)
26772 {
26773     PRINT_SPACE
26774     _OUT << "{" << std::endl;
26775     INDENT(4);
26776 
26777     print_VkStructureType(obj->sType, "sType", 1);
26778 
26779     if (obj->pNext)
26780     {
26781         dumpPNextChain(obj->pNext);
26782     }
26783     else
26784     {
26785         PRINT_SPACE
26786         _OUT << "\"pNext\":"
26787              << "\"NULL\""
26788              << "," << std::endl;
26789     }
26790 
26791     print_VkImageLayout(obj->stencilLayout, "stencilLayout", 0);
26792 
26793     INDENT(-4);
26794     PRINT_SPACE
26795     if (commaNeeded)
26796         _OUT << "}," << std::endl;
26797     else
26798         _OUT << "}" << std::endl;
26799 }
26800 
print_VkAttachmentDescriptionStencilLayout(VkAttachmentDescriptionStencilLayout obj,const std::string & s,bool commaNeeded=true)26801 static void print_VkAttachmentDescriptionStencilLayout(VkAttachmentDescriptionStencilLayout obj, const std::string &s,
26802                                                        bool commaNeeded = true)
26803 {
26804     PRINT_SPACE
26805     _OUT << "{" << std::endl;
26806     INDENT(4);
26807 
26808     print_VkStructureType(obj.sType, "sType", 1);
26809 
26810     if (obj.pNext)
26811     {
26812         dumpPNextChain(obj.pNext);
26813     }
26814     else
26815     {
26816         PRINT_SPACE
26817         _OUT << "\"pNext\":"
26818              << "\"NULL\""
26819              << "," << std::endl;
26820     }
26821 
26822     print_VkImageLayout(obj.stencilInitialLayout, "stencilInitialLayout", 1);
26823 
26824     print_VkImageLayout(obj.stencilFinalLayout, "stencilFinalLayout", 0);
26825 
26826     INDENT(-4);
26827     PRINT_SPACE
26828     if (commaNeeded)
26829         _OUT << "}," << std::endl;
26830     else
26831         _OUT << "}" << std::endl;
26832 }
print_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout * obj,const std::string & s,bool commaNeeded=true)26833 static void print_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout *obj,
26834                                                        const std::string &s, bool commaNeeded = true)
26835 {
26836     PRINT_SPACE
26837     _OUT << "{" << std::endl;
26838     INDENT(4);
26839 
26840     print_VkStructureType(obj->sType, "sType", 1);
26841 
26842     if (obj->pNext)
26843     {
26844         dumpPNextChain(obj->pNext);
26845     }
26846     else
26847     {
26848         PRINT_SPACE
26849         _OUT << "\"pNext\":"
26850              << "\"NULL\""
26851              << "," << std::endl;
26852     }
26853 
26854     print_VkImageLayout(obj->stencilInitialLayout, "stencilInitialLayout", 1);
26855 
26856     print_VkImageLayout(obj->stencilFinalLayout, "stencilFinalLayout", 0);
26857 
26858     INDENT(-4);
26859     PRINT_SPACE
26860     if (commaNeeded)
26861         _OUT << "}," << std::endl;
26862     else
26863         _OUT << "}" << std::endl;
26864 }
26865 
print_VkPhysicalDeviceHostQueryResetFeatures(VkPhysicalDeviceHostQueryResetFeatures obj,const std::string & s,bool commaNeeded=true)26866 static void print_VkPhysicalDeviceHostQueryResetFeatures(VkPhysicalDeviceHostQueryResetFeatures obj,
26867                                                          const std::string &s, bool commaNeeded = true)
26868 {
26869     PRINT_SPACE
26870     _OUT << "{" << std::endl;
26871     INDENT(4);
26872 
26873     print_VkStructureType(obj.sType, "sType", 1);
26874 
26875     if (obj.pNext)
26876     {
26877         dumpPNextChain(obj.pNext);
26878     }
26879     else
26880     {
26881         PRINT_SPACE
26882         _OUT << "\"pNext\":"
26883              << "\"NULL\""
26884              << "," << std::endl;
26885     }
26886 
26887     print_VkBool32(obj.hostQueryReset, "hostQueryReset", 0);
26888 
26889     INDENT(-4);
26890     PRINT_SPACE
26891     if (commaNeeded)
26892         _OUT << "}," << std::endl;
26893     else
26894         _OUT << "}" << std::endl;
26895 }
print_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures * obj,const std::string & s,bool commaNeeded=true)26896 static void print_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures *obj,
26897                                                          const std::string &s, bool commaNeeded = true)
26898 {
26899     PRINT_SPACE
26900     _OUT << "{" << std::endl;
26901     INDENT(4);
26902 
26903     print_VkStructureType(obj->sType, "sType", 1);
26904 
26905     if (obj->pNext)
26906     {
26907         dumpPNextChain(obj->pNext);
26908     }
26909     else
26910     {
26911         PRINT_SPACE
26912         _OUT << "\"pNext\":"
26913              << "\"NULL\""
26914              << "," << std::endl;
26915     }
26916 
26917     print_VkBool32(obj->hostQueryReset, "hostQueryReset", 0);
26918 
26919     INDENT(-4);
26920     PRINT_SPACE
26921     if (commaNeeded)
26922         _OUT << "}," << std::endl;
26923     else
26924         _OUT << "}" << std::endl;
26925 }
26926 
print_VkPhysicalDeviceTimelineSemaphoreFeatures(VkPhysicalDeviceTimelineSemaphoreFeatures obj,const std::string & s,bool commaNeeded=true)26927 static void print_VkPhysicalDeviceTimelineSemaphoreFeatures(VkPhysicalDeviceTimelineSemaphoreFeatures obj,
26928                                                             const std::string &s, bool commaNeeded = true)
26929 {
26930     PRINT_SPACE
26931     _OUT << "{" << std::endl;
26932     INDENT(4);
26933 
26934     print_VkStructureType(obj.sType, "sType", 1);
26935 
26936     if (obj.pNext)
26937     {
26938         dumpPNextChain(obj.pNext);
26939     }
26940     else
26941     {
26942         PRINT_SPACE
26943         _OUT << "\"pNext\":"
26944              << "\"NULL\""
26945              << "," << std::endl;
26946     }
26947 
26948     print_VkBool32(obj.timelineSemaphore, "timelineSemaphore", 0);
26949 
26950     INDENT(-4);
26951     PRINT_SPACE
26952     if (commaNeeded)
26953         _OUT << "}," << std::endl;
26954     else
26955         _OUT << "}" << std::endl;
26956 }
print_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures * obj,const std::string & s,bool commaNeeded=true)26957 static void print_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures *obj,
26958                                                             const std::string &s, bool commaNeeded = true)
26959 {
26960     PRINT_SPACE
26961     _OUT << "{" << std::endl;
26962     INDENT(4);
26963 
26964     print_VkStructureType(obj->sType, "sType", 1);
26965 
26966     if (obj->pNext)
26967     {
26968         dumpPNextChain(obj->pNext);
26969     }
26970     else
26971     {
26972         PRINT_SPACE
26973         _OUT << "\"pNext\":"
26974              << "\"NULL\""
26975              << "," << std::endl;
26976     }
26977 
26978     print_VkBool32(obj->timelineSemaphore, "timelineSemaphore", 0);
26979 
26980     INDENT(-4);
26981     PRINT_SPACE
26982     if (commaNeeded)
26983         _OUT << "}," << std::endl;
26984     else
26985         _OUT << "}" << std::endl;
26986 }
26987 
print_VkPhysicalDeviceTimelineSemaphoreProperties(VkPhysicalDeviceTimelineSemaphoreProperties obj,const std::string & s,bool commaNeeded=true)26988 static void print_VkPhysicalDeviceTimelineSemaphoreProperties(VkPhysicalDeviceTimelineSemaphoreProperties obj,
26989                                                               const std::string &s, bool commaNeeded = true)
26990 {
26991     PRINT_SPACE
26992     _OUT << "{" << std::endl;
26993     INDENT(4);
26994 
26995     print_VkStructureType(obj.sType, "sType", 1);
26996 
26997     if (obj.pNext)
26998     {
26999         dumpPNextChain(obj.pNext);
27000     }
27001     else
27002     {
27003         PRINT_SPACE
27004         _OUT << "\"pNext\":"
27005              << "\"NULL\""
27006              << "," << std::endl;
27007     }
27008 
27009     print_uint64_t(obj.maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 0);
27010 
27011     INDENT(-4);
27012     PRINT_SPACE
27013     if (commaNeeded)
27014         _OUT << "}," << std::endl;
27015     else
27016         _OUT << "}" << std::endl;
27017 }
print_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties * obj,const std::string & s,bool commaNeeded=true)27018 static void print_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties *obj,
27019                                                               const std::string &s, bool commaNeeded = true)
27020 {
27021     PRINT_SPACE
27022     _OUT << "{" << std::endl;
27023     INDENT(4);
27024 
27025     print_VkStructureType(obj->sType, "sType", 1);
27026 
27027     if (obj->pNext)
27028     {
27029         dumpPNextChain(obj->pNext);
27030     }
27031     else
27032     {
27033         PRINT_SPACE
27034         _OUT << "\"pNext\":"
27035              << "\"NULL\""
27036              << "," << std::endl;
27037     }
27038 
27039     print_uint64_t(obj->maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 0);
27040 
27041     INDENT(-4);
27042     PRINT_SPACE
27043     if (commaNeeded)
27044         _OUT << "}," << std::endl;
27045     else
27046         _OUT << "}" << std::endl;
27047 }
27048 
print_VkSemaphoreTypeCreateInfo(VkSemaphoreTypeCreateInfo obj,const std::string & s,bool commaNeeded=true)27049 static void print_VkSemaphoreTypeCreateInfo(VkSemaphoreTypeCreateInfo obj, const std::string &s,
27050                                             bool commaNeeded = true)
27051 {
27052     PRINT_SPACE
27053     _OUT << "{" << std::endl;
27054     INDENT(4);
27055 
27056     print_VkStructureType(obj.sType, "sType", 1);
27057 
27058     if (obj.pNext)
27059     {
27060         dumpPNextChain(obj.pNext);
27061     }
27062     else
27063     {
27064         PRINT_SPACE
27065         _OUT << "\"pNext\":"
27066              << "\"NULL\""
27067              << "," << std::endl;
27068     }
27069 
27070     print_VkSemaphoreType(obj.semaphoreType, "semaphoreType", 1);
27071 
27072     print_uint64_t(obj.initialValue, "initialValue", 0);
27073 
27074     INDENT(-4);
27075     PRINT_SPACE
27076     if (commaNeeded)
27077         _OUT << "}," << std::endl;
27078     else
27079         _OUT << "}" << std::endl;
27080 }
print_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo * obj,const std::string & s,bool commaNeeded=true)27081 static void print_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo *obj, const std::string &s,
27082                                             bool commaNeeded = true)
27083 {
27084     PRINT_SPACE
27085     _OUT << "{" << std::endl;
27086     INDENT(4);
27087 
27088     print_VkStructureType(obj->sType, "sType", 1);
27089 
27090     if (obj->pNext)
27091     {
27092         dumpPNextChain(obj->pNext);
27093     }
27094     else
27095     {
27096         PRINT_SPACE
27097         _OUT << "\"pNext\":"
27098              << "\"NULL\""
27099              << "," << std::endl;
27100     }
27101 
27102     print_VkSemaphoreType(obj->semaphoreType, "semaphoreType", 1);
27103 
27104     print_uint64_t(obj->initialValue, "initialValue", 0);
27105 
27106     INDENT(-4);
27107     PRINT_SPACE
27108     if (commaNeeded)
27109         _OUT << "}," << std::endl;
27110     else
27111         _OUT << "}" << std::endl;
27112 }
27113 
print_VkTimelineSemaphoreSubmitInfo(VkTimelineSemaphoreSubmitInfo obj,const std::string & s,bool commaNeeded=true)27114 static void print_VkTimelineSemaphoreSubmitInfo(VkTimelineSemaphoreSubmitInfo obj, const std::string &s,
27115                                                 bool commaNeeded = true)
27116 {
27117     PRINT_SPACE
27118     _OUT << "{" << std::endl;
27119     INDENT(4);
27120 
27121     print_VkStructureType(obj.sType, "sType", 1);
27122 
27123     if (obj.pNext)
27124     {
27125         dumpPNextChain(obj.pNext);
27126     }
27127     else
27128     {
27129         PRINT_SPACE
27130         _OUT << "\"pNext\":"
27131              << "\"NULL\""
27132              << "," << std::endl;
27133     }
27134 
27135     print_uint32_t(obj.waitSemaphoreValueCount, "waitSemaphoreValueCount", 1);
27136 
27137     PRINT_SPACE
27138     _OUT << "\"pWaitSemaphoreValues\":" << std::endl;
27139     PRINT_SPACE
27140     if (obj.pWaitSemaphoreValues)
27141     {
27142         _OUT << "[" << std::endl;
27143         for (unsigned int i = 0; i < obj.waitSemaphoreValueCount; i++)
27144         {
27145             bool isCommaNeeded = (i + 1) != obj.waitSemaphoreValueCount;
27146             print_uint64_t(obj.pWaitSemaphoreValues[i], "", isCommaNeeded);
27147         }
27148         PRINT_SPACE
27149         _OUT << "]"
27150              << "," << std::endl;
27151     }
27152     else
27153     {
27154         _OUT << "\"NULL\""
27155              << "," << std::endl;
27156     }
27157 
27158     print_uint32_t(obj.signalSemaphoreValueCount, "signalSemaphoreValueCount", 1);
27159 
27160     PRINT_SPACE
27161     _OUT << "\"pSignalSemaphoreValues\":" << std::endl;
27162     PRINT_SPACE
27163     if (obj.pSignalSemaphoreValues)
27164     {
27165         _OUT << "[" << std::endl;
27166         for (unsigned int i = 0; i < obj.signalSemaphoreValueCount; i++)
27167         {
27168             bool isCommaNeeded = (i + 1) != obj.signalSemaphoreValueCount;
27169             print_uint64_t(obj.pSignalSemaphoreValues[i], "", isCommaNeeded);
27170         }
27171         PRINT_SPACE
27172         _OUT << "]"
27173              << "" << std::endl;
27174     }
27175     else
27176     {
27177         _OUT << "\"NULL\""
27178              << "" << std::endl;
27179     }
27180 
27181     INDENT(-4);
27182     PRINT_SPACE
27183     if (commaNeeded)
27184         _OUT << "}," << std::endl;
27185     else
27186         _OUT << "}" << std::endl;
27187 }
print_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo * obj,const std::string & s,bool commaNeeded=true)27188 static void print_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo *obj, const std::string &s,
27189                                                 bool commaNeeded = true)
27190 {
27191     PRINT_SPACE
27192     _OUT << "{" << std::endl;
27193     INDENT(4);
27194 
27195     print_VkStructureType(obj->sType, "sType", 1);
27196 
27197     if (obj->pNext)
27198     {
27199         dumpPNextChain(obj->pNext);
27200     }
27201     else
27202     {
27203         PRINT_SPACE
27204         _OUT << "\"pNext\":"
27205              << "\"NULL\""
27206              << "," << std::endl;
27207     }
27208 
27209     print_uint32_t(obj->waitSemaphoreValueCount, "waitSemaphoreValueCount", 1);
27210 
27211     PRINT_SPACE
27212     _OUT << "\"pWaitSemaphoreValues\":" << std::endl;
27213     PRINT_SPACE
27214     if (obj->pWaitSemaphoreValues)
27215     {
27216         _OUT << "[" << std::endl;
27217         for (unsigned int i = 0; i < obj->waitSemaphoreValueCount; i++)
27218         {
27219             bool isCommaNeeded = (i + 1) != obj->waitSemaphoreValueCount;
27220             print_uint64_t(obj->pWaitSemaphoreValues[i], "", isCommaNeeded);
27221         }
27222         PRINT_SPACE
27223         _OUT << "]"
27224              << "," << std::endl;
27225     }
27226     else
27227     {
27228         _OUT << "\"NULL\""
27229              << "," << std::endl;
27230     }
27231 
27232     print_uint32_t(obj->signalSemaphoreValueCount, "signalSemaphoreValueCount", 1);
27233 
27234     PRINT_SPACE
27235     _OUT << "\"pSignalSemaphoreValues\":" << std::endl;
27236     PRINT_SPACE
27237     if (obj->pSignalSemaphoreValues)
27238     {
27239         _OUT << "[" << std::endl;
27240         for (unsigned int i = 0; i < obj->signalSemaphoreValueCount; i++)
27241         {
27242             bool isCommaNeeded = (i + 1) != obj->signalSemaphoreValueCount;
27243             print_uint64_t(obj->pSignalSemaphoreValues[i], "", isCommaNeeded);
27244         }
27245         PRINT_SPACE
27246         _OUT << "]"
27247              << "" << std::endl;
27248     }
27249     else
27250     {
27251         _OUT << "\"NULL\""
27252              << "" << std::endl;
27253     }
27254 
27255     INDENT(-4);
27256     PRINT_SPACE
27257     if (commaNeeded)
27258         _OUT << "}," << std::endl;
27259     else
27260         _OUT << "}" << std::endl;
27261 }
27262 
print_VkSemaphoreWaitInfo(VkSemaphoreWaitInfo obj,const std::string & s,bool commaNeeded=true)27263 static void print_VkSemaphoreWaitInfo(VkSemaphoreWaitInfo obj, const std::string &s, bool commaNeeded = true)
27264 {
27265     PRINT_SPACE
27266     _OUT << "{" << std::endl;
27267     INDENT(4);
27268 
27269     print_VkStructureType(obj.sType, "sType", 1);
27270 
27271     if (obj.pNext)
27272     {
27273         dumpPNextChain(obj.pNext);
27274     }
27275     else
27276     {
27277         PRINT_SPACE
27278         _OUT << "\"pNext\":"
27279              << "\"NULL\""
27280              << "," << std::endl;
27281     }
27282 
27283     print_VkSemaphoreWaitFlags(obj.flags, "flags", 1);
27284 
27285     print_uint32_t(obj.semaphoreCount, "semaphoreCount", 1);
27286 
27287     PRINT_SPACE
27288     _OUT << "\"pSemaphores\":" << std::endl;
27289     PRINT_SPACE
27290     if (obj.pSemaphores)
27291     {
27292         _OUT << "[" << std::endl;
27293         for (unsigned int i = 0; i < obj.semaphoreCount; i++)
27294         {
27295             std::stringstream tmp;
27296             tmp << "pSemaphores"
27297                 << "_" << i;
27298             bool isCommaNeeded = (i + 1) != obj.semaphoreCount;
27299             print_VkSemaphore(obj.pSemaphores[i], tmp.str(), isCommaNeeded);
27300         }
27301         PRINT_SPACE
27302         _OUT << "]"
27303              << "," << std::endl;
27304     }
27305     else
27306     {
27307         _OUT << "\"NULL\""
27308              << "," << std::endl;
27309     }
27310 
27311     PRINT_SPACE
27312     _OUT << "\"pValues\":" << std::endl;
27313     PRINT_SPACE
27314     if (obj.pValues)
27315     {
27316         _OUT << "[" << std::endl;
27317         for (unsigned int i = 0; i < obj.semaphoreCount; i++)
27318         {
27319             bool isCommaNeeded = (i + 1) != obj.semaphoreCount;
27320             print_uint64_t(obj.pValues[i], "", isCommaNeeded);
27321         }
27322         PRINT_SPACE
27323         _OUT << "]"
27324              << "" << std::endl;
27325     }
27326     else
27327     {
27328         _OUT << "\"NULL\""
27329              << "" << std::endl;
27330     }
27331 
27332     INDENT(-4);
27333     PRINT_SPACE
27334     if (commaNeeded)
27335         _OUT << "}," << std::endl;
27336     else
27337         _OUT << "}" << std::endl;
27338 }
print_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo * obj,const std::string & s,bool commaNeeded=true)27339 static void print_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo *obj, const std::string &s, bool commaNeeded = true)
27340 {
27341     PRINT_SPACE
27342     _OUT << "{" << std::endl;
27343     INDENT(4);
27344 
27345     print_VkStructureType(obj->sType, "sType", 1);
27346 
27347     if (obj->pNext)
27348     {
27349         dumpPNextChain(obj->pNext);
27350     }
27351     else
27352     {
27353         PRINT_SPACE
27354         _OUT << "\"pNext\":"
27355              << "\"NULL\""
27356              << "," << std::endl;
27357     }
27358 
27359     print_VkSemaphoreWaitFlags(obj->flags, "flags", 1);
27360 
27361     print_uint32_t(obj->semaphoreCount, "semaphoreCount", 1);
27362 
27363     PRINT_SPACE
27364     _OUT << "\"pSemaphores\":" << std::endl;
27365     PRINT_SPACE
27366     if (obj->pSemaphores)
27367     {
27368         _OUT << "[" << std::endl;
27369         for (unsigned int i = 0; i < obj->semaphoreCount; i++)
27370         {
27371             std::stringstream tmp;
27372             tmp << "pSemaphores"
27373                 << "_" << i;
27374             bool isCommaNeeded = (i + 1) != obj->semaphoreCount;
27375             print_VkSemaphore(obj->pSemaphores[i], tmp.str(), isCommaNeeded);
27376         }
27377         PRINT_SPACE
27378         _OUT << "]"
27379              << "," << std::endl;
27380     }
27381     else
27382     {
27383         _OUT << "\"NULL\""
27384              << "," << std::endl;
27385     }
27386 
27387     PRINT_SPACE
27388     _OUT << "\"pValues\":" << std::endl;
27389     PRINT_SPACE
27390     if (obj->pValues)
27391     {
27392         _OUT << "[" << std::endl;
27393         for (unsigned int i = 0; i < obj->semaphoreCount; i++)
27394         {
27395             bool isCommaNeeded = (i + 1) != obj->semaphoreCount;
27396             print_uint64_t(obj->pValues[i], "", isCommaNeeded);
27397         }
27398         PRINT_SPACE
27399         _OUT << "]"
27400              << "" << std::endl;
27401     }
27402     else
27403     {
27404         _OUT << "\"NULL\""
27405              << "" << std::endl;
27406     }
27407 
27408     INDENT(-4);
27409     PRINT_SPACE
27410     if (commaNeeded)
27411         _OUT << "}," << std::endl;
27412     else
27413         _OUT << "}" << std::endl;
27414 }
27415 
print_VkSemaphoreSignalInfo(VkSemaphoreSignalInfo obj,const std::string & s,bool commaNeeded=true)27416 static void print_VkSemaphoreSignalInfo(VkSemaphoreSignalInfo obj, const std::string &s, bool commaNeeded = true)
27417 {
27418     PRINT_SPACE
27419     _OUT << "{" << std::endl;
27420     INDENT(4);
27421 
27422     print_VkStructureType(obj.sType, "sType", 1);
27423 
27424     if (obj.pNext)
27425     {
27426         dumpPNextChain(obj.pNext);
27427     }
27428     else
27429     {
27430         PRINT_SPACE
27431         _OUT << "\"pNext\":"
27432              << "\"NULL\""
27433              << "," << std::endl;
27434     }
27435 
27436     // CTS : required value
27437     PRINT_SPACE _OUT << "\""
27438                      << "semaphore"
27439                      << "\""
27440                      << " : "
27441                      << "\""
27442                      << "\"," << std::endl;
27443 
27444     print_uint64_t(obj.value, "value", 0);
27445 
27446     INDENT(-4);
27447     PRINT_SPACE
27448     if (commaNeeded)
27449         _OUT << "}," << std::endl;
27450     else
27451         _OUT << "}" << std::endl;
27452 }
print_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo * obj,const std::string & s,bool commaNeeded=true)27453 static void print_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo *obj, const std::string &s, bool commaNeeded = true)
27454 {
27455     PRINT_SPACE
27456     _OUT << "{" << std::endl;
27457     INDENT(4);
27458 
27459     print_VkStructureType(obj->sType, "sType", 1);
27460 
27461     if (obj->pNext)
27462     {
27463         dumpPNextChain(obj->pNext);
27464     }
27465     else
27466     {
27467         PRINT_SPACE
27468         _OUT << "\"pNext\":"
27469              << "\"NULL\""
27470              << "," << std::endl;
27471     }
27472 
27473     // CTS : required value
27474     PRINT_SPACE _OUT << "\""
27475                      << "semaphore"
27476                      << "\""
27477                      << " : "
27478                      << "\""
27479                      << "\"," << std::endl;
27480 
27481     print_uint64_t(obj->value, "value", 0);
27482 
27483     INDENT(-4);
27484     PRINT_SPACE
27485     if (commaNeeded)
27486         _OUT << "}," << std::endl;
27487     else
27488         _OUT << "}" << std::endl;
27489 }
27490 
print_VkPhysicalDeviceBufferDeviceAddressFeatures(VkPhysicalDeviceBufferDeviceAddressFeatures obj,const std::string & s,bool commaNeeded=true)27491 static void print_VkPhysicalDeviceBufferDeviceAddressFeatures(VkPhysicalDeviceBufferDeviceAddressFeatures obj,
27492                                                               const std::string &s, bool commaNeeded = true)
27493 {
27494     PRINT_SPACE
27495     _OUT << "{" << std::endl;
27496     INDENT(4);
27497 
27498     print_VkStructureType(obj.sType, "sType", 1);
27499 
27500     if (obj.pNext)
27501     {
27502         dumpPNextChain(obj.pNext);
27503     }
27504     else
27505     {
27506         PRINT_SPACE
27507         _OUT << "\"pNext\":"
27508              << "\"NULL\""
27509              << "," << std::endl;
27510     }
27511 
27512     print_VkBool32(obj.bufferDeviceAddress, "bufferDeviceAddress", 1);
27513 
27514     print_VkBool32(obj.bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1);
27515 
27516     print_VkBool32(obj.bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 0);
27517 
27518     INDENT(-4);
27519     PRINT_SPACE
27520     if (commaNeeded)
27521         _OUT << "}," << std::endl;
27522     else
27523         _OUT << "}" << std::endl;
27524 }
print_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures * obj,const std::string & s,bool commaNeeded=true)27525 static void print_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures *obj,
27526                                                               const std::string &s, bool commaNeeded = true)
27527 {
27528     PRINT_SPACE
27529     _OUT << "{" << std::endl;
27530     INDENT(4);
27531 
27532     print_VkStructureType(obj->sType, "sType", 1);
27533 
27534     if (obj->pNext)
27535     {
27536         dumpPNextChain(obj->pNext);
27537     }
27538     else
27539     {
27540         PRINT_SPACE
27541         _OUT << "\"pNext\":"
27542              << "\"NULL\""
27543              << "," << std::endl;
27544     }
27545 
27546     print_VkBool32(obj->bufferDeviceAddress, "bufferDeviceAddress", 1);
27547 
27548     print_VkBool32(obj->bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1);
27549 
27550     print_VkBool32(obj->bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 0);
27551 
27552     INDENT(-4);
27553     PRINT_SPACE
27554     if (commaNeeded)
27555         _OUT << "}," << std::endl;
27556     else
27557         _OUT << "}" << std::endl;
27558 }
27559 
print_VkBufferDeviceAddressInfo(VkBufferDeviceAddressInfo obj,const std::string & s,bool commaNeeded=true)27560 static void print_VkBufferDeviceAddressInfo(VkBufferDeviceAddressInfo obj, const std::string &s,
27561                                             bool commaNeeded = true)
27562 {
27563     PRINT_SPACE
27564     _OUT << "{" << std::endl;
27565     INDENT(4);
27566 
27567     print_VkStructureType(obj.sType, "sType", 1);
27568 
27569     if (obj.pNext)
27570     {
27571         dumpPNextChain(obj.pNext);
27572     }
27573     else
27574     {
27575         PRINT_SPACE
27576         _OUT << "\"pNext\":"
27577              << "\"NULL\""
27578              << "," << std::endl;
27579     }
27580 
27581     // CTS : required value
27582     PRINT_SPACE _OUT << "\""
27583                      << "buffer"
27584                      << "\""
27585                      << " : "
27586                      << "\""
27587                      << "\"" << std::endl;
27588 
27589     INDENT(-4);
27590     PRINT_SPACE
27591     if (commaNeeded)
27592         _OUT << "}," << std::endl;
27593     else
27594         _OUT << "}" << std::endl;
27595 }
print_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo * obj,const std::string & s,bool commaNeeded=true)27596 static void print_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo *obj, const std::string &s,
27597                                             bool commaNeeded = true)
27598 {
27599     PRINT_SPACE
27600     _OUT << "{" << std::endl;
27601     INDENT(4);
27602 
27603     print_VkStructureType(obj->sType, "sType", 1);
27604 
27605     if (obj->pNext)
27606     {
27607         dumpPNextChain(obj->pNext);
27608     }
27609     else
27610     {
27611         PRINT_SPACE
27612         _OUT << "\"pNext\":"
27613              << "\"NULL\""
27614              << "," << std::endl;
27615     }
27616 
27617     // CTS : required value
27618     PRINT_SPACE _OUT << "\""
27619                      << "buffer"
27620                      << "\""
27621                      << " : "
27622                      << "\""
27623                      << "\"" << std::endl;
27624 
27625     INDENT(-4);
27626     PRINT_SPACE
27627     if (commaNeeded)
27628         _OUT << "}," << std::endl;
27629     else
27630         _OUT << "}" << std::endl;
27631 }
27632 
print_VkBufferOpaqueCaptureAddressCreateInfo(VkBufferOpaqueCaptureAddressCreateInfo obj,const std::string & s,bool commaNeeded=true)27633 static void print_VkBufferOpaqueCaptureAddressCreateInfo(VkBufferOpaqueCaptureAddressCreateInfo obj,
27634                                                          const std::string &s, bool commaNeeded = true)
27635 {
27636     PRINT_SPACE
27637     _OUT << "{" << std::endl;
27638     INDENT(4);
27639 
27640     print_VkStructureType(obj.sType, "sType", 1);
27641 
27642     if (obj.pNext)
27643     {
27644         dumpPNextChain(obj.pNext);
27645     }
27646     else
27647     {
27648         PRINT_SPACE
27649         _OUT << "\"pNext\":"
27650              << "\"NULL\""
27651              << "," << std::endl;
27652     }
27653 
27654     print_uint64_t(obj.opaqueCaptureAddress, "opaqueCaptureAddress", 0);
27655 
27656     INDENT(-4);
27657     PRINT_SPACE
27658     if (commaNeeded)
27659         _OUT << "}," << std::endl;
27660     else
27661         _OUT << "}" << std::endl;
27662 }
print_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo * obj,const std::string & s,bool commaNeeded=true)27663 static void print_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo *obj,
27664                                                          const std::string &s, bool commaNeeded = true)
27665 {
27666     PRINT_SPACE
27667     _OUT << "{" << std::endl;
27668     INDENT(4);
27669 
27670     print_VkStructureType(obj->sType, "sType", 1);
27671 
27672     if (obj->pNext)
27673     {
27674         dumpPNextChain(obj->pNext);
27675     }
27676     else
27677     {
27678         PRINT_SPACE
27679         _OUT << "\"pNext\":"
27680              << "\"NULL\""
27681              << "," << std::endl;
27682     }
27683 
27684     print_uint64_t(obj->opaqueCaptureAddress, "opaqueCaptureAddress", 0);
27685 
27686     INDENT(-4);
27687     PRINT_SPACE
27688     if (commaNeeded)
27689         _OUT << "}," << std::endl;
27690     else
27691         _OUT << "}" << std::endl;
27692 }
27693 
print_VkMemoryOpaqueCaptureAddressAllocateInfo(VkMemoryOpaqueCaptureAddressAllocateInfo obj,const std::string & s,bool commaNeeded=true)27694 static void print_VkMemoryOpaqueCaptureAddressAllocateInfo(VkMemoryOpaqueCaptureAddressAllocateInfo obj,
27695                                                            const std::string &s, bool commaNeeded = true)
27696 {
27697     PRINT_SPACE
27698     _OUT << "{" << std::endl;
27699     INDENT(4);
27700 
27701     print_VkStructureType(obj.sType, "sType", 1);
27702 
27703     if (obj.pNext)
27704     {
27705         dumpPNextChain(obj.pNext);
27706     }
27707     else
27708     {
27709         PRINT_SPACE
27710         _OUT << "\"pNext\":"
27711              << "\"NULL\""
27712              << "," << std::endl;
27713     }
27714 
27715     print_uint64_t(obj.opaqueCaptureAddress, "opaqueCaptureAddress", 0);
27716 
27717     INDENT(-4);
27718     PRINT_SPACE
27719     if (commaNeeded)
27720         _OUT << "}," << std::endl;
27721     else
27722         _OUT << "}" << std::endl;
27723 }
print_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo * obj,const std::string & s,bool commaNeeded=true)27724 static void print_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo *obj,
27725                                                            const std::string &s, bool commaNeeded = true)
27726 {
27727     PRINT_SPACE
27728     _OUT << "{" << std::endl;
27729     INDENT(4);
27730 
27731     print_VkStructureType(obj->sType, "sType", 1);
27732 
27733     if (obj->pNext)
27734     {
27735         dumpPNextChain(obj->pNext);
27736     }
27737     else
27738     {
27739         PRINT_SPACE
27740         _OUT << "\"pNext\":"
27741              << "\"NULL\""
27742              << "," << std::endl;
27743     }
27744 
27745     print_uint64_t(obj->opaqueCaptureAddress, "opaqueCaptureAddress", 0);
27746 
27747     INDENT(-4);
27748     PRINT_SPACE
27749     if (commaNeeded)
27750         _OUT << "}," << std::endl;
27751     else
27752         _OUT << "}" << std::endl;
27753 }
27754 
print_VkDeviceMemoryOpaqueCaptureAddressInfo(VkDeviceMemoryOpaqueCaptureAddressInfo obj,const std::string & s,bool commaNeeded=true)27755 static void print_VkDeviceMemoryOpaqueCaptureAddressInfo(VkDeviceMemoryOpaqueCaptureAddressInfo obj,
27756                                                          const std::string &s, bool commaNeeded = true)
27757 {
27758     PRINT_SPACE
27759     _OUT << "{" << std::endl;
27760     INDENT(4);
27761 
27762     print_VkStructureType(obj.sType, "sType", 1);
27763 
27764     if (obj.pNext)
27765     {
27766         dumpPNextChain(obj.pNext);
27767     }
27768     else
27769     {
27770         PRINT_SPACE
27771         _OUT << "\"pNext\":"
27772              << "\"NULL\""
27773              << "," << std::endl;
27774     }
27775 
27776     // CTS : required value
27777     PRINT_SPACE _OUT << "\""
27778                      << "memory"
27779                      << "\""
27780                      << " : "
27781                      << "\""
27782                      << "\"" << std::endl;
27783 
27784     INDENT(-4);
27785     PRINT_SPACE
27786     if (commaNeeded)
27787         _OUT << "}," << std::endl;
27788     else
27789         _OUT << "}" << std::endl;
27790 }
print_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo * obj,const std::string & s,bool commaNeeded=true)27791 static void print_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo *obj,
27792                                                          const std::string &s, bool commaNeeded = true)
27793 {
27794     PRINT_SPACE
27795     _OUT << "{" << std::endl;
27796     INDENT(4);
27797 
27798     print_VkStructureType(obj->sType, "sType", 1);
27799 
27800     if (obj->pNext)
27801     {
27802         dumpPNextChain(obj->pNext);
27803     }
27804     else
27805     {
27806         PRINT_SPACE
27807         _OUT << "\"pNext\":"
27808              << "\"NULL\""
27809              << "," << std::endl;
27810     }
27811 
27812     // CTS : required value
27813     PRINT_SPACE _OUT << "\""
27814                      << "memory"
27815                      << "\""
27816                      << " : "
27817                      << "\""
27818                      << "\"" << std::endl;
27819 
27820     INDENT(-4);
27821     PRINT_SPACE
27822     if (commaNeeded)
27823         _OUT << "}," << std::endl;
27824     else
27825         _OUT << "}" << std::endl;
27826 }
27827 
27828 static std::map<uint64_t, std::string> VkFaultLevel_map = {
27829     std::make_pair(0, "VK_FAULT_LEVEL_UNASSIGNED"),
27830     std::make_pair(1, "VK_FAULT_LEVEL_CRITICAL"),
27831     std::make_pair(2, "VK_FAULT_LEVEL_RECOVERABLE"),
27832     std::make_pair(3, "VK_FAULT_LEVEL_WARNING"),
27833 };
print_VkFaultLevel(VkFaultLevel obj,const std::string & str,bool commaNeeded=true)27834 static void print_VkFaultLevel(VkFaultLevel obj, const std::string &str, bool commaNeeded = true)
27835 {
27836     PRINT_SPACE
27837     if (str != "")
27838         _OUT << "\"" << str << "\""
27839              << " : ";
27840     if (commaNeeded)
27841         _OUT << "\"" << VkFaultLevel_map[obj] << "\"," << std::endl;
27842     else
27843         _OUT << "\"" << VkFaultLevel_map[obj] << "\"" << std::endl;
27844 }
print_VkFaultLevel(const VkFaultLevel * obj,const std::string & str,bool commaNeeded=true)27845 static void print_VkFaultLevel(const VkFaultLevel *obj, const std::string &str, bool commaNeeded = true)
27846 {
27847     PRINT_SPACE
27848     if (str != "")
27849         _OUT << "\"" << str << "\""
27850              << " : ";
27851     if (commaNeeded)
27852         _OUT << "\"" << VkFaultLevel_map[*obj] << "\"," << std::endl;
27853     else
27854         _OUT << "\"" << VkFaultLevel_map[*obj] << "\"" << std::endl;
27855 }
27856 
27857 static std::map<uint64_t, std::string> VkFaultType_map = {
27858     std::make_pair(0, "VK_FAULT_TYPE_INVALID"),           std::make_pair(1, "VK_FAULT_TYPE_UNASSIGNED"),
27859     std::make_pair(2, "VK_FAULT_TYPE_IMPLEMENTATION"),    std::make_pair(3, "VK_FAULT_TYPE_SYSTEM"),
27860     std::make_pair(4, "VK_FAULT_TYPE_PHYSICAL_DEVICE"),   std::make_pair(5, "VK_FAULT_TYPE_COMMAND_BUFFER_FULL"),
27861     std::make_pair(6, "VK_FAULT_TYPE_INVALID_API_USAGE"),
27862 };
print_VkFaultType(VkFaultType obj,const std::string & str,bool commaNeeded=true)27863 static void print_VkFaultType(VkFaultType obj, const std::string &str, bool commaNeeded = true)
27864 {
27865     PRINT_SPACE
27866     if (str != "")
27867         _OUT << "\"" << str << "\""
27868              << " : ";
27869     if (commaNeeded)
27870         _OUT << "\"" << VkFaultType_map[obj] << "\"," << std::endl;
27871     else
27872         _OUT << "\"" << VkFaultType_map[obj] << "\"" << std::endl;
27873 }
print_VkFaultType(const VkFaultType * obj,const std::string & str,bool commaNeeded=true)27874 static void print_VkFaultType(const VkFaultType *obj, const std::string &str, bool commaNeeded = true)
27875 {
27876     PRINT_SPACE
27877     if (str != "")
27878         _OUT << "\"" << str << "\""
27879              << " : ";
27880     if (commaNeeded)
27881         _OUT << "\"" << VkFaultType_map[*obj] << "\"," << std::endl;
27882     else
27883         _OUT << "\"" << VkFaultType_map[*obj] << "\"" << std::endl;
27884 }
27885 
27886 static std::map<uint64_t, std::string> VkFaultQueryBehavior_map = {
27887     std::make_pair(0, "VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS"),
27888 };
print_VkFaultQueryBehavior(VkFaultQueryBehavior obj,const std::string & str,bool commaNeeded=true)27889 static void print_VkFaultQueryBehavior(VkFaultQueryBehavior obj, const std::string &str, bool commaNeeded = true)
27890 {
27891     PRINT_SPACE
27892     if (str != "")
27893         _OUT << "\"" << str << "\""
27894              << " : ";
27895     if (commaNeeded)
27896         _OUT << "\"" << VkFaultQueryBehavior_map[obj] << "\"," << std::endl;
27897     else
27898         _OUT << "\"" << VkFaultQueryBehavior_map[obj] << "\"" << std::endl;
27899 }
print_VkFaultQueryBehavior(const VkFaultQueryBehavior * obj,const std::string & str,bool commaNeeded=true)27900 static void print_VkFaultQueryBehavior(const VkFaultQueryBehavior *obj, const std::string &str, bool commaNeeded = true)
27901 {
27902     PRINT_SPACE
27903     if (str != "")
27904         _OUT << "\"" << str << "\""
27905              << " : ";
27906     if (commaNeeded)
27907         _OUT << "\"" << VkFaultQueryBehavior_map[*obj] << "\"," << std::endl;
27908     else
27909         _OUT << "\"" << VkFaultQueryBehavior_map[*obj] << "\"" << std::endl;
27910 }
27911 
27912 static std::map<uint64_t, std::string> VkPipelineMatchControl_map = {
27913     std::make_pair(0, "VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH"),
27914 };
print_VkPipelineMatchControl(VkPipelineMatchControl obj,const std::string & str,bool commaNeeded=true)27915 static void print_VkPipelineMatchControl(VkPipelineMatchControl obj, const std::string &str, bool commaNeeded = true)
27916 {
27917     PRINT_SPACE
27918     if (str != "")
27919         _OUT << "\"" << str << "\""
27920              << " : ";
27921     if (commaNeeded)
27922         _OUT << "\"" << VkPipelineMatchControl_map[obj] << "\"," << std::endl;
27923     else
27924         _OUT << "\"" << VkPipelineMatchControl_map[obj] << "\"" << std::endl;
27925 }
print_VkPipelineMatchControl(const VkPipelineMatchControl * obj,const std::string & str,bool commaNeeded=true)27926 static void print_VkPipelineMatchControl(const VkPipelineMatchControl *obj, const std::string &str,
27927                                          bool commaNeeded = true)
27928 {
27929     PRINT_SPACE
27930     if (str != "")
27931         _OUT << "\"" << str << "\""
27932              << " : ";
27933     if (commaNeeded)
27934         _OUT << "\"" << VkPipelineMatchControl_map[*obj] << "\"," << std::endl;
27935     else
27936         _OUT << "\"" << VkPipelineMatchControl_map[*obj] << "\"" << std::endl;
27937 }
27938 
27939 static std::map<uint64_t, std::string> VkPipelineCacheValidationVersion_map = {
27940     std::make_pair(1, "VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE"),
27941 };
print_VkPipelineCacheValidationVersion(VkPipelineCacheValidationVersion obj,const std::string & str,bool commaNeeded=true)27942 static void print_VkPipelineCacheValidationVersion(VkPipelineCacheValidationVersion obj, const std::string &str,
27943                                                    bool commaNeeded = true)
27944 {
27945     PRINT_SPACE
27946     if (str != "")
27947         _OUT << "\"" << str << "\""
27948              << " : ";
27949     if (commaNeeded)
27950         _OUT << "\"" << VkPipelineCacheValidationVersion_map[obj] << "\"," << std::endl;
27951     else
27952         _OUT << "\"" << VkPipelineCacheValidationVersion_map[obj] << "\"" << std::endl;
27953 }
print_VkPipelineCacheValidationVersion(const VkPipelineCacheValidationVersion * obj,const std::string & str,bool commaNeeded=true)27954 static void print_VkPipelineCacheValidationVersion(const VkPipelineCacheValidationVersion *obj, const std::string &str,
27955                                                    bool commaNeeded = true)
27956 {
27957     PRINT_SPACE
27958     if (str != "")
27959         _OUT << "\"" << str << "\""
27960              << " : ";
27961     if (commaNeeded)
27962         _OUT << "\"" << VkPipelineCacheValidationVersion_map[*obj] << "\"," << std::endl;
27963     else
27964         _OUT << "\"" << VkPipelineCacheValidationVersion_map[*obj] << "\"" << std::endl;
27965 }
27966 
print_VkPhysicalDeviceVulkanSC10Features(VkPhysicalDeviceVulkanSC10Features obj,const std::string & s,bool commaNeeded=true)27967 static void print_VkPhysicalDeviceVulkanSC10Features(VkPhysicalDeviceVulkanSC10Features obj, const std::string &s,
27968                                                      bool commaNeeded = true)
27969 {
27970     PRINT_SPACE
27971     _OUT << "{" << std::endl;
27972     INDENT(4);
27973 
27974     print_VkStructureType(obj.sType, "sType", 1);
27975 
27976     if (obj.pNext)
27977     {
27978         dumpPNextChain(obj.pNext);
27979     }
27980     else
27981     {
27982         PRINT_SPACE
27983         _OUT << "\"pNext\":"
27984              << "\"NULL\""
27985              << "," << std::endl;
27986     }
27987 
27988     print_VkBool32(obj.shaderAtomicInstructions, "shaderAtomicInstructions", 0);
27989 
27990     INDENT(-4);
27991     PRINT_SPACE
27992     if (commaNeeded)
27993         _OUT << "}," << std::endl;
27994     else
27995         _OUT << "}" << std::endl;
27996 }
print_VkPhysicalDeviceVulkanSC10Features(const VkPhysicalDeviceVulkanSC10Features * obj,const std::string & s,bool commaNeeded=true)27997 static void print_VkPhysicalDeviceVulkanSC10Features(const VkPhysicalDeviceVulkanSC10Features *obj,
27998                                                      const std::string &s, bool commaNeeded = true)
27999 {
28000     PRINT_SPACE
28001     _OUT << "{" << std::endl;
28002     INDENT(4);
28003 
28004     print_VkStructureType(obj->sType, "sType", 1);
28005 
28006     if (obj->pNext)
28007     {
28008         dumpPNextChain(obj->pNext);
28009     }
28010     else
28011     {
28012         PRINT_SPACE
28013         _OUT << "\"pNext\":"
28014              << "\"NULL\""
28015              << "," << std::endl;
28016     }
28017 
28018     print_VkBool32(obj->shaderAtomicInstructions, "shaderAtomicInstructions", 0);
28019 
28020     INDENT(-4);
28021     PRINT_SPACE
28022     if (commaNeeded)
28023         _OUT << "}," << std::endl;
28024     else
28025         _OUT << "}" << std::endl;
28026 }
28027 
print_VkPhysicalDeviceVulkanSC10Properties(VkPhysicalDeviceVulkanSC10Properties obj,const std::string & s,bool commaNeeded=true)28028 static void print_VkPhysicalDeviceVulkanSC10Properties(VkPhysicalDeviceVulkanSC10Properties obj, const std::string &s,
28029                                                        bool commaNeeded = true)
28030 {
28031     PRINT_SPACE
28032     _OUT << "{" << std::endl;
28033     INDENT(4);
28034 
28035     print_VkStructureType(obj.sType, "sType", 1);
28036 
28037     if (obj.pNext)
28038     {
28039         dumpPNextChain(obj.pNext);
28040     }
28041     else
28042     {
28043         PRINT_SPACE
28044         _OUT << "\"pNext\":"
28045              << "\"NULL\""
28046              << "," << std::endl;
28047     }
28048 
28049     print_VkBool32(obj.deviceNoDynamicHostAllocations, "deviceNoDynamicHostAllocations", 1);
28050 
28051     print_VkBool32(obj.deviceDestroyFreesMemory, "deviceDestroyFreesMemory", 1);
28052 
28053     print_VkBool32(obj.commandPoolMultipleCommandBuffersRecording, "commandPoolMultipleCommandBuffersRecording", 1);
28054 
28055     print_VkBool32(obj.commandPoolResetCommandBuffer, "commandPoolResetCommandBuffer", 1);
28056 
28057     print_VkBool32(obj.commandBufferSimultaneousUse, "commandBufferSimultaneousUse", 1);
28058 
28059     print_VkBool32(obj.secondaryCommandBufferNullOrImagelessFramebuffer,
28060                    "secondaryCommandBufferNullOrImagelessFramebuffer", 1);
28061 
28062     print_VkBool32(obj.recycleDescriptorSetMemory, "recycleDescriptorSetMemory", 1);
28063 
28064     print_VkBool32(obj.recyclePipelineMemory, "recyclePipelineMemory", 1);
28065 
28066     print_uint32_t(obj.maxRenderPassSubpasses, "maxRenderPassSubpasses", 1);
28067 
28068     print_uint32_t(obj.maxRenderPassDependencies, "maxRenderPassDependencies", 1);
28069 
28070     print_uint32_t(obj.maxSubpassInputAttachments, "maxSubpassInputAttachments", 1);
28071 
28072     print_uint32_t(obj.maxSubpassPreserveAttachments, "maxSubpassPreserveAttachments", 1);
28073 
28074     print_uint32_t(obj.maxFramebufferAttachments, "maxFramebufferAttachments", 1);
28075 
28076     print_uint32_t(obj.maxDescriptorSetLayoutBindings, "maxDescriptorSetLayoutBindings", 1);
28077 
28078     print_uint32_t(obj.maxQueryFaultCount, "maxQueryFaultCount", 1);
28079 
28080     print_uint32_t(obj.maxCallbackFaultCount, "maxCallbackFaultCount", 1);
28081 
28082     print_uint32_t(obj.maxCommandPoolCommandBuffers, "maxCommandPoolCommandBuffers", 1);
28083 
28084     print_VkDeviceSize(obj.maxCommandBufferSize, "maxCommandBufferSize", 0);
28085 
28086     INDENT(-4);
28087     PRINT_SPACE
28088     if (commaNeeded)
28089         _OUT << "}," << std::endl;
28090     else
28091         _OUT << "}" << std::endl;
28092 }
print_VkPhysicalDeviceVulkanSC10Properties(const VkPhysicalDeviceVulkanSC10Properties * obj,const std::string & s,bool commaNeeded=true)28093 static void print_VkPhysicalDeviceVulkanSC10Properties(const VkPhysicalDeviceVulkanSC10Properties *obj,
28094                                                        const std::string &s, bool commaNeeded = true)
28095 {
28096     PRINT_SPACE
28097     _OUT << "{" << std::endl;
28098     INDENT(4);
28099 
28100     print_VkStructureType(obj->sType, "sType", 1);
28101 
28102     if (obj->pNext)
28103     {
28104         dumpPNextChain(obj->pNext);
28105     }
28106     else
28107     {
28108         PRINT_SPACE
28109         _OUT << "\"pNext\":"
28110              << "\"NULL\""
28111              << "," << std::endl;
28112     }
28113 
28114     print_VkBool32(obj->deviceNoDynamicHostAllocations, "deviceNoDynamicHostAllocations", 1);
28115 
28116     print_VkBool32(obj->deviceDestroyFreesMemory, "deviceDestroyFreesMemory", 1);
28117 
28118     print_VkBool32(obj->commandPoolMultipleCommandBuffersRecording, "commandPoolMultipleCommandBuffersRecording", 1);
28119 
28120     print_VkBool32(obj->commandPoolResetCommandBuffer, "commandPoolResetCommandBuffer", 1);
28121 
28122     print_VkBool32(obj->commandBufferSimultaneousUse, "commandBufferSimultaneousUse", 1);
28123 
28124     print_VkBool32(obj->secondaryCommandBufferNullOrImagelessFramebuffer,
28125                    "secondaryCommandBufferNullOrImagelessFramebuffer", 1);
28126 
28127     print_VkBool32(obj->recycleDescriptorSetMemory, "recycleDescriptorSetMemory", 1);
28128 
28129     print_VkBool32(obj->recyclePipelineMemory, "recyclePipelineMemory", 1);
28130 
28131     print_uint32_t(obj->maxRenderPassSubpasses, "maxRenderPassSubpasses", 1);
28132 
28133     print_uint32_t(obj->maxRenderPassDependencies, "maxRenderPassDependencies", 1);
28134 
28135     print_uint32_t(obj->maxSubpassInputAttachments, "maxSubpassInputAttachments", 1);
28136 
28137     print_uint32_t(obj->maxSubpassPreserveAttachments, "maxSubpassPreserveAttachments", 1);
28138 
28139     print_uint32_t(obj->maxFramebufferAttachments, "maxFramebufferAttachments", 1);
28140 
28141     print_uint32_t(obj->maxDescriptorSetLayoutBindings, "maxDescriptorSetLayoutBindings", 1);
28142 
28143     print_uint32_t(obj->maxQueryFaultCount, "maxQueryFaultCount", 1);
28144 
28145     print_uint32_t(obj->maxCallbackFaultCount, "maxCallbackFaultCount", 1);
28146 
28147     print_uint32_t(obj->maxCommandPoolCommandBuffers, "maxCommandPoolCommandBuffers", 1);
28148 
28149     print_VkDeviceSize(obj->maxCommandBufferSize, "maxCommandBufferSize", 0);
28150 
28151     INDENT(-4);
28152     PRINT_SPACE
28153     if (commaNeeded)
28154         _OUT << "}," << std::endl;
28155     else
28156         _OUT << "}" << std::endl;
28157 }
28158 
print_VkPipelinePoolSize(VkPipelinePoolSize obj,const std::string & s,bool commaNeeded=true)28159 static void print_VkPipelinePoolSize(VkPipelinePoolSize obj, const std::string &s, bool commaNeeded = true)
28160 {
28161     PRINT_SPACE
28162     _OUT << "{" << std::endl;
28163     INDENT(4);
28164 
28165     print_VkStructureType(obj.sType, "sType", 1);
28166 
28167     if (obj.pNext)
28168     {
28169         dumpPNextChain(obj.pNext);
28170     }
28171     else
28172     {
28173         PRINT_SPACE
28174         _OUT << "\"pNext\":"
28175              << "\"NULL\""
28176              << "," << std::endl;
28177     }
28178 
28179     print_VkDeviceSize(obj.poolEntrySize, "poolEntrySize", 1);
28180 
28181     print_uint32_t(obj.poolEntryCount, "poolEntryCount", 0);
28182 
28183     INDENT(-4);
28184     PRINT_SPACE
28185     if (commaNeeded)
28186         _OUT << "}," << std::endl;
28187     else
28188         _OUT << "}" << std::endl;
28189 }
print_VkPipelinePoolSize(const VkPipelinePoolSize * obj,const std::string & s,bool commaNeeded=true)28190 static void print_VkPipelinePoolSize(const VkPipelinePoolSize *obj, const std::string &s, bool commaNeeded = true)
28191 {
28192     PRINT_SPACE
28193     _OUT << "{" << std::endl;
28194     INDENT(4);
28195 
28196     print_VkStructureType(obj->sType, "sType", 1);
28197 
28198     if (obj->pNext)
28199     {
28200         dumpPNextChain(obj->pNext);
28201     }
28202     else
28203     {
28204         PRINT_SPACE
28205         _OUT << "\"pNext\":"
28206              << "\"NULL\""
28207              << "," << std::endl;
28208     }
28209 
28210     print_VkDeviceSize(obj->poolEntrySize, "poolEntrySize", 1);
28211 
28212     print_uint32_t(obj->poolEntryCount, "poolEntryCount", 0);
28213 
28214     INDENT(-4);
28215     PRINT_SPACE
28216     if (commaNeeded)
28217         _OUT << "}," << std::endl;
28218     else
28219         _OUT << "}" << std::endl;
28220 }
28221 
print_VkDeviceObjectReservationCreateInfo(VkDeviceObjectReservationCreateInfo obj,const std::string & s,bool commaNeeded=true)28222 static void print_VkDeviceObjectReservationCreateInfo(VkDeviceObjectReservationCreateInfo obj, const std::string &s,
28223                                                       bool commaNeeded = true)
28224 {
28225     PRINT_SPACE
28226     _OUT << "{" << std::endl;
28227     INDENT(4);
28228 
28229     print_VkStructureType(obj.sType, "sType", 1);
28230 
28231     if (obj.pNext)
28232     {
28233         dumpPNextChain(obj.pNext);
28234     }
28235     else
28236     {
28237         PRINT_SPACE
28238         _OUT << "\"pNext\":"
28239              << "\"NULL\""
28240              << "," << std::endl;
28241     }
28242 
28243     print_uint32_t(obj.pipelineCacheCreateInfoCount, "pipelineCacheCreateInfoCount", 1);
28244 
28245     PRINT_SPACE
28246     _OUT << "\"pPipelineCacheCreateInfos\": " << std::endl;
28247     if (obj.pPipelineCacheCreateInfos)
28248     {
28249         PRINT_SPACE
28250         _OUT << "[" << std::endl;
28251         for (unsigned int i = 0; i < obj.pipelineCacheCreateInfoCount; i++)
28252         {
28253             if (i + 1 == obj.pipelineCacheCreateInfoCount)
28254                 print_VkPipelineCacheCreateInfo(obj.pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 0);
28255             else
28256                 print_VkPipelineCacheCreateInfo(obj.pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 1);
28257         }
28258         PRINT_SPACE
28259         _OUT << "]," << std::endl;
28260     }
28261     else
28262     {
28263         PRINT_SPACE _OUT << "\"NULL\""
28264                          << "," << std::endl;
28265     }
28266 
28267     print_uint32_t(obj.pipelinePoolSizeCount, "pipelinePoolSizeCount", 1);
28268 
28269     PRINT_SPACE
28270     _OUT << "\"pPipelinePoolSizes\": " << std::endl;
28271     if (obj.pPipelinePoolSizes)
28272     {
28273         PRINT_SPACE
28274         _OUT << "[" << std::endl;
28275         for (unsigned int i = 0; i < obj.pipelinePoolSizeCount; i++)
28276         {
28277             if (i + 1 == obj.pipelinePoolSizeCount)
28278                 print_VkPipelinePoolSize(obj.pPipelinePoolSizes[i], "pPipelinePoolSizes", 0);
28279             else
28280                 print_VkPipelinePoolSize(obj.pPipelinePoolSizes[i], "pPipelinePoolSizes", 1);
28281         }
28282         PRINT_SPACE
28283         _OUT << "]," << std::endl;
28284     }
28285     else
28286     {
28287         PRINT_SPACE _OUT << "\"NULL\""
28288                          << "," << std::endl;
28289     }
28290 
28291     print_uint32_t(obj.semaphoreRequestCount, "semaphoreRequestCount", 1);
28292 
28293     print_uint32_t(obj.commandBufferRequestCount, "commandBufferRequestCount", 1);
28294 
28295     print_uint32_t(obj.fenceRequestCount, "fenceRequestCount", 1);
28296 
28297     print_uint32_t(obj.deviceMemoryRequestCount, "deviceMemoryRequestCount", 1);
28298 
28299     print_uint32_t(obj.bufferRequestCount, "bufferRequestCount", 1);
28300 
28301     print_uint32_t(obj.imageRequestCount, "imageRequestCount", 1);
28302 
28303     print_uint32_t(obj.eventRequestCount, "eventRequestCount", 1);
28304 
28305     print_uint32_t(obj.queryPoolRequestCount, "queryPoolRequestCount", 1);
28306 
28307     print_uint32_t(obj.bufferViewRequestCount, "bufferViewRequestCount", 1);
28308 
28309     print_uint32_t(obj.imageViewRequestCount, "imageViewRequestCount", 1);
28310 
28311     print_uint32_t(obj.layeredImageViewRequestCount, "layeredImageViewRequestCount", 1);
28312 
28313     print_uint32_t(obj.pipelineCacheRequestCount, "pipelineCacheRequestCount", 1);
28314 
28315     print_uint32_t(obj.pipelineLayoutRequestCount, "pipelineLayoutRequestCount", 1);
28316 
28317     print_uint32_t(obj.renderPassRequestCount, "renderPassRequestCount", 1);
28318 
28319     print_uint32_t(obj.graphicsPipelineRequestCount, "graphicsPipelineRequestCount", 1);
28320 
28321     print_uint32_t(obj.computePipelineRequestCount, "computePipelineRequestCount", 1);
28322 
28323     print_uint32_t(obj.descriptorSetLayoutRequestCount, "descriptorSetLayoutRequestCount", 1);
28324 
28325     print_uint32_t(obj.samplerRequestCount, "samplerRequestCount", 1);
28326 
28327     print_uint32_t(obj.descriptorPoolRequestCount, "descriptorPoolRequestCount", 1);
28328 
28329     print_uint32_t(obj.descriptorSetRequestCount, "descriptorSetRequestCount", 1);
28330 
28331     print_uint32_t(obj.framebufferRequestCount, "framebufferRequestCount", 1);
28332 
28333     print_uint32_t(obj.commandPoolRequestCount, "commandPoolRequestCount", 1);
28334 
28335     print_uint32_t(obj.samplerYcbcrConversionRequestCount, "samplerYcbcrConversionRequestCount", 1);
28336 
28337     print_uint32_t(obj.surfaceRequestCount, "surfaceRequestCount", 1);
28338 
28339     print_uint32_t(obj.swapchainRequestCount, "swapchainRequestCount", 1);
28340 
28341     print_uint32_t(obj.displayModeRequestCount, "displayModeRequestCount", 1);
28342 
28343     print_uint32_t(obj.subpassDescriptionRequestCount, "subpassDescriptionRequestCount", 1);
28344 
28345     print_uint32_t(obj.attachmentDescriptionRequestCount, "attachmentDescriptionRequestCount", 1);
28346 
28347     print_uint32_t(obj.descriptorSetLayoutBindingRequestCount, "descriptorSetLayoutBindingRequestCount", 1);
28348 
28349     print_uint32_t(obj.descriptorSetLayoutBindingLimit, "descriptorSetLayoutBindingLimit", 1);
28350 
28351     print_uint32_t(obj.maxImageViewMipLevels, "maxImageViewMipLevels", 1);
28352 
28353     print_uint32_t(obj.maxImageViewArrayLayers, "maxImageViewArrayLayers", 1);
28354 
28355     print_uint32_t(obj.maxLayeredImageViewMipLevels, "maxLayeredImageViewMipLevels", 1);
28356 
28357     print_uint32_t(obj.maxOcclusionQueriesPerPool, "maxOcclusionQueriesPerPool", 1);
28358 
28359     print_uint32_t(obj.maxPipelineStatisticsQueriesPerPool, "maxPipelineStatisticsQueriesPerPool", 1);
28360 
28361     print_uint32_t(obj.maxTimestampQueriesPerPool, "maxTimestampQueriesPerPool", 1);
28362 
28363     print_uint32_t(obj.maxImmutableSamplersPerDescriptorSetLayout, "maxImmutableSamplersPerDescriptorSetLayout", 0);
28364 
28365     INDENT(-4);
28366     PRINT_SPACE
28367     if (commaNeeded)
28368         _OUT << "}," << std::endl;
28369     else
28370         _OUT << "}" << std::endl;
28371 }
print_VkDeviceObjectReservationCreateInfo(const VkDeviceObjectReservationCreateInfo * obj,const std::string & s,bool commaNeeded=true)28372 static void print_VkDeviceObjectReservationCreateInfo(const VkDeviceObjectReservationCreateInfo *obj,
28373                                                       const std::string &s, bool commaNeeded = true)
28374 {
28375     PRINT_SPACE
28376     _OUT << "{" << std::endl;
28377     INDENT(4);
28378 
28379     print_VkStructureType(obj->sType, "sType", 1);
28380 
28381     if (obj->pNext)
28382     {
28383         dumpPNextChain(obj->pNext);
28384     }
28385     else
28386     {
28387         PRINT_SPACE
28388         _OUT << "\"pNext\":"
28389              << "\"NULL\""
28390              << "," << std::endl;
28391     }
28392 
28393     print_uint32_t(obj->pipelineCacheCreateInfoCount, "pipelineCacheCreateInfoCount", 1);
28394 
28395     PRINT_SPACE
28396     _OUT << "\"pPipelineCacheCreateInfos\": " << std::endl;
28397     if (obj->pPipelineCacheCreateInfos)
28398     {
28399         PRINT_SPACE
28400         _OUT << "[" << std::endl;
28401         for (unsigned int i = 0; i < obj->pipelineCacheCreateInfoCount; i++)
28402         {
28403             if (i + 1 == obj->pipelineCacheCreateInfoCount)
28404                 print_VkPipelineCacheCreateInfo(obj->pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 0);
28405             else
28406                 print_VkPipelineCacheCreateInfo(obj->pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 1);
28407         }
28408         PRINT_SPACE
28409         _OUT << "]," << std::endl;
28410     }
28411     else
28412     {
28413         PRINT_SPACE _OUT << "\"NULL\""
28414                          << "," << std::endl;
28415     }
28416 
28417     print_uint32_t(obj->pipelinePoolSizeCount, "pipelinePoolSizeCount", 1);
28418 
28419     PRINT_SPACE
28420     _OUT << "\"pPipelinePoolSizes\": " << std::endl;
28421     if (obj->pPipelinePoolSizes)
28422     {
28423         PRINT_SPACE
28424         _OUT << "[" << std::endl;
28425         for (unsigned int i = 0; i < obj->pipelinePoolSizeCount; i++)
28426         {
28427             if (i + 1 == obj->pipelinePoolSizeCount)
28428                 print_VkPipelinePoolSize(obj->pPipelinePoolSizes[i], "pPipelinePoolSizes", 0);
28429             else
28430                 print_VkPipelinePoolSize(obj->pPipelinePoolSizes[i], "pPipelinePoolSizes", 1);
28431         }
28432         PRINT_SPACE
28433         _OUT << "]," << std::endl;
28434     }
28435     else
28436     {
28437         PRINT_SPACE _OUT << "\"NULL\""
28438                          << "," << std::endl;
28439     }
28440 
28441     print_uint32_t(obj->semaphoreRequestCount, "semaphoreRequestCount", 1);
28442 
28443     print_uint32_t(obj->commandBufferRequestCount, "commandBufferRequestCount", 1);
28444 
28445     print_uint32_t(obj->fenceRequestCount, "fenceRequestCount", 1);
28446 
28447     print_uint32_t(obj->deviceMemoryRequestCount, "deviceMemoryRequestCount", 1);
28448 
28449     print_uint32_t(obj->bufferRequestCount, "bufferRequestCount", 1);
28450 
28451     print_uint32_t(obj->imageRequestCount, "imageRequestCount", 1);
28452 
28453     print_uint32_t(obj->eventRequestCount, "eventRequestCount", 1);
28454 
28455     print_uint32_t(obj->queryPoolRequestCount, "queryPoolRequestCount", 1);
28456 
28457     print_uint32_t(obj->bufferViewRequestCount, "bufferViewRequestCount", 1);
28458 
28459     print_uint32_t(obj->imageViewRequestCount, "imageViewRequestCount", 1);
28460 
28461     print_uint32_t(obj->layeredImageViewRequestCount, "layeredImageViewRequestCount", 1);
28462 
28463     print_uint32_t(obj->pipelineCacheRequestCount, "pipelineCacheRequestCount", 1);
28464 
28465     print_uint32_t(obj->pipelineLayoutRequestCount, "pipelineLayoutRequestCount", 1);
28466 
28467     print_uint32_t(obj->renderPassRequestCount, "renderPassRequestCount", 1);
28468 
28469     print_uint32_t(obj->graphicsPipelineRequestCount, "graphicsPipelineRequestCount", 1);
28470 
28471     print_uint32_t(obj->computePipelineRequestCount, "computePipelineRequestCount", 1);
28472 
28473     print_uint32_t(obj->descriptorSetLayoutRequestCount, "descriptorSetLayoutRequestCount", 1);
28474 
28475     print_uint32_t(obj->samplerRequestCount, "samplerRequestCount", 1);
28476 
28477     print_uint32_t(obj->descriptorPoolRequestCount, "descriptorPoolRequestCount", 1);
28478 
28479     print_uint32_t(obj->descriptorSetRequestCount, "descriptorSetRequestCount", 1);
28480 
28481     print_uint32_t(obj->framebufferRequestCount, "framebufferRequestCount", 1);
28482 
28483     print_uint32_t(obj->commandPoolRequestCount, "commandPoolRequestCount", 1);
28484 
28485     print_uint32_t(obj->samplerYcbcrConversionRequestCount, "samplerYcbcrConversionRequestCount", 1);
28486 
28487     print_uint32_t(obj->surfaceRequestCount, "surfaceRequestCount", 1);
28488 
28489     print_uint32_t(obj->swapchainRequestCount, "swapchainRequestCount", 1);
28490 
28491     print_uint32_t(obj->displayModeRequestCount, "displayModeRequestCount", 1);
28492 
28493     print_uint32_t(obj->subpassDescriptionRequestCount, "subpassDescriptionRequestCount", 1);
28494 
28495     print_uint32_t(obj->attachmentDescriptionRequestCount, "attachmentDescriptionRequestCount", 1);
28496 
28497     print_uint32_t(obj->descriptorSetLayoutBindingRequestCount, "descriptorSetLayoutBindingRequestCount", 1);
28498 
28499     print_uint32_t(obj->descriptorSetLayoutBindingLimit, "descriptorSetLayoutBindingLimit", 1);
28500 
28501     print_uint32_t(obj->maxImageViewMipLevels, "maxImageViewMipLevels", 1);
28502 
28503     print_uint32_t(obj->maxImageViewArrayLayers, "maxImageViewArrayLayers", 1);
28504 
28505     print_uint32_t(obj->maxLayeredImageViewMipLevels, "maxLayeredImageViewMipLevels", 1);
28506 
28507     print_uint32_t(obj->maxOcclusionQueriesPerPool, "maxOcclusionQueriesPerPool", 1);
28508 
28509     print_uint32_t(obj->maxPipelineStatisticsQueriesPerPool, "maxPipelineStatisticsQueriesPerPool", 1);
28510 
28511     print_uint32_t(obj->maxTimestampQueriesPerPool, "maxTimestampQueriesPerPool", 1);
28512 
28513     print_uint32_t(obj->maxImmutableSamplersPerDescriptorSetLayout, "maxImmutableSamplersPerDescriptorSetLayout", 0);
28514 
28515     INDENT(-4);
28516     PRINT_SPACE
28517     if (commaNeeded)
28518         _OUT << "}," << std::endl;
28519     else
28520         _OUT << "}" << std::endl;
28521 }
28522 
print_VkCommandPoolMemoryReservationCreateInfo(VkCommandPoolMemoryReservationCreateInfo obj,const std::string & s,bool commaNeeded=true)28523 static void print_VkCommandPoolMemoryReservationCreateInfo(VkCommandPoolMemoryReservationCreateInfo obj,
28524                                                            const std::string &s, bool commaNeeded = true)
28525 {
28526     PRINT_SPACE
28527     _OUT << "{" << std::endl;
28528     INDENT(4);
28529 
28530     print_VkStructureType(obj.sType, "sType", 1);
28531 
28532     if (obj.pNext)
28533     {
28534         dumpPNextChain(obj.pNext);
28535     }
28536     else
28537     {
28538         PRINT_SPACE
28539         _OUT << "\"pNext\":"
28540              << "\"NULL\""
28541              << "," << std::endl;
28542     }
28543 
28544     print_VkDeviceSize(obj.commandPoolReservedSize, "commandPoolReservedSize", 1);
28545 
28546     print_uint32_t(obj.commandPoolMaxCommandBuffers, "commandPoolMaxCommandBuffers", 0);
28547 
28548     INDENT(-4);
28549     PRINT_SPACE
28550     if (commaNeeded)
28551         _OUT << "}," << std::endl;
28552     else
28553         _OUT << "}" << std::endl;
28554 }
print_VkCommandPoolMemoryReservationCreateInfo(const VkCommandPoolMemoryReservationCreateInfo * obj,const std::string & s,bool commaNeeded=true)28555 static void print_VkCommandPoolMemoryReservationCreateInfo(const VkCommandPoolMemoryReservationCreateInfo *obj,
28556                                                            const std::string &s, bool commaNeeded = true)
28557 {
28558     PRINT_SPACE
28559     _OUT << "{" << std::endl;
28560     INDENT(4);
28561 
28562     print_VkStructureType(obj->sType, "sType", 1);
28563 
28564     if (obj->pNext)
28565     {
28566         dumpPNextChain(obj->pNext);
28567     }
28568     else
28569     {
28570         PRINT_SPACE
28571         _OUT << "\"pNext\":"
28572              << "\"NULL\""
28573              << "," << std::endl;
28574     }
28575 
28576     print_VkDeviceSize(obj->commandPoolReservedSize, "commandPoolReservedSize", 1);
28577 
28578     print_uint32_t(obj->commandPoolMaxCommandBuffers, "commandPoolMaxCommandBuffers", 0);
28579 
28580     INDENT(-4);
28581     PRINT_SPACE
28582     if (commaNeeded)
28583         _OUT << "}," << std::endl;
28584     else
28585         _OUT << "}" << std::endl;
28586 }
28587 
print_VkCommandPoolMemoryConsumption(VkCommandPoolMemoryConsumption obj,const std::string & s,bool commaNeeded=true)28588 static void print_VkCommandPoolMemoryConsumption(VkCommandPoolMemoryConsumption obj, const std::string &s,
28589                                                  bool commaNeeded = true)
28590 {
28591     PRINT_SPACE
28592     _OUT << "{" << std::endl;
28593     INDENT(4);
28594 
28595     print_VkStructureType(obj.sType, "sType", 1);
28596 
28597     if (obj.pNext)
28598     {
28599         dumpPNextChain(obj.pNext);
28600     }
28601     else
28602     {
28603         PRINT_SPACE
28604         _OUT << "\"pNext\":"
28605              << "\"NULL\""
28606              << "," << std::endl;
28607     }
28608 
28609     print_VkDeviceSize(obj.commandPoolAllocated, "commandPoolAllocated", 1);
28610 
28611     print_VkDeviceSize(obj.commandPoolReservedSize, "commandPoolReservedSize", 1);
28612 
28613     print_VkDeviceSize(obj.commandBufferAllocated, "commandBufferAllocated", 0);
28614 
28615     INDENT(-4);
28616     PRINT_SPACE
28617     if (commaNeeded)
28618         _OUT << "}," << std::endl;
28619     else
28620         _OUT << "}" << std::endl;
28621 }
print_VkCommandPoolMemoryConsumption(const VkCommandPoolMemoryConsumption * obj,const std::string & s,bool commaNeeded=true)28622 static void print_VkCommandPoolMemoryConsumption(const VkCommandPoolMemoryConsumption *obj, const std::string &s,
28623                                                  bool commaNeeded = true)
28624 {
28625     PRINT_SPACE
28626     _OUT << "{" << std::endl;
28627     INDENT(4);
28628 
28629     print_VkStructureType(obj->sType, "sType", 1);
28630 
28631     if (obj->pNext)
28632     {
28633         dumpPNextChain(obj->pNext);
28634     }
28635     else
28636     {
28637         PRINT_SPACE
28638         _OUT << "\"pNext\":"
28639              << "\"NULL\""
28640              << "," << std::endl;
28641     }
28642 
28643     print_VkDeviceSize(obj->commandPoolAllocated, "commandPoolAllocated", 1);
28644 
28645     print_VkDeviceSize(obj->commandPoolReservedSize, "commandPoolReservedSize", 1);
28646 
28647     print_VkDeviceSize(obj->commandBufferAllocated, "commandBufferAllocated", 0);
28648 
28649     INDENT(-4);
28650     PRINT_SPACE
28651     if (commaNeeded)
28652         _OUT << "}," << std::endl;
28653     else
28654         _OUT << "}" << std::endl;
28655 }
28656 
print_VkFaultData(VkFaultData obj,const std::string & s,bool commaNeeded=true)28657 static void print_VkFaultData(VkFaultData obj, const std::string &s, bool commaNeeded = true)
28658 {
28659     PRINT_SPACE
28660     _OUT << "{" << std::endl;
28661     INDENT(4);
28662 
28663     print_VkStructureType(obj.sType, "sType", 1);
28664 
28665     if (obj.pNext)
28666     {
28667         dumpPNextChain(obj.pNext);
28668     }
28669     else
28670     {
28671         PRINT_SPACE
28672         _OUT << "\"pNext\":"
28673              << "\"NULL\""
28674              << "," << std::endl;
28675     }
28676 
28677     print_VkFaultLevel(obj.faultLevel, "faultLevel", 1);
28678 
28679     print_VkFaultType(obj.faultType, "faultType", 0);
28680 
28681     INDENT(-4);
28682     PRINT_SPACE
28683     if (commaNeeded)
28684         _OUT << "}," << std::endl;
28685     else
28686         _OUT << "}" << std::endl;
28687 }
print_VkFaultData(const VkFaultData * obj,const std::string & s,bool commaNeeded=true)28688 static void print_VkFaultData(const VkFaultData *obj, const std::string &s, bool commaNeeded = true)
28689 {
28690     PRINT_SPACE
28691     _OUT << "{" << std::endl;
28692     INDENT(4);
28693 
28694     print_VkStructureType(obj->sType, "sType", 1);
28695 
28696     if (obj->pNext)
28697     {
28698         dumpPNextChain(obj->pNext);
28699     }
28700     else
28701     {
28702         PRINT_SPACE
28703         _OUT << "\"pNext\":"
28704              << "\"NULL\""
28705              << "," << std::endl;
28706     }
28707 
28708     print_VkFaultLevel(obj->faultLevel, "faultLevel", 1);
28709 
28710     print_VkFaultType(obj->faultType, "faultType", 0);
28711 
28712     INDENT(-4);
28713     PRINT_SPACE
28714     if (commaNeeded)
28715         _OUT << "}," << std::endl;
28716     else
28717         _OUT << "}" << std::endl;
28718 }
28719 
print_VkFaultCallbackInfo(VkFaultCallbackInfo obj,const std::string & s,bool commaNeeded=true)28720 static void print_VkFaultCallbackInfo(VkFaultCallbackInfo obj, const std::string &s, bool commaNeeded = true)
28721 {
28722     PRINT_SPACE
28723     _OUT << "{" << std::endl;
28724     INDENT(4);
28725 
28726     print_VkStructureType(obj.sType, "sType", 1);
28727 
28728     if (obj.pNext)
28729     {
28730         dumpPNextChain(obj.pNext);
28731     }
28732     else
28733     {
28734         PRINT_SPACE
28735         _OUT << "\"pNext\":"
28736              << "\"NULL\""
28737              << "," << std::endl;
28738     }
28739 
28740     print_uint32_t(obj.faultCount, "faultCount", 1);
28741 
28742     PRINT_SPACE
28743     _OUT << "\"pFaults\": " << std::endl;
28744     if (obj.pFaults)
28745     {
28746         PRINT_SPACE
28747         _OUT << "[" << std::endl;
28748         for (unsigned int i = 0; i < obj.faultCount; i++)
28749         {
28750             if (i + 1 == obj.faultCount)
28751                 print_VkFaultData(obj.pFaults[i], "pFaults", 0);
28752             else
28753                 print_VkFaultData(obj.pFaults[i], "pFaults", 1);
28754         }
28755         PRINT_SPACE
28756         _OUT << "]," << std::endl;
28757     }
28758     else
28759     {
28760         PRINT_SPACE _OUT << "\"NULL\""
28761                          << "," << std::endl;
28762     }
28763 
28764     /** Note: Ignoring function pointer (PFN_vkFaultCallbackFunction). **/
28765 
28766     INDENT(-4);
28767     PRINT_SPACE
28768     if (commaNeeded)
28769         _OUT << "}," << std::endl;
28770     else
28771         _OUT << "}" << std::endl;
28772 }
print_VkFaultCallbackInfo(const VkFaultCallbackInfo * obj,const std::string & s,bool commaNeeded=true)28773 static void print_VkFaultCallbackInfo(const VkFaultCallbackInfo *obj, const std::string &s, bool commaNeeded = true)
28774 {
28775     PRINT_SPACE
28776     _OUT << "{" << std::endl;
28777     INDENT(4);
28778 
28779     print_VkStructureType(obj->sType, "sType", 1);
28780 
28781     if (obj->pNext)
28782     {
28783         dumpPNextChain(obj->pNext);
28784     }
28785     else
28786     {
28787         PRINT_SPACE
28788         _OUT << "\"pNext\":"
28789              << "\"NULL\""
28790              << "," << std::endl;
28791     }
28792 
28793     print_uint32_t(obj->faultCount, "faultCount", 1);
28794 
28795     PRINT_SPACE
28796     _OUT << "\"pFaults\": " << std::endl;
28797     if (obj->pFaults)
28798     {
28799         PRINT_SPACE
28800         _OUT << "[" << std::endl;
28801         for (unsigned int i = 0; i < obj->faultCount; i++)
28802         {
28803             if (i + 1 == obj->faultCount)
28804                 print_VkFaultData(obj->pFaults[i], "pFaults", 0);
28805             else
28806                 print_VkFaultData(obj->pFaults[i], "pFaults", 1);
28807         }
28808         PRINT_SPACE
28809         _OUT << "]," << std::endl;
28810     }
28811     else
28812     {
28813         PRINT_SPACE _OUT << "\"NULL\""
28814                          << "," << std::endl;
28815     }
28816 
28817     /** Note: Ignoring function pointer (PFN_vkFaultCallbackFunction). **/
28818 
28819     INDENT(-4);
28820     PRINT_SPACE
28821     if (commaNeeded)
28822         _OUT << "}," << std::endl;
28823     else
28824         _OUT << "}" << std::endl;
28825 }
28826 
print_VkPipelineOfflineCreateInfo(VkPipelineOfflineCreateInfo obj,const std::string & s,bool commaNeeded=true)28827 static void print_VkPipelineOfflineCreateInfo(VkPipelineOfflineCreateInfo obj, const std::string &s,
28828                                               bool commaNeeded = true)
28829 {
28830     PRINT_SPACE
28831     _OUT << "{" << std::endl;
28832     INDENT(4);
28833 
28834     print_VkStructureType(obj.sType, "sType", 1);
28835 
28836     if (obj.pNext)
28837     {
28838         dumpPNextChain(obj.pNext);
28839     }
28840     else
28841     {
28842         PRINT_SPACE
28843         _OUT << "\"pNext\":"
28844              << "\"NULL\""
28845              << "," << std::endl;
28846     }
28847 
28848     PRINT_SPACE
28849     _OUT << "\"pipelineIdentifier\":" << std::endl;
28850     PRINT_SPACE
28851     _OUT << "[" << std::endl;
28852     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
28853     {
28854         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
28855         print_uint32_t((uint32_t)obj.pipelineIdentifier[i], "", isCommaNeeded);
28856     }
28857     PRINT_SPACE
28858     _OUT << "]"
28859          << "," << std::endl;
28860 
28861     print_VkPipelineMatchControl(obj.matchControl, "matchControl", 1);
28862 
28863     print_VkDeviceSize(obj.poolEntrySize, "poolEntrySize", 0);
28864 
28865     INDENT(-4);
28866     PRINT_SPACE
28867     if (commaNeeded)
28868         _OUT << "}," << std::endl;
28869     else
28870         _OUT << "}" << std::endl;
28871 }
print_VkPipelineOfflineCreateInfo(const VkPipelineOfflineCreateInfo * obj,const std::string & s,bool commaNeeded=true)28872 static void print_VkPipelineOfflineCreateInfo(const VkPipelineOfflineCreateInfo *obj, const std::string &s,
28873                                               bool commaNeeded = true)
28874 {
28875     PRINT_SPACE
28876     _OUT << "{" << std::endl;
28877     INDENT(4);
28878 
28879     print_VkStructureType(obj->sType, "sType", 1);
28880 
28881     if (obj->pNext)
28882     {
28883         dumpPNextChain(obj->pNext);
28884     }
28885     else
28886     {
28887         PRINT_SPACE
28888         _OUT << "\"pNext\":"
28889              << "\"NULL\""
28890              << "," << std::endl;
28891     }
28892 
28893     PRINT_SPACE
28894     _OUT << "\"pipelineIdentifier\":" << std::endl;
28895     PRINT_SPACE
28896     _OUT << "[" << std::endl;
28897     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
28898     {
28899         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
28900         print_uint32_t((uint32_t)obj->pipelineIdentifier[i], "", isCommaNeeded);
28901     }
28902     PRINT_SPACE
28903     _OUT << "]"
28904          << "," << std::endl;
28905 
28906     print_VkPipelineMatchControl(obj->matchControl, "matchControl", 1);
28907 
28908     print_VkDeviceSize(obj->poolEntrySize, "poolEntrySize", 0);
28909 
28910     INDENT(-4);
28911     PRINT_SPACE
28912     if (commaNeeded)
28913         _OUT << "}," << std::endl;
28914     else
28915         _OUT << "}" << std::endl;
28916 }
28917 
print_VkPipelineCacheStageValidationIndexEntry(VkPipelineCacheStageValidationIndexEntry obj,const std::string & s,bool commaNeeded=true)28918 static void print_VkPipelineCacheStageValidationIndexEntry(VkPipelineCacheStageValidationIndexEntry obj,
28919                                                            const std::string &s, bool commaNeeded = true)
28920 {
28921     PRINT_SPACE
28922     _OUT << "{" << std::endl;
28923     INDENT(4);
28924 
28925     print_uint64_t(obj.codeSize, "codeSize", 1);
28926 
28927     print_uint64_t(obj.codeOffset, "codeOffset", 0);
28928 
28929     INDENT(-4);
28930     PRINT_SPACE
28931     if (commaNeeded)
28932         _OUT << "}," << std::endl;
28933     else
28934         _OUT << "}" << std::endl;
28935 }
print_VkPipelineCacheStageValidationIndexEntry(const VkPipelineCacheStageValidationIndexEntry * obj,const std::string & s,bool commaNeeded=true)28936 static void print_VkPipelineCacheStageValidationIndexEntry(const VkPipelineCacheStageValidationIndexEntry *obj,
28937                                                            const std::string &s, bool commaNeeded = true)
28938 {
28939     PRINT_SPACE
28940     _OUT << "{" << std::endl;
28941     INDENT(4);
28942 
28943     print_uint64_t(obj->codeSize, "codeSize", 1);
28944 
28945     print_uint64_t(obj->codeOffset, "codeOffset", 0);
28946 
28947     INDENT(-4);
28948     PRINT_SPACE
28949     if (commaNeeded)
28950         _OUT << "}," << std::endl;
28951     else
28952         _OUT << "}" << std::endl;
28953 }
28954 
print_VkPipelineCacheSafetyCriticalIndexEntry(VkPipelineCacheSafetyCriticalIndexEntry obj,const std::string & s,bool commaNeeded=true)28955 static void print_VkPipelineCacheSafetyCriticalIndexEntry(VkPipelineCacheSafetyCriticalIndexEntry obj,
28956                                                           const std::string &s, bool commaNeeded = true)
28957 {
28958     PRINT_SPACE
28959     _OUT << "{" << std::endl;
28960     INDENT(4);
28961 
28962     PRINT_SPACE
28963     _OUT << "\"pipelineIdentifier\":" << std::endl;
28964     PRINT_SPACE
28965     _OUT << "[" << std::endl;
28966     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
28967     {
28968         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
28969         print_uint32_t((uint32_t)obj.pipelineIdentifier[i], "", isCommaNeeded);
28970     }
28971     PRINT_SPACE
28972     _OUT << "]"
28973          << "," << std::endl;
28974 
28975     print_uint64_t(obj.pipelineMemorySize, "pipelineMemorySize", 1);
28976 
28977     print_uint64_t(obj.jsonSize, "jsonSize", 1);
28978 
28979     print_uint64_t(obj.jsonOffset, "jsonOffset", 1);
28980 
28981     print_uint32_t(obj.stageIndexCount, "stageIndexCount", 1);
28982 
28983     print_uint32_t(obj.stageIndexStride, "stageIndexStride", 1);
28984 
28985     print_uint64_t(obj.stageIndexOffset, "stageIndexOffset", 0);
28986 
28987     INDENT(-4);
28988     PRINT_SPACE
28989     if (commaNeeded)
28990         _OUT << "}," << std::endl;
28991     else
28992         _OUT << "}" << std::endl;
28993 }
print_VkPipelineCacheSafetyCriticalIndexEntry(const VkPipelineCacheSafetyCriticalIndexEntry * obj,const std::string & s,bool commaNeeded=true)28994 static void print_VkPipelineCacheSafetyCriticalIndexEntry(const VkPipelineCacheSafetyCriticalIndexEntry *obj,
28995                                                           const std::string &s, bool commaNeeded = true)
28996 {
28997     PRINT_SPACE
28998     _OUT << "{" << std::endl;
28999     INDENT(4);
29000 
29001     PRINT_SPACE
29002     _OUT << "\"pipelineIdentifier\":" << std::endl;
29003     PRINT_SPACE
29004     _OUT << "[" << std::endl;
29005     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
29006     {
29007         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
29008         print_uint32_t((uint32_t)obj->pipelineIdentifier[i], "", isCommaNeeded);
29009     }
29010     PRINT_SPACE
29011     _OUT << "]"
29012          << "," << std::endl;
29013 
29014     print_uint64_t(obj->pipelineMemorySize, "pipelineMemorySize", 1);
29015 
29016     print_uint64_t(obj->jsonSize, "jsonSize", 1);
29017 
29018     print_uint64_t(obj->jsonOffset, "jsonOffset", 1);
29019 
29020     print_uint32_t(obj->stageIndexCount, "stageIndexCount", 1);
29021 
29022     print_uint32_t(obj->stageIndexStride, "stageIndexStride", 1);
29023 
29024     print_uint64_t(obj->stageIndexOffset, "stageIndexOffset", 0);
29025 
29026     INDENT(-4);
29027     PRINT_SPACE
29028     if (commaNeeded)
29029         _OUT << "}," << std::endl;
29030     else
29031         _OUT << "}" << std::endl;
29032 }
29033 
print_VkPipelineCacheHeaderVersionSafetyCriticalOne(VkPipelineCacheHeaderVersionSafetyCriticalOne obj,const std::string & s,bool commaNeeded=true)29034 static void print_VkPipelineCacheHeaderVersionSafetyCriticalOne(VkPipelineCacheHeaderVersionSafetyCriticalOne obj,
29035                                                                 const std::string &s, bool commaNeeded = true)
29036 {
29037     PRINT_SPACE
29038     _OUT << "{" << std::endl;
29039     INDENT(4);
29040 
29041     PRINT_SPACE
29042     _OUT << "\"headerVersionOne\": " << std::endl;
29043     {
29044         print_VkPipelineCacheHeaderVersionOne(obj.headerVersionOne, "headerVersionOne", 1);
29045     }
29046 
29047     print_VkPipelineCacheValidationVersion(obj.validationVersion, "validationVersion", 1);
29048 
29049     print_uint32_t(obj.implementationData, "implementationData", 1);
29050 
29051     print_uint32_t(obj.pipelineIndexCount, "pipelineIndexCount", 1);
29052 
29053     print_uint32_t(obj.pipelineIndexStride, "pipelineIndexStride", 1);
29054 
29055     print_uint64_t(obj.pipelineIndexOffset, "pipelineIndexOffset", 0);
29056 
29057     INDENT(-4);
29058     PRINT_SPACE
29059     if (commaNeeded)
29060         _OUT << "}," << std::endl;
29061     else
29062         _OUT << "}" << std::endl;
29063 }
print_VkPipelineCacheHeaderVersionSafetyCriticalOne(const VkPipelineCacheHeaderVersionSafetyCriticalOne * obj,const std::string & s,bool commaNeeded=true)29064 static void print_VkPipelineCacheHeaderVersionSafetyCriticalOne(
29065     const VkPipelineCacheHeaderVersionSafetyCriticalOne *obj, const std::string &s, bool commaNeeded = true)
29066 {
29067     PRINT_SPACE
29068     _OUT << "{" << std::endl;
29069     INDENT(4);
29070 
29071     PRINT_SPACE
29072     _OUT << "\"headerVersionOne\": " << std::endl;
29073     {
29074         print_VkPipelineCacheHeaderVersionOne(obj->headerVersionOne, "headerVersionOne", 1);
29075     }
29076 
29077     print_VkPipelineCacheValidationVersion(obj->validationVersion, "validationVersion", 1);
29078 
29079     print_uint32_t(obj->implementationData, "implementationData", 1);
29080 
29081     print_uint32_t(obj->pipelineIndexCount, "pipelineIndexCount", 1);
29082 
29083     print_uint32_t(obj->pipelineIndexStride, "pipelineIndexStride", 1);
29084 
29085     print_uint64_t(obj->pipelineIndexOffset, "pipelineIndexOffset", 0);
29086 
29087     INDENT(-4);
29088     PRINT_SPACE
29089     if (commaNeeded)
29090         _OUT << "}," << std::endl;
29091     else
29092         _OUT << "}" << std::endl;
29093 }
29094 
print_VkSurfaceKHR(VkSurfaceKHR obj,const std::string & str,bool commaNeeded=true)29095 static void print_VkSurfaceKHR(VkSurfaceKHR obj, const std::string &str, bool commaNeeded = true)
29096 {
29097     PRINT_SPACE
29098     if (commaNeeded)
29099         _OUT << "\"" << str << "\""
29100              << "," << std::endl;
29101     else
29102         _OUT << "\"" << str << "\"" << std::endl;
29103 }
print_VkSurfaceKHR(const VkSurfaceKHR * obj,const std::string & str,bool commaNeeded=true)29104 static void print_VkSurfaceKHR(const VkSurfaceKHR *obj, const std::string &str, bool commaNeeded = true)
29105 {
29106     PRINT_SPACE
29107     if (commaNeeded)
29108         _OUT << "\"" << str << "\""
29109              << "," << std::endl;
29110     else
29111         _OUT << "\"" << str << "\"" << std::endl;
29112 }
29113 
29114 static std::map<uint64_t, std::string> VkSurfaceTransformFlagBitsKHR_map = {
29115     std::make_pair(1ULL << 0, "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR"),
29116     std::make_pair(1ULL << 1, "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR"),
29117     std::make_pair(1ULL << 2, "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR"),
29118     std::make_pair(1ULL << 3, "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR"),
29119     std::make_pair(1ULL << 4, "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR"),
29120     std::make_pair(1ULL << 5, "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR"),
29121     std::make_pair(1ULL << 6, "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR"),
29122     std::make_pair(1ULL << 7, "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR"),
29123     std::make_pair(1ULL << 8, "VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR"),
29124 };
print_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR obj,const std::string & str,bool commaNeeded=true)29125 static void print_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR obj, const std::string &str,
29126                                                 bool commaNeeded = true)
29127 {
29128     PRINT_SPACE
29129     if (str != "")
29130         _OUT << "\"" << str << "\""
29131              << " : ";
29132     if (commaNeeded)
29133         _OUT << "\"" << VkSurfaceTransformFlagBitsKHR_map[obj] << "\"," << std::endl;
29134     else
29135         _OUT << "\"" << VkSurfaceTransformFlagBitsKHR_map[obj] << "\"" << std::endl;
29136 }
print_VkSurfaceTransformFlagBitsKHR(const VkSurfaceTransformFlagBitsKHR * obj,const std::string & str,bool commaNeeded=true)29137 static void print_VkSurfaceTransformFlagBitsKHR(const VkSurfaceTransformFlagBitsKHR *obj, const std::string &str,
29138                                                 bool commaNeeded = true)
29139 {
29140     PRINT_SPACE
29141     if (str != "")
29142         _OUT << "\"" << str << "\""
29143              << " : ";
29144     if (commaNeeded)
29145         _OUT << "\"" << VkSurfaceTransformFlagBitsKHR_map[*obj] << "\"," << std::endl;
29146     else
29147         _OUT << "\"" << VkSurfaceTransformFlagBitsKHR_map[*obj] << "\"" << std::endl;
29148 }
29149 
29150 static std::map<uint64_t, std::string> VkPresentModeKHR_map = {
29151     std::make_pair(0, "VK_PRESENT_MODE_IMMEDIATE_KHR"),
29152     std::make_pair(1, "VK_PRESENT_MODE_MAILBOX_KHR"),
29153     std::make_pair(2, "VK_PRESENT_MODE_FIFO_KHR"),
29154     std::make_pair(3, "VK_PRESENT_MODE_FIFO_RELAXED_KHR"),
29155     std::make_pair(1000111000, "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR"),
29156     std::make_pair(1000111001, "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR"),
29157 };
print_VkPresentModeKHR(VkPresentModeKHR obj,const std::string & str,bool commaNeeded=true)29158 static void print_VkPresentModeKHR(VkPresentModeKHR obj, const std::string &str, bool commaNeeded = true)
29159 {
29160     PRINT_SPACE
29161     if (str != "")
29162         _OUT << "\"" << str << "\""
29163              << " : ";
29164     if (commaNeeded)
29165         _OUT << "\"" << VkPresentModeKHR_map[obj] << "\"," << std::endl;
29166     else
29167         _OUT << "\"" << VkPresentModeKHR_map[obj] << "\"" << std::endl;
29168 }
print_VkPresentModeKHR(const VkPresentModeKHR * obj,const std::string & str,bool commaNeeded=true)29169 static void print_VkPresentModeKHR(const VkPresentModeKHR *obj, const std::string &str, bool commaNeeded = true)
29170 {
29171     PRINT_SPACE
29172     if (str != "")
29173         _OUT << "\"" << str << "\""
29174              << " : ";
29175     if (commaNeeded)
29176         _OUT << "\"" << VkPresentModeKHR_map[*obj] << "\"," << std::endl;
29177     else
29178         _OUT << "\"" << VkPresentModeKHR_map[*obj] << "\"" << std::endl;
29179 }
29180 
29181 static std::map<uint64_t, std::string> VkColorSpaceKHR_map = {
29182     std::make_pair(0, "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR"),
29183     std::make_pair(1000104001, "VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT"),
29184     std::make_pair(1000104002, "VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT"),
29185     std::make_pair(1000104003, "VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT"),
29186     std::make_pair(1000104004, "VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT"),
29187     std::make_pair(1000104005, "VK_COLOR_SPACE_BT709_LINEAR_EXT"),
29188     std::make_pair(1000104006, "VK_COLOR_SPACE_BT709_NONLINEAR_EXT"),
29189     std::make_pair(1000104007, "VK_COLOR_SPACE_BT2020_LINEAR_EXT"),
29190     std::make_pair(1000104008, "VK_COLOR_SPACE_HDR10_ST2084_EXT"),
29191     std::make_pair(1000104009, "VK_COLOR_SPACE_DOLBYVISION_EXT"),
29192     std::make_pair(1000104010, "VK_COLOR_SPACE_HDR10_HLG_EXT"),
29193     std::make_pair(1000104011, "VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT"),
29194     std::make_pair(1000104012, "VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT"),
29195     std::make_pair(1000104013, "VK_COLOR_SPACE_PASS_THROUGH_EXT"),
29196     std::make_pair(1000104014, "VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT"),
29197     std::make_pair(1000213000, "VK_COLOR_SPACE_DISPLAY_NATIVE_AMD"),
29198 };
print_VkColorSpaceKHR(VkColorSpaceKHR obj,const std::string & str,bool commaNeeded=true)29199 static void print_VkColorSpaceKHR(VkColorSpaceKHR obj, const std::string &str, bool commaNeeded = true)
29200 {
29201     PRINT_SPACE
29202     if (str != "")
29203         _OUT << "\"" << str << "\""
29204              << " : ";
29205     if (commaNeeded)
29206         _OUT << "\"" << VkColorSpaceKHR_map[obj] << "\"," << std::endl;
29207     else
29208         _OUT << "\"" << VkColorSpaceKHR_map[obj] << "\"" << std::endl;
29209 }
print_VkColorSpaceKHR(const VkColorSpaceKHR * obj,const std::string & str,bool commaNeeded=true)29210 static void print_VkColorSpaceKHR(const VkColorSpaceKHR *obj, const std::string &str, bool commaNeeded = true)
29211 {
29212     PRINT_SPACE
29213     if (str != "")
29214         _OUT << "\"" << str << "\""
29215              << " : ";
29216     if (commaNeeded)
29217         _OUT << "\"" << VkColorSpaceKHR_map[*obj] << "\"," << std::endl;
29218     else
29219         _OUT << "\"" << VkColorSpaceKHR_map[*obj] << "\"" << std::endl;
29220 }
29221 
29222 static std::map<uint64_t, std::string> VkCompositeAlphaFlagBitsKHR_map = {
29223     std::make_pair(1ULL << 0, "VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR"),
29224     std::make_pair(1ULL << 1, "VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR"),
29225     std::make_pair(1ULL << 2, "VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR"),
29226     std::make_pair(1ULL << 3, "VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR"),
29227 };
print_VkCompositeAlphaFlagBitsKHR(VkCompositeAlphaFlagBitsKHR obj,const std::string & str,bool commaNeeded=true)29228 static void print_VkCompositeAlphaFlagBitsKHR(VkCompositeAlphaFlagBitsKHR obj, const std::string &str,
29229                                               bool commaNeeded = true)
29230 {
29231     PRINT_SPACE
29232     if (str != "")
29233         _OUT << "\"" << str << "\""
29234              << " : ";
29235     if (commaNeeded)
29236         _OUT << "\"" << VkCompositeAlphaFlagBitsKHR_map[obj] << "\"," << std::endl;
29237     else
29238         _OUT << "\"" << VkCompositeAlphaFlagBitsKHR_map[obj] << "\"" << std::endl;
29239 }
print_VkCompositeAlphaFlagBitsKHR(const VkCompositeAlphaFlagBitsKHR * obj,const std::string & str,bool commaNeeded=true)29240 static void print_VkCompositeAlphaFlagBitsKHR(const VkCompositeAlphaFlagBitsKHR *obj, const std::string &str,
29241                                               bool commaNeeded = true)
29242 {
29243     PRINT_SPACE
29244     if (str != "")
29245         _OUT << "\"" << str << "\""
29246              << " : ";
29247     if (commaNeeded)
29248         _OUT << "\"" << VkCompositeAlphaFlagBitsKHR_map[*obj] << "\"," << std::endl;
29249     else
29250         _OUT << "\"" << VkCompositeAlphaFlagBitsKHR_map[*obj] << "\"" << std::endl;
29251 }
29252 
print_VkCompositeAlphaFlagsKHR(VkCompositeAlphaFlagsKHR obj,const std::string & str,bool commaNeeded=true)29253 static void print_VkCompositeAlphaFlagsKHR(VkCompositeAlphaFlagsKHR obj, const std::string &str,
29254                                            bool commaNeeded = true)
29255 {
29256     PRINT_SPACE
29257     if (str != "")
29258         _OUT << "\"" << str << "\""
29259              << " : ";
29260     const int max_bits = 64; // We don't expect the number to be larger.
29261     std::bitset<max_bits> b(obj);
29262     _OUT << "\"";
29263     if (obj == 0)
29264         _OUT << "0";
29265     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
29266     {
29267         if (b[i] == 1)
29268         {
29269             bitCount++;
29270             if (bitCount < b.count())
29271                 _OUT << VkCompositeAlphaFlagBitsKHR_map[1ULL << i] << " | ";
29272             else
29273                 _OUT << VkCompositeAlphaFlagBitsKHR_map[1ULL << i];
29274         }
29275     }
29276     if (commaNeeded)
29277         _OUT << "\""
29278              << ",";
29279     else
29280         _OUT << "\""
29281              << "";
29282     _OUT << std::endl;
29283 }
print_VkCompositeAlphaFlagsKHR(const VkCompositeAlphaFlagsKHR * obj,const std::string & str,bool commaNeeded=true)29284 static void print_VkCompositeAlphaFlagsKHR(const VkCompositeAlphaFlagsKHR *obj, const std::string &str,
29285                                            bool commaNeeded = true)
29286 {
29287     PRINT_SPACE
29288     if (str != "")
29289         _OUT << "\"" << str << "\""
29290              << " : ";
29291     const int max_bits = 64; // We don't expect the number to be larger.
29292     std::bitset<max_bits> b(obj);
29293     _OUT << "\"";
29294     if (obj == 0)
29295         _OUT << "0";
29296     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
29297     {
29298         if (b[i] == 1)
29299         {
29300             bitCount++;
29301             if (bitCount < b.count())
29302                 _OUT << VkCompositeAlphaFlagBitsKHR_map[1ULL << i] << " | ";
29303             else
29304                 _OUT << VkCompositeAlphaFlagBitsKHR_map[1ULL << i];
29305         }
29306     }
29307     if (commaNeeded)
29308         _OUT << "\""
29309              << ",";
29310     else
29311         _OUT << "\""
29312              << "";
29313     _OUT << std::endl;
29314 }
29315 
print_VkSurfaceTransformFlagsKHR(VkSurfaceTransformFlagsKHR obj,const std::string & str,bool commaNeeded=true)29316 static void print_VkSurfaceTransformFlagsKHR(VkSurfaceTransformFlagsKHR obj, const std::string &str,
29317                                              bool commaNeeded = true)
29318 {
29319     PRINT_SPACE
29320     if (str != "")
29321         _OUT << "\"" << str << "\""
29322              << " : ";
29323     const int max_bits = 64; // We don't expect the number to be larger.
29324     std::bitset<max_bits> b(obj);
29325     _OUT << "\"";
29326     if (obj == 0)
29327         _OUT << "0";
29328     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
29329     {
29330         if (b[i] == 1)
29331         {
29332             bitCount++;
29333             if (bitCount < b.count())
29334                 _OUT << VkSurfaceTransformFlagBitsKHR_map[1ULL << i] << " | ";
29335             else
29336                 _OUT << VkSurfaceTransformFlagBitsKHR_map[1ULL << i];
29337         }
29338     }
29339     if (commaNeeded)
29340         _OUT << "\""
29341              << ",";
29342     else
29343         _OUT << "\""
29344              << "";
29345     _OUT << std::endl;
29346 }
print_VkSurfaceTransformFlagsKHR(const VkSurfaceTransformFlagsKHR * obj,const std::string & str,bool commaNeeded=true)29347 static void print_VkSurfaceTransformFlagsKHR(const VkSurfaceTransformFlagsKHR *obj, const std::string &str,
29348                                              bool commaNeeded = true)
29349 {
29350     PRINT_SPACE
29351     if (str != "")
29352         _OUT << "\"" << str << "\""
29353              << " : ";
29354     const int max_bits = 64; // We don't expect the number to be larger.
29355     std::bitset<max_bits> b(obj);
29356     _OUT << "\"";
29357     if (obj == 0)
29358         _OUT << "0";
29359     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
29360     {
29361         if (b[i] == 1)
29362         {
29363             bitCount++;
29364             if (bitCount < b.count())
29365                 _OUT << VkSurfaceTransformFlagBitsKHR_map[1ULL << i] << " | ";
29366             else
29367                 _OUT << VkSurfaceTransformFlagBitsKHR_map[1ULL << i];
29368         }
29369     }
29370     if (commaNeeded)
29371         _OUT << "\""
29372              << ",";
29373     else
29374         _OUT << "\""
29375              << "";
29376     _OUT << std::endl;
29377 }
29378 
print_VkSurfaceCapabilitiesKHR(VkSurfaceCapabilitiesKHR obj,const std::string & s,bool commaNeeded=true)29379 static void print_VkSurfaceCapabilitiesKHR(VkSurfaceCapabilitiesKHR obj, const std::string &s, bool commaNeeded = true)
29380 {
29381     PRINT_SPACE
29382     _OUT << "{" << std::endl;
29383     INDENT(4);
29384 
29385     print_uint32_t(obj.minImageCount, "minImageCount", 1);
29386 
29387     print_uint32_t(obj.maxImageCount, "maxImageCount", 1);
29388 
29389     PRINT_SPACE
29390     _OUT << "\"currentExtent\": " << std::endl;
29391     {
29392         print_VkExtent2D(obj.currentExtent, "currentExtent", 1);
29393     }
29394 
29395     PRINT_SPACE
29396     _OUT << "\"minImageExtent\": " << std::endl;
29397     {
29398         print_VkExtent2D(obj.minImageExtent, "minImageExtent", 1);
29399     }
29400 
29401     PRINT_SPACE
29402     _OUT << "\"maxImageExtent\": " << std::endl;
29403     {
29404         print_VkExtent2D(obj.maxImageExtent, "maxImageExtent", 1);
29405     }
29406 
29407     print_uint32_t(obj.maxImageArrayLayers, "maxImageArrayLayers", 1);
29408 
29409     print_VkSurfaceTransformFlagsKHR(obj.supportedTransforms, "supportedTransforms", 1);
29410 
29411     print_VkSurfaceTransformFlagBitsKHR(obj.currentTransform, "currentTransform", 1);
29412 
29413     print_VkCompositeAlphaFlagsKHR(obj.supportedCompositeAlpha, "supportedCompositeAlpha", 1);
29414 
29415     print_VkImageUsageFlags(obj.supportedUsageFlags, "supportedUsageFlags", 0);
29416 
29417     INDENT(-4);
29418     PRINT_SPACE
29419     if (commaNeeded)
29420         _OUT << "}," << std::endl;
29421     else
29422         _OUT << "}" << std::endl;
29423 }
print_VkSurfaceCapabilitiesKHR(const VkSurfaceCapabilitiesKHR * obj,const std::string & s,bool commaNeeded=true)29424 static void print_VkSurfaceCapabilitiesKHR(const VkSurfaceCapabilitiesKHR *obj, const std::string &s,
29425                                            bool commaNeeded = true)
29426 {
29427     PRINT_SPACE
29428     _OUT << "{" << std::endl;
29429     INDENT(4);
29430 
29431     print_uint32_t(obj->minImageCount, "minImageCount", 1);
29432 
29433     print_uint32_t(obj->maxImageCount, "maxImageCount", 1);
29434 
29435     PRINT_SPACE
29436     _OUT << "\"currentExtent\": " << std::endl;
29437     {
29438         print_VkExtent2D(obj->currentExtent, "currentExtent", 1);
29439     }
29440 
29441     PRINT_SPACE
29442     _OUT << "\"minImageExtent\": " << std::endl;
29443     {
29444         print_VkExtent2D(obj->minImageExtent, "minImageExtent", 1);
29445     }
29446 
29447     PRINT_SPACE
29448     _OUT << "\"maxImageExtent\": " << std::endl;
29449     {
29450         print_VkExtent2D(obj->maxImageExtent, "maxImageExtent", 1);
29451     }
29452 
29453     print_uint32_t(obj->maxImageArrayLayers, "maxImageArrayLayers", 1);
29454 
29455     print_VkSurfaceTransformFlagsKHR(obj->supportedTransforms, "supportedTransforms", 1);
29456 
29457     print_VkSurfaceTransformFlagBitsKHR(obj->currentTransform, "currentTransform", 1);
29458 
29459     print_VkCompositeAlphaFlagsKHR(obj->supportedCompositeAlpha, "supportedCompositeAlpha", 1);
29460 
29461     print_VkImageUsageFlags(obj->supportedUsageFlags, "supportedUsageFlags", 0);
29462 
29463     INDENT(-4);
29464     PRINT_SPACE
29465     if (commaNeeded)
29466         _OUT << "}," << std::endl;
29467     else
29468         _OUT << "}" << std::endl;
29469 }
29470 
print_VkSurfaceFormatKHR(VkSurfaceFormatKHR obj,const std::string & s,bool commaNeeded=true)29471 static void print_VkSurfaceFormatKHR(VkSurfaceFormatKHR obj, const std::string &s, bool commaNeeded = true)
29472 {
29473     PRINT_SPACE
29474     _OUT << "{" << std::endl;
29475     INDENT(4);
29476 
29477     print_VkFormat(obj.format, "format", 1);
29478 
29479     print_VkColorSpaceKHR(obj.colorSpace, "colorSpace", 0);
29480 
29481     INDENT(-4);
29482     PRINT_SPACE
29483     if (commaNeeded)
29484         _OUT << "}," << std::endl;
29485     else
29486         _OUT << "}" << std::endl;
29487 }
print_VkSurfaceFormatKHR(const VkSurfaceFormatKHR * obj,const std::string & s,bool commaNeeded=true)29488 static void print_VkSurfaceFormatKHR(const VkSurfaceFormatKHR *obj, const std::string &s, bool commaNeeded = true)
29489 {
29490     PRINT_SPACE
29491     _OUT << "{" << std::endl;
29492     INDENT(4);
29493 
29494     print_VkFormat(obj->format, "format", 1);
29495 
29496     print_VkColorSpaceKHR(obj->colorSpace, "colorSpace", 0);
29497 
29498     INDENT(-4);
29499     PRINT_SPACE
29500     if (commaNeeded)
29501         _OUT << "}," << std::endl;
29502     else
29503         _OUT << "}" << std::endl;
29504 }
29505 
print_VkSwapchainKHR(VkSwapchainKHR obj,const std::string & str,bool commaNeeded=true)29506 static void print_VkSwapchainKHR(VkSwapchainKHR obj, const std::string &str, bool commaNeeded = true)
29507 {
29508     PRINT_SPACE
29509     if (commaNeeded)
29510         _OUT << "\"" << str << "\""
29511              << "," << std::endl;
29512     else
29513         _OUT << "\"" << str << "\"" << std::endl;
29514 }
print_VkSwapchainKHR(const VkSwapchainKHR * obj,const std::string & str,bool commaNeeded=true)29515 static void print_VkSwapchainKHR(const VkSwapchainKHR *obj, const std::string &str, bool commaNeeded = true)
29516 {
29517     PRINT_SPACE
29518     if (commaNeeded)
29519         _OUT << "\"" << str << "\""
29520              << "," << std::endl;
29521     else
29522         _OUT << "\"" << str << "\"" << std::endl;
29523 }
29524 
29525 static std::map<uint64_t, std::string> VkSwapchainCreateFlagBitsKHR_map = {
29526     std::make_pair(1ULL << 0, "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR"),
29527     std::make_pair(1ULL << 1, "VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR"),
29528     std::make_pair(1ULL << 0, "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR"),
29529     std::make_pair(1ULL << 2, "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR"),
29530 };
print_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateFlagBitsKHR obj,const std::string & str,bool commaNeeded=true)29531 static void print_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateFlagBitsKHR obj, const std::string &str,
29532                                                bool commaNeeded = true)
29533 {
29534     PRINT_SPACE
29535     if (str != "")
29536         _OUT << "\"" << str << "\""
29537              << " : ";
29538     if (commaNeeded)
29539         _OUT << "\"" << VkSwapchainCreateFlagBitsKHR_map[obj] << "\"," << std::endl;
29540     else
29541         _OUT << "\"" << VkSwapchainCreateFlagBitsKHR_map[obj] << "\"" << std::endl;
29542 }
print_VkSwapchainCreateFlagBitsKHR(const VkSwapchainCreateFlagBitsKHR * obj,const std::string & str,bool commaNeeded=true)29543 static void print_VkSwapchainCreateFlagBitsKHR(const VkSwapchainCreateFlagBitsKHR *obj, const std::string &str,
29544                                                bool commaNeeded = true)
29545 {
29546     PRINT_SPACE
29547     if (str != "")
29548         _OUT << "\"" << str << "\""
29549              << " : ";
29550     if (commaNeeded)
29551         _OUT << "\"" << VkSwapchainCreateFlagBitsKHR_map[*obj] << "\"," << std::endl;
29552     else
29553         _OUT << "\"" << VkSwapchainCreateFlagBitsKHR_map[*obj] << "\"" << std::endl;
29554 }
29555 
29556 static std::map<uint64_t, std::string> VkDeviceGroupPresentModeFlagBitsKHR_map = {
29557     std::make_pair(1ULL << 0, "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR"),
29558     std::make_pair(1ULL << 1, "VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR"),
29559     std::make_pair(1ULL << 2, "VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR"),
29560     std::make_pair(1ULL << 3, "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR"),
29561 };
print_VkDeviceGroupPresentModeFlagBitsKHR(VkDeviceGroupPresentModeFlagBitsKHR obj,const std::string & str,bool commaNeeded=true)29562 static void print_VkDeviceGroupPresentModeFlagBitsKHR(VkDeviceGroupPresentModeFlagBitsKHR obj, const std::string &str,
29563                                                       bool commaNeeded = true)
29564 {
29565     PRINT_SPACE
29566     if (str != "")
29567         _OUT << "\"" << str << "\""
29568              << " : ";
29569     if (commaNeeded)
29570         _OUT << "\"" << VkDeviceGroupPresentModeFlagBitsKHR_map[obj] << "\"," << std::endl;
29571     else
29572         _OUT << "\"" << VkDeviceGroupPresentModeFlagBitsKHR_map[obj] << "\"" << std::endl;
29573 }
print_VkDeviceGroupPresentModeFlagBitsKHR(const VkDeviceGroupPresentModeFlagBitsKHR * obj,const std::string & str,bool commaNeeded=true)29574 static void print_VkDeviceGroupPresentModeFlagBitsKHR(const VkDeviceGroupPresentModeFlagBitsKHR *obj,
29575                                                       const std::string &str, bool commaNeeded = true)
29576 {
29577     PRINT_SPACE
29578     if (str != "")
29579         _OUT << "\"" << str << "\""
29580              << " : ";
29581     if (commaNeeded)
29582         _OUT << "\"" << VkDeviceGroupPresentModeFlagBitsKHR_map[*obj] << "\"," << std::endl;
29583     else
29584         _OUT << "\"" << VkDeviceGroupPresentModeFlagBitsKHR_map[*obj] << "\"" << std::endl;
29585 }
29586 
print_VkSwapchainCreateFlagsKHR(VkSwapchainCreateFlagsKHR obj,const std::string & str,bool commaNeeded=true)29587 static void print_VkSwapchainCreateFlagsKHR(VkSwapchainCreateFlagsKHR obj, const std::string &str,
29588                                             bool commaNeeded = true)
29589 {
29590     PRINT_SPACE
29591     if (str != "")
29592         _OUT << "\"" << str << "\""
29593              << " : ";
29594     const int max_bits = 64; // We don't expect the number to be larger.
29595     std::bitset<max_bits> b(obj);
29596     _OUT << "\"";
29597     if (obj == 0)
29598         _OUT << "0";
29599     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
29600     {
29601         if (b[i] == 1)
29602         {
29603             bitCount++;
29604             if (bitCount < b.count())
29605                 _OUT << VkSwapchainCreateFlagBitsKHR_map[1ULL << i] << " | ";
29606             else
29607                 _OUT << VkSwapchainCreateFlagBitsKHR_map[1ULL << i];
29608         }
29609     }
29610     if (commaNeeded)
29611         _OUT << "\""
29612              << ",";
29613     else
29614         _OUT << "\""
29615              << "";
29616     _OUT << std::endl;
29617 }
print_VkSwapchainCreateFlagsKHR(const VkSwapchainCreateFlagsKHR * obj,const std::string & str,bool commaNeeded=true)29618 static void print_VkSwapchainCreateFlagsKHR(const VkSwapchainCreateFlagsKHR *obj, const std::string &str,
29619                                             bool commaNeeded = true)
29620 {
29621     PRINT_SPACE
29622     if (str != "")
29623         _OUT << "\"" << str << "\""
29624              << " : ";
29625     const int max_bits = 64; // We don't expect the number to be larger.
29626     std::bitset<max_bits> b(obj);
29627     _OUT << "\"";
29628     if (obj == 0)
29629         _OUT << "0";
29630     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
29631     {
29632         if (b[i] == 1)
29633         {
29634             bitCount++;
29635             if (bitCount < b.count())
29636                 _OUT << VkSwapchainCreateFlagBitsKHR_map[1ULL << i] << " | ";
29637             else
29638                 _OUT << VkSwapchainCreateFlagBitsKHR_map[1ULL << i];
29639         }
29640     }
29641     if (commaNeeded)
29642         _OUT << "\""
29643              << ",";
29644     else
29645         _OUT << "\""
29646              << "";
29647     _OUT << std::endl;
29648 }
29649 
print_VkDeviceGroupPresentModeFlagsKHR(VkDeviceGroupPresentModeFlagsKHR obj,const std::string & str,bool commaNeeded=true)29650 static void print_VkDeviceGroupPresentModeFlagsKHR(VkDeviceGroupPresentModeFlagsKHR obj, const std::string &str,
29651                                                    bool commaNeeded = true)
29652 {
29653     PRINT_SPACE
29654     if (str != "")
29655         _OUT << "\"" << str << "\""
29656              << " : ";
29657     const int max_bits = 64; // We don't expect the number to be larger.
29658     std::bitset<max_bits> b(obj);
29659     _OUT << "\"";
29660     if (obj == 0)
29661         _OUT << "0";
29662     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
29663     {
29664         if (b[i] == 1)
29665         {
29666             bitCount++;
29667             if (bitCount < b.count())
29668                 _OUT << VkDeviceGroupPresentModeFlagBitsKHR_map[1ULL << i] << " | ";
29669             else
29670                 _OUT << VkDeviceGroupPresentModeFlagBitsKHR_map[1ULL << i];
29671         }
29672     }
29673     if (commaNeeded)
29674         _OUT << "\""
29675              << ",";
29676     else
29677         _OUT << "\""
29678              << "";
29679     _OUT << std::endl;
29680 }
print_VkDeviceGroupPresentModeFlagsKHR(const VkDeviceGroupPresentModeFlagsKHR * obj,const std::string & str,bool commaNeeded=true)29681 static void print_VkDeviceGroupPresentModeFlagsKHR(const VkDeviceGroupPresentModeFlagsKHR *obj, const std::string &str,
29682                                                    bool commaNeeded = true)
29683 {
29684     PRINT_SPACE
29685     if (str != "")
29686         _OUT << "\"" << str << "\""
29687              << " : ";
29688     const int max_bits = 64; // We don't expect the number to be larger.
29689     std::bitset<max_bits> b(obj);
29690     _OUT << "\"";
29691     if (obj == 0)
29692         _OUT << "0";
29693     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
29694     {
29695         if (b[i] == 1)
29696         {
29697             bitCount++;
29698             if (bitCount < b.count())
29699                 _OUT << VkDeviceGroupPresentModeFlagBitsKHR_map[1ULL << i] << " | ";
29700             else
29701                 _OUT << VkDeviceGroupPresentModeFlagBitsKHR_map[1ULL << i];
29702         }
29703     }
29704     if (commaNeeded)
29705         _OUT << "\""
29706              << ",";
29707     else
29708         _OUT << "\""
29709              << "";
29710     _OUT << std::endl;
29711 }
29712 
print_VkSwapchainCreateInfoKHR(VkSwapchainCreateInfoKHR obj,const std::string & s,bool commaNeeded=true)29713 static void print_VkSwapchainCreateInfoKHR(VkSwapchainCreateInfoKHR obj, const std::string &s, bool commaNeeded = true)
29714 {
29715     PRINT_SPACE
29716     _OUT << "{" << std::endl;
29717     INDENT(4);
29718 
29719     print_VkStructureType(obj.sType, "sType", 1);
29720 
29721     if (obj.pNext)
29722     {
29723         dumpPNextChain(obj.pNext);
29724     }
29725     else
29726     {
29727         PRINT_SPACE
29728         _OUT << "\"pNext\":"
29729              << "\"NULL\""
29730              << "," << std::endl;
29731     }
29732 
29733     print_VkSwapchainCreateFlagsKHR(obj.flags, "flags", 1);
29734 
29735     // CTS : required value
29736     PRINT_SPACE _OUT << "\""
29737                      << "surface"
29738                      << "\""
29739                      << " : "
29740                      << "\""
29741                      << "\"," << std::endl;
29742 
29743     print_uint32_t(obj.minImageCount, "minImageCount", 1);
29744 
29745     print_VkFormat(obj.imageFormat, "imageFormat", 1);
29746 
29747     print_VkColorSpaceKHR(obj.imageColorSpace, "imageColorSpace", 1);
29748 
29749     PRINT_SPACE
29750     _OUT << "\"imageExtent\": " << std::endl;
29751     {
29752         print_VkExtent2D(obj.imageExtent, "imageExtent", 1);
29753     }
29754 
29755     print_uint32_t(obj.imageArrayLayers, "imageArrayLayers", 1);
29756 
29757     print_VkImageUsageFlags(obj.imageUsage, "imageUsage", 1);
29758 
29759     print_VkSharingMode(obj.imageSharingMode, "imageSharingMode", 1);
29760 
29761     print_uint32_t(obj.queueFamilyIndexCount, "queueFamilyIndexCount", 1);
29762 
29763     PRINT_SPACE
29764     _OUT << "\"pQueueFamilyIndices\":" << std::endl;
29765     PRINT_SPACE
29766     if (obj.pQueueFamilyIndices)
29767     {
29768         _OUT << "[" << std::endl;
29769         for (unsigned int i = 0; i < obj.queueFamilyIndexCount; i++)
29770         {
29771             bool isCommaNeeded = (i + 1) != obj.queueFamilyIndexCount;
29772             print_uint32_t(obj.pQueueFamilyIndices[i], "", isCommaNeeded);
29773         }
29774         PRINT_SPACE
29775         _OUT << "]"
29776              << "," << std::endl;
29777     }
29778     else
29779     {
29780         _OUT << "\"NULL\""
29781              << "," << std::endl;
29782     }
29783 
29784     print_VkSurfaceTransformFlagBitsKHR(obj.preTransform, "preTransform", 1);
29785 
29786     print_VkCompositeAlphaFlagBitsKHR(obj.compositeAlpha, "compositeAlpha", 1);
29787 
29788     print_VkPresentModeKHR(obj.presentMode, "presentMode", 1);
29789 
29790     print_VkBool32(obj.clipped, "clipped", 1);
29791 
29792     // CTS : required value
29793     PRINT_SPACE _OUT << "\""
29794                      << "oldSwapchain"
29795                      << "\""
29796                      << " : "
29797                      << "\""
29798                      << "\"" << std::endl;
29799 
29800     INDENT(-4);
29801     PRINT_SPACE
29802     if (commaNeeded)
29803         _OUT << "}," << std::endl;
29804     else
29805         _OUT << "}" << std::endl;
29806 }
print_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR * obj,const std::string & s,bool commaNeeded=true)29807 static void print_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR *obj, const std::string &s,
29808                                            bool commaNeeded = true)
29809 {
29810     PRINT_SPACE
29811     _OUT << "{" << std::endl;
29812     INDENT(4);
29813 
29814     print_VkStructureType(obj->sType, "sType", 1);
29815 
29816     if (obj->pNext)
29817     {
29818         dumpPNextChain(obj->pNext);
29819     }
29820     else
29821     {
29822         PRINT_SPACE
29823         _OUT << "\"pNext\":"
29824              << "\"NULL\""
29825              << "," << std::endl;
29826     }
29827 
29828     print_VkSwapchainCreateFlagsKHR(obj->flags, "flags", 1);
29829 
29830     // CTS : required value
29831     PRINT_SPACE _OUT << "\""
29832                      << "surface"
29833                      << "\""
29834                      << " : "
29835                      << "\""
29836                      << "\"," << std::endl;
29837 
29838     print_uint32_t(obj->minImageCount, "minImageCount", 1);
29839 
29840     print_VkFormat(obj->imageFormat, "imageFormat", 1);
29841 
29842     print_VkColorSpaceKHR(obj->imageColorSpace, "imageColorSpace", 1);
29843 
29844     PRINT_SPACE
29845     _OUT << "\"imageExtent\": " << std::endl;
29846     {
29847         print_VkExtent2D(obj->imageExtent, "imageExtent", 1);
29848     }
29849 
29850     print_uint32_t(obj->imageArrayLayers, "imageArrayLayers", 1);
29851 
29852     print_VkImageUsageFlags(obj->imageUsage, "imageUsage", 1);
29853 
29854     print_VkSharingMode(obj->imageSharingMode, "imageSharingMode", 1);
29855 
29856     print_uint32_t(obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1);
29857 
29858     PRINT_SPACE
29859     _OUT << "\"pQueueFamilyIndices\":" << std::endl;
29860     PRINT_SPACE
29861     if (obj->pQueueFamilyIndices)
29862     {
29863         _OUT << "[" << std::endl;
29864         for (unsigned int i = 0; i < obj->queueFamilyIndexCount; i++)
29865         {
29866             bool isCommaNeeded = (i + 1) != obj->queueFamilyIndexCount;
29867             print_uint32_t(obj->pQueueFamilyIndices[i], "", isCommaNeeded);
29868         }
29869         PRINT_SPACE
29870         _OUT << "]"
29871              << "," << std::endl;
29872     }
29873     else
29874     {
29875         _OUT << "\"NULL\""
29876              << "," << std::endl;
29877     }
29878 
29879     print_VkSurfaceTransformFlagBitsKHR(obj->preTransform, "preTransform", 1);
29880 
29881     print_VkCompositeAlphaFlagBitsKHR(obj->compositeAlpha, "compositeAlpha", 1);
29882 
29883     print_VkPresentModeKHR(obj->presentMode, "presentMode", 1);
29884 
29885     print_VkBool32(obj->clipped, "clipped", 1);
29886 
29887     // CTS : required value
29888     PRINT_SPACE _OUT << "\""
29889                      << "oldSwapchain"
29890                      << "\""
29891                      << " : "
29892                      << "\""
29893                      << "\"" << std::endl;
29894 
29895     INDENT(-4);
29896     PRINT_SPACE
29897     if (commaNeeded)
29898         _OUT << "}," << std::endl;
29899     else
29900         _OUT << "}" << std::endl;
29901 }
29902 
print_VkPresentInfoKHR(VkPresentInfoKHR obj,const std::string & s,bool commaNeeded=true)29903 static void print_VkPresentInfoKHR(VkPresentInfoKHR obj, const std::string &s, bool commaNeeded = true)
29904 {
29905     PRINT_SPACE
29906     _OUT << "{" << std::endl;
29907     INDENT(4);
29908 
29909     print_VkStructureType(obj.sType, "sType", 1);
29910 
29911     if (obj.pNext)
29912     {
29913         dumpPNextChain(obj.pNext);
29914     }
29915     else
29916     {
29917         PRINT_SPACE
29918         _OUT << "\"pNext\":"
29919              << "\"NULL\""
29920              << "," << std::endl;
29921     }
29922 
29923     print_uint32_t(obj.waitSemaphoreCount, "waitSemaphoreCount", 1);
29924 
29925     PRINT_SPACE
29926     _OUT << "\"pWaitSemaphores\":" << std::endl;
29927     PRINT_SPACE
29928     if (obj.pWaitSemaphores)
29929     {
29930         _OUT << "[" << std::endl;
29931         for (unsigned int i = 0; i < obj.waitSemaphoreCount; i++)
29932         {
29933             std::stringstream tmp;
29934             tmp << "pWaitSemaphores"
29935                 << "_" << i;
29936             bool isCommaNeeded = (i + 1) != obj.waitSemaphoreCount;
29937             print_VkSemaphore(obj.pWaitSemaphores[i], tmp.str(), isCommaNeeded);
29938         }
29939         PRINT_SPACE
29940         _OUT << "]"
29941              << "," << std::endl;
29942     }
29943     else
29944     {
29945         _OUT << "\"NULL\""
29946              << "," << std::endl;
29947     }
29948 
29949     print_uint32_t(obj.swapchainCount, "swapchainCount", 1);
29950 
29951     PRINT_SPACE
29952     _OUT << "\"pSwapchains\":" << std::endl;
29953     PRINT_SPACE
29954     if (obj.pSwapchains)
29955     {
29956         _OUT << "[" << std::endl;
29957         for (unsigned int i = 0; i < obj.swapchainCount; i++)
29958         {
29959             std::stringstream tmp;
29960             tmp << "pSwapchains"
29961                 << "_" << i;
29962             bool isCommaNeeded = (i + 1) != obj.swapchainCount;
29963             print_VkSwapchainKHR(obj.pSwapchains[i], tmp.str(), isCommaNeeded);
29964         }
29965         PRINT_SPACE
29966         _OUT << "]"
29967              << "," << std::endl;
29968     }
29969     else
29970     {
29971         _OUT << "\"NULL\""
29972              << "," << std::endl;
29973     }
29974 
29975     PRINT_SPACE
29976     _OUT << "\"pImageIndices\":" << std::endl;
29977     PRINT_SPACE
29978     if (obj.pImageIndices)
29979     {
29980         _OUT << "[" << std::endl;
29981         for (unsigned int i = 0; i < obj.swapchainCount; i++)
29982         {
29983             bool isCommaNeeded = (i + 1) != obj.swapchainCount;
29984             print_uint32_t(obj.pImageIndices[i], "", isCommaNeeded);
29985         }
29986         PRINT_SPACE
29987         _OUT << "]"
29988              << "," << std::endl;
29989     }
29990     else
29991     {
29992         _OUT << "\"NULL\""
29993              << "," << std::endl;
29994     }
29995 
29996     PRINT_SPACE
29997     _OUT << "\"pResults\":" << std::endl;
29998     PRINT_SPACE
29999     if (obj.pResults)
30000     {
30001         _OUT << "[" << std::endl;
30002         for (unsigned int i = 0; i < obj.swapchainCount; i++)
30003         {
30004             bool isCommaNeeded = (i + 1) != obj.swapchainCount;
30005             print_VkResult(obj.pResults[i], "", isCommaNeeded);
30006         }
30007         PRINT_SPACE
30008         _OUT << "]"
30009              << "" << std::endl;
30010     }
30011     else
30012     {
30013         _OUT << "\"NULL\""
30014              << "" << std::endl;
30015     }
30016 
30017     INDENT(-4);
30018     PRINT_SPACE
30019     if (commaNeeded)
30020         _OUT << "}," << std::endl;
30021     else
30022         _OUT << "}" << std::endl;
30023 }
print_VkPresentInfoKHR(const VkPresentInfoKHR * obj,const std::string & s,bool commaNeeded=true)30024 static void print_VkPresentInfoKHR(const VkPresentInfoKHR *obj, const std::string &s, bool commaNeeded = true)
30025 {
30026     PRINT_SPACE
30027     _OUT << "{" << std::endl;
30028     INDENT(4);
30029 
30030     print_VkStructureType(obj->sType, "sType", 1);
30031 
30032     if (obj->pNext)
30033     {
30034         dumpPNextChain(obj->pNext);
30035     }
30036     else
30037     {
30038         PRINT_SPACE
30039         _OUT << "\"pNext\":"
30040              << "\"NULL\""
30041              << "," << std::endl;
30042     }
30043 
30044     print_uint32_t(obj->waitSemaphoreCount, "waitSemaphoreCount", 1);
30045 
30046     PRINT_SPACE
30047     _OUT << "\"pWaitSemaphores\":" << std::endl;
30048     PRINT_SPACE
30049     if (obj->pWaitSemaphores)
30050     {
30051         _OUT << "[" << std::endl;
30052         for (unsigned int i = 0; i < obj->waitSemaphoreCount; i++)
30053         {
30054             std::stringstream tmp;
30055             tmp << "pWaitSemaphores"
30056                 << "_" << i;
30057             bool isCommaNeeded = (i + 1) != obj->waitSemaphoreCount;
30058             print_VkSemaphore(obj->pWaitSemaphores[i], tmp.str(), isCommaNeeded);
30059         }
30060         PRINT_SPACE
30061         _OUT << "]"
30062              << "," << std::endl;
30063     }
30064     else
30065     {
30066         _OUT << "\"NULL\""
30067              << "," << std::endl;
30068     }
30069 
30070     print_uint32_t(obj->swapchainCount, "swapchainCount", 1);
30071 
30072     PRINT_SPACE
30073     _OUT << "\"pSwapchains\":" << std::endl;
30074     PRINT_SPACE
30075     if (obj->pSwapchains)
30076     {
30077         _OUT << "[" << std::endl;
30078         for (unsigned int i = 0; i < obj->swapchainCount; i++)
30079         {
30080             std::stringstream tmp;
30081             tmp << "pSwapchains"
30082                 << "_" << i;
30083             bool isCommaNeeded = (i + 1) != obj->swapchainCount;
30084             print_VkSwapchainKHR(obj->pSwapchains[i], tmp.str(), isCommaNeeded);
30085         }
30086         PRINT_SPACE
30087         _OUT << "]"
30088              << "," << std::endl;
30089     }
30090     else
30091     {
30092         _OUT << "\"NULL\""
30093              << "," << std::endl;
30094     }
30095 
30096     PRINT_SPACE
30097     _OUT << "\"pImageIndices\":" << std::endl;
30098     PRINT_SPACE
30099     if (obj->pImageIndices)
30100     {
30101         _OUT << "[" << std::endl;
30102         for (unsigned int i = 0; i < obj->swapchainCount; i++)
30103         {
30104             bool isCommaNeeded = (i + 1) != obj->swapchainCount;
30105             print_uint32_t(obj->pImageIndices[i], "", isCommaNeeded);
30106         }
30107         PRINT_SPACE
30108         _OUT << "]"
30109              << "," << std::endl;
30110     }
30111     else
30112     {
30113         _OUT << "\"NULL\""
30114              << "," << std::endl;
30115     }
30116 
30117     PRINT_SPACE
30118     _OUT << "\"pResults\":" << std::endl;
30119     PRINT_SPACE
30120     if (obj->pResults)
30121     {
30122         _OUT << "[" << std::endl;
30123         for (unsigned int i = 0; i < obj->swapchainCount; i++)
30124         {
30125             bool isCommaNeeded = (i + 1) != obj->swapchainCount;
30126             print_VkResult(obj->pResults[i], "", isCommaNeeded);
30127         }
30128         PRINT_SPACE
30129         _OUT << "]"
30130              << "" << std::endl;
30131     }
30132     else
30133     {
30134         _OUT << "\"NULL\""
30135              << "" << std::endl;
30136     }
30137 
30138     INDENT(-4);
30139     PRINT_SPACE
30140     if (commaNeeded)
30141         _OUT << "}," << std::endl;
30142     else
30143         _OUT << "}" << std::endl;
30144 }
30145 
print_VkImageSwapchainCreateInfoKHR(VkImageSwapchainCreateInfoKHR obj,const std::string & s,bool commaNeeded=true)30146 static void print_VkImageSwapchainCreateInfoKHR(VkImageSwapchainCreateInfoKHR obj, const std::string &s,
30147                                                 bool commaNeeded = true)
30148 {
30149     PRINT_SPACE
30150     _OUT << "{" << std::endl;
30151     INDENT(4);
30152 
30153     print_VkStructureType(obj.sType, "sType", 1);
30154 
30155     if (obj.pNext)
30156     {
30157         dumpPNextChain(obj.pNext);
30158     }
30159     else
30160     {
30161         PRINT_SPACE
30162         _OUT << "\"pNext\":"
30163              << "\"NULL\""
30164              << "," << std::endl;
30165     }
30166 
30167     // CTS : required value
30168     PRINT_SPACE _OUT << "\""
30169                      << "swapchain"
30170                      << "\""
30171                      << " : "
30172                      << "\""
30173                      << "\"" << std::endl;
30174 
30175     INDENT(-4);
30176     PRINT_SPACE
30177     if (commaNeeded)
30178         _OUT << "}," << std::endl;
30179     else
30180         _OUT << "}" << std::endl;
30181 }
print_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR * obj,const std::string & s,bool commaNeeded=true)30182 static void print_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR *obj, const std::string &s,
30183                                                 bool commaNeeded = true)
30184 {
30185     PRINT_SPACE
30186     _OUT << "{" << std::endl;
30187     INDENT(4);
30188 
30189     print_VkStructureType(obj->sType, "sType", 1);
30190 
30191     if (obj->pNext)
30192     {
30193         dumpPNextChain(obj->pNext);
30194     }
30195     else
30196     {
30197         PRINT_SPACE
30198         _OUT << "\"pNext\":"
30199              << "\"NULL\""
30200              << "," << std::endl;
30201     }
30202 
30203     // CTS : required value
30204     PRINT_SPACE _OUT << "\""
30205                      << "swapchain"
30206                      << "\""
30207                      << " : "
30208                      << "\""
30209                      << "\"" << std::endl;
30210 
30211     INDENT(-4);
30212     PRINT_SPACE
30213     if (commaNeeded)
30214         _OUT << "}," << std::endl;
30215     else
30216         _OUT << "}" << std::endl;
30217 }
30218 
print_VkBindImageMemorySwapchainInfoKHR(VkBindImageMemorySwapchainInfoKHR obj,const std::string & s,bool commaNeeded=true)30219 static void print_VkBindImageMemorySwapchainInfoKHR(VkBindImageMemorySwapchainInfoKHR obj, const std::string &s,
30220                                                     bool commaNeeded = true)
30221 {
30222     PRINT_SPACE
30223     _OUT << "{" << std::endl;
30224     INDENT(4);
30225 
30226     print_VkStructureType(obj.sType, "sType", 1);
30227 
30228     if (obj.pNext)
30229     {
30230         dumpPNextChain(obj.pNext);
30231     }
30232     else
30233     {
30234         PRINT_SPACE
30235         _OUT << "\"pNext\":"
30236              << "\"NULL\""
30237              << "," << std::endl;
30238     }
30239 
30240     // CTS : required value
30241     PRINT_SPACE _OUT << "\""
30242                      << "swapchain"
30243                      << "\""
30244                      << " : "
30245                      << "\""
30246                      << "\"," << std::endl;
30247 
30248     print_uint32_t(obj.imageIndex, "imageIndex", 0);
30249 
30250     INDENT(-4);
30251     PRINT_SPACE
30252     if (commaNeeded)
30253         _OUT << "}," << std::endl;
30254     else
30255         _OUT << "}" << std::endl;
30256 }
print_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR * obj,const std::string & s,bool commaNeeded=true)30257 static void print_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR *obj, const std::string &s,
30258                                                     bool commaNeeded = true)
30259 {
30260     PRINT_SPACE
30261     _OUT << "{" << std::endl;
30262     INDENT(4);
30263 
30264     print_VkStructureType(obj->sType, "sType", 1);
30265 
30266     if (obj->pNext)
30267     {
30268         dumpPNextChain(obj->pNext);
30269     }
30270     else
30271     {
30272         PRINT_SPACE
30273         _OUT << "\"pNext\":"
30274              << "\"NULL\""
30275              << "," << std::endl;
30276     }
30277 
30278     // CTS : required value
30279     PRINT_SPACE _OUT << "\""
30280                      << "swapchain"
30281                      << "\""
30282                      << " : "
30283                      << "\""
30284                      << "\"," << std::endl;
30285 
30286     print_uint32_t(obj->imageIndex, "imageIndex", 0);
30287 
30288     INDENT(-4);
30289     PRINT_SPACE
30290     if (commaNeeded)
30291         _OUT << "}," << std::endl;
30292     else
30293         _OUT << "}" << std::endl;
30294 }
30295 
print_VkAcquireNextImageInfoKHR(VkAcquireNextImageInfoKHR obj,const std::string & s,bool commaNeeded=true)30296 static void print_VkAcquireNextImageInfoKHR(VkAcquireNextImageInfoKHR obj, const std::string &s,
30297                                             bool commaNeeded = true)
30298 {
30299     PRINT_SPACE
30300     _OUT << "{" << std::endl;
30301     INDENT(4);
30302 
30303     print_VkStructureType(obj.sType, "sType", 1);
30304 
30305     if (obj.pNext)
30306     {
30307         dumpPNextChain(obj.pNext);
30308     }
30309     else
30310     {
30311         PRINT_SPACE
30312         _OUT << "\"pNext\":"
30313              << "\"NULL\""
30314              << "," << std::endl;
30315     }
30316 
30317     // CTS : required value
30318     PRINT_SPACE _OUT << "\""
30319                      << "swapchain"
30320                      << "\""
30321                      << " : "
30322                      << "\""
30323                      << "\"," << std::endl;
30324 
30325     print_uint64_t(obj.timeout, "timeout", 1);
30326 
30327     // CTS : required value
30328     PRINT_SPACE _OUT << "\""
30329                      << "semaphore"
30330                      << "\""
30331                      << " : "
30332                      << "\""
30333                      << "\"," << std::endl;
30334 
30335     // CTS : required value
30336     PRINT_SPACE _OUT << "\""
30337                      << "fence"
30338                      << "\""
30339                      << " : "
30340                      << "\""
30341                      << "\"," << std::endl;
30342 
30343     print_uint32_t(obj.deviceMask, "deviceMask", 0);
30344 
30345     INDENT(-4);
30346     PRINT_SPACE
30347     if (commaNeeded)
30348         _OUT << "}," << std::endl;
30349     else
30350         _OUT << "}" << std::endl;
30351 }
print_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR * obj,const std::string & s,bool commaNeeded=true)30352 static void print_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR *obj, const std::string &s,
30353                                             bool commaNeeded = true)
30354 {
30355     PRINT_SPACE
30356     _OUT << "{" << std::endl;
30357     INDENT(4);
30358 
30359     print_VkStructureType(obj->sType, "sType", 1);
30360 
30361     if (obj->pNext)
30362     {
30363         dumpPNextChain(obj->pNext);
30364     }
30365     else
30366     {
30367         PRINT_SPACE
30368         _OUT << "\"pNext\":"
30369              << "\"NULL\""
30370              << "," << std::endl;
30371     }
30372 
30373     // CTS : required value
30374     PRINT_SPACE _OUT << "\""
30375                      << "swapchain"
30376                      << "\""
30377                      << " : "
30378                      << "\""
30379                      << "\"," << std::endl;
30380 
30381     print_uint64_t(obj->timeout, "timeout", 1);
30382 
30383     // CTS : required value
30384     PRINT_SPACE _OUT << "\""
30385                      << "semaphore"
30386                      << "\""
30387                      << " : "
30388                      << "\""
30389                      << "\"," << std::endl;
30390 
30391     // CTS : required value
30392     PRINT_SPACE _OUT << "\""
30393                      << "fence"
30394                      << "\""
30395                      << " : "
30396                      << "\""
30397                      << "\"," << std::endl;
30398 
30399     print_uint32_t(obj->deviceMask, "deviceMask", 0);
30400 
30401     INDENT(-4);
30402     PRINT_SPACE
30403     if (commaNeeded)
30404         _OUT << "}," << std::endl;
30405     else
30406         _OUT << "}" << std::endl;
30407 }
30408 
print_VkDeviceGroupPresentCapabilitiesKHR(VkDeviceGroupPresentCapabilitiesKHR obj,const std::string & s,bool commaNeeded=true)30409 static void print_VkDeviceGroupPresentCapabilitiesKHR(VkDeviceGroupPresentCapabilitiesKHR obj, const std::string &s,
30410                                                       bool commaNeeded = true)
30411 {
30412     PRINT_SPACE
30413     _OUT << "{" << std::endl;
30414     INDENT(4);
30415 
30416     print_VkStructureType(obj.sType, "sType", 1);
30417 
30418     if (obj.pNext)
30419     {
30420         dumpPNextChain(obj.pNext);
30421     }
30422     else
30423     {
30424         PRINT_SPACE
30425         _OUT << "\"pNext\":"
30426              << "\"NULL\""
30427              << "," << std::endl;
30428     }
30429 
30430     PRINT_SPACE
30431     _OUT << "\"presentMask\":" << std::endl;
30432     PRINT_SPACE
30433     _OUT << "[" << std::endl;
30434     for (unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
30435     {
30436         bool isCommaNeeded = (i + 1) != VK_MAX_DEVICE_GROUP_SIZE;
30437         print_uint32_t(obj.presentMask[i], "", isCommaNeeded);
30438     }
30439     PRINT_SPACE
30440     _OUT << "]"
30441          << "," << std::endl;
30442 
30443     print_VkDeviceGroupPresentModeFlagsKHR(obj.modes, "modes", 0);
30444 
30445     INDENT(-4);
30446     PRINT_SPACE
30447     if (commaNeeded)
30448         _OUT << "}," << std::endl;
30449     else
30450         _OUT << "}" << std::endl;
30451 }
print_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR * obj,const std::string & s,bool commaNeeded=true)30452 static void print_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR *obj,
30453                                                       const std::string &s, bool commaNeeded = true)
30454 {
30455     PRINT_SPACE
30456     _OUT << "{" << std::endl;
30457     INDENT(4);
30458 
30459     print_VkStructureType(obj->sType, "sType", 1);
30460 
30461     if (obj->pNext)
30462     {
30463         dumpPNextChain(obj->pNext);
30464     }
30465     else
30466     {
30467         PRINT_SPACE
30468         _OUT << "\"pNext\":"
30469              << "\"NULL\""
30470              << "," << std::endl;
30471     }
30472 
30473     PRINT_SPACE
30474     _OUT << "\"presentMask\":" << std::endl;
30475     PRINT_SPACE
30476     _OUT << "[" << std::endl;
30477     for (unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
30478     {
30479         bool isCommaNeeded = (i + 1) != VK_MAX_DEVICE_GROUP_SIZE;
30480         print_uint32_t(obj->presentMask[i], "", isCommaNeeded);
30481     }
30482     PRINT_SPACE
30483     _OUT << "]"
30484          << "," << std::endl;
30485 
30486     print_VkDeviceGroupPresentModeFlagsKHR(obj->modes, "modes", 0);
30487 
30488     INDENT(-4);
30489     PRINT_SPACE
30490     if (commaNeeded)
30491         _OUT << "}," << std::endl;
30492     else
30493         _OUT << "}" << std::endl;
30494 }
30495 
print_VkDeviceGroupPresentInfoKHR(VkDeviceGroupPresentInfoKHR obj,const std::string & s,bool commaNeeded=true)30496 static void print_VkDeviceGroupPresentInfoKHR(VkDeviceGroupPresentInfoKHR obj, const std::string &s,
30497                                               bool commaNeeded = true)
30498 {
30499     PRINT_SPACE
30500     _OUT << "{" << std::endl;
30501     INDENT(4);
30502 
30503     print_VkStructureType(obj.sType, "sType", 1);
30504 
30505     if (obj.pNext)
30506     {
30507         dumpPNextChain(obj.pNext);
30508     }
30509     else
30510     {
30511         PRINT_SPACE
30512         _OUT << "\"pNext\":"
30513              << "\"NULL\""
30514              << "," << std::endl;
30515     }
30516 
30517     print_uint32_t(obj.swapchainCount, "swapchainCount", 1);
30518 
30519     PRINT_SPACE
30520     _OUT << "\"pDeviceMasks\":" << std::endl;
30521     PRINT_SPACE
30522     if (obj.pDeviceMasks)
30523     {
30524         _OUT << "[" << std::endl;
30525         for (unsigned int i = 0; i < obj.swapchainCount; i++)
30526         {
30527             bool isCommaNeeded = (i + 1) != obj.swapchainCount;
30528             print_uint32_t(obj.pDeviceMasks[i], "", isCommaNeeded);
30529         }
30530         PRINT_SPACE
30531         _OUT << "]"
30532              << "," << std::endl;
30533     }
30534     else
30535     {
30536         _OUT << "\"NULL\""
30537              << "," << std::endl;
30538     }
30539 
30540     print_VkDeviceGroupPresentModeFlagBitsKHR(obj.mode, "mode", 0);
30541 
30542     INDENT(-4);
30543     PRINT_SPACE
30544     if (commaNeeded)
30545         _OUT << "}," << std::endl;
30546     else
30547         _OUT << "}" << std::endl;
30548 }
print_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR * obj,const std::string & s,bool commaNeeded=true)30549 static void print_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR *obj, const std::string &s,
30550                                               bool commaNeeded = true)
30551 {
30552     PRINT_SPACE
30553     _OUT << "{" << std::endl;
30554     INDENT(4);
30555 
30556     print_VkStructureType(obj->sType, "sType", 1);
30557 
30558     if (obj->pNext)
30559     {
30560         dumpPNextChain(obj->pNext);
30561     }
30562     else
30563     {
30564         PRINT_SPACE
30565         _OUT << "\"pNext\":"
30566              << "\"NULL\""
30567              << "," << std::endl;
30568     }
30569 
30570     print_uint32_t(obj->swapchainCount, "swapchainCount", 1);
30571 
30572     PRINT_SPACE
30573     _OUT << "\"pDeviceMasks\":" << std::endl;
30574     PRINT_SPACE
30575     if (obj->pDeviceMasks)
30576     {
30577         _OUT << "[" << std::endl;
30578         for (unsigned int i = 0; i < obj->swapchainCount; i++)
30579         {
30580             bool isCommaNeeded = (i + 1) != obj->swapchainCount;
30581             print_uint32_t(obj->pDeviceMasks[i], "", isCommaNeeded);
30582         }
30583         PRINT_SPACE
30584         _OUT << "]"
30585              << "," << std::endl;
30586     }
30587     else
30588     {
30589         _OUT << "\"NULL\""
30590              << "," << std::endl;
30591     }
30592 
30593     print_VkDeviceGroupPresentModeFlagBitsKHR(obj->mode, "mode", 0);
30594 
30595     INDENT(-4);
30596     PRINT_SPACE
30597     if (commaNeeded)
30598         _OUT << "}," << std::endl;
30599     else
30600         _OUT << "}" << std::endl;
30601 }
30602 
print_VkDeviceGroupSwapchainCreateInfoKHR(VkDeviceGroupSwapchainCreateInfoKHR obj,const std::string & s,bool commaNeeded=true)30603 static void print_VkDeviceGroupSwapchainCreateInfoKHR(VkDeviceGroupSwapchainCreateInfoKHR obj, const std::string &s,
30604                                                       bool commaNeeded = true)
30605 {
30606     PRINT_SPACE
30607     _OUT << "{" << std::endl;
30608     INDENT(4);
30609 
30610     print_VkStructureType(obj.sType, "sType", 1);
30611 
30612     if (obj.pNext)
30613     {
30614         dumpPNextChain(obj.pNext);
30615     }
30616     else
30617     {
30618         PRINT_SPACE
30619         _OUT << "\"pNext\":"
30620              << "\"NULL\""
30621              << "," << std::endl;
30622     }
30623 
30624     print_VkDeviceGroupPresentModeFlagsKHR(obj.modes, "modes", 0);
30625 
30626     INDENT(-4);
30627     PRINT_SPACE
30628     if (commaNeeded)
30629         _OUT << "}," << std::endl;
30630     else
30631         _OUT << "}" << std::endl;
30632 }
print_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR * obj,const std::string & s,bool commaNeeded=true)30633 static void print_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR *obj,
30634                                                       const std::string &s, bool commaNeeded = true)
30635 {
30636     PRINT_SPACE
30637     _OUT << "{" << std::endl;
30638     INDENT(4);
30639 
30640     print_VkStructureType(obj->sType, "sType", 1);
30641 
30642     if (obj->pNext)
30643     {
30644         dumpPNextChain(obj->pNext);
30645     }
30646     else
30647     {
30648         PRINT_SPACE
30649         _OUT << "\"pNext\":"
30650              << "\"NULL\""
30651              << "," << std::endl;
30652     }
30653 
30654     print_VkDeviceGroupPresentModeFlagsKHR(obj->modes, "modes", 0);
30655 
30656     INDENT(-4);
30657     PRINT_SPACE
30658     if (commaNeeded)
30659         _OUT << "}," << std::endl;
30660     else
30661         _OUT << "}" << std::endl;
30662 }
30663 
print_VkDisplayKHR(VkDisplayKHR obj,const std::string & str,bool commaNeeded=true)30664 static void print_VkDisplayKHR(VkDisplayKHR obj, const std::string &str, bool commaNeeded = true)
30665 {
30666     PRINT_SPACE
30667     if (commaNeeded)
30668         _OUT << "\"" << str << "\""
30669              << "," << std::endl;
30670     else
30671         _OUT << "\"" << str << "\"" << std::endl;
30672 }
print_VkDisplayKHR(const VkDisplayKHR * obj,const std::string & str,bool commaNeeded=true)30673 static void print_VkDisplayKHR(const VkDisplayKHR *obj, const std::string &str, bool commaNeeded = true)
30674 {
30675     PRINT_SPACE
30676     if (commaNeeded)
30677         _OUT << "\"" << str << "\""
30678              << "," << std::endl;
30679     else
30680         _OUT << "\"" << str << "\"" << std::endl;
30681 }
30682 
print_VkDisplayModeKHR(VkDisplayModeKHR obj,const std::string & str,bool commaNeeded=true)30683 static void print_VkDisplayModeKHR(VkDisplayModeKHR obj, const std::string &str, bool commaNeeded = true)
30684 {
30685     PRINT_SPACE
30686     if (commaNeeded)
30687         _OUT << "\"" << str << "\""
30688              << "," << std::endl;
30689     else
30690         _OUT << "\"" << str << "\"" << std::endl;
30691 }
print_VkDisplayModeKHR(const VkDisplayModeKHR * obj,const std::string & str,bool commaNeeded=true)30692 static void print_VkDisplayModeKHR(const VkDisplayModeKHR *obj, const std::string &str, bool commaNeeded = true)
30693 {
30694     PRINT_SPACE
30695     if (commaNeeded)
30696         _OUT << "\"" << str << "\""
30697              << "," << std::endl;
30698     else
30699         _OUT << "\"" << str << "\"" << std::endl;
30700 }
30701 
30702 static std::map<uint64_t, std::string> VkDisplayPlaneAlphaFlagBitsKHR_map = {
30703     std::make_pair(1ULL << 0, "VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR"),
30704     std::make_pair(1ULL << 1, "VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR"),
30705     std::make_pair(1ULL << 2, "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR"),
30706     std::make_pair(1ULL << 3, "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR"),
30707 };
print_VkDisplayPlaneAlphaFlagBitsKHR(VkDisplayPlaneAlphaFlagBitsKHR obj,const std::string & str,bool commaNeeded=true)30708 static void print_VkDisplayPlaneAlphaFlagBitsKHR(VkDisplayPlaneAlphaFlagBitsKHR obj, const std::string &str,
30709                                                  bool commaNeeded = true)
30710 {
30711     PRINT_SPACE
30712     if (str != "")
30713         _OUT << "\"" << str << "\""
30714              << " : ";
30715     if (commaNeeded)
30716         _OUT << "\"" << VkDisplayPlaneAlphaFlagBitsKHR_map[obj] << "\"," << std::endl;
30717     else
30718         _OUT << "\"" << VkDisplayPlaneAlphaFlagBitsKHR_map[obj] << "\"" << std::endl;
30719 }
print_VkDisplayPlaneAlphaFlagBitsKHR(const VkDisplayPlaneAlphaFlagBitsKHR * obj,const std::string & str,bool commaNeeded=true)30720 static void print_VkDisplayPlaneAlphaFlagBitsKHR(const VkDisplayPlaneAlphaFlagBitsKHR *obj, const std::string &str,
30721                                                  bool commaNeeded = true)
30722 {
30723     PRINT_SPACE
30724     if (str != "")
30725         _OUT << "\"" << str << "\""
30726              << " : ";
30727     if (commaNeeded)
30728         _OUT << "\"" << VkDisplayPlaneAlphaFlagBitsKHR_map[*obj] << "\"," << std::endl;
30729     else
30730         _OUT << "\"" << VkDisplayPlaneAlphaFlagBitsKHR_map[*obj] << "\"" << std::endl;
30731 }
30732 
print_VkDisplayModeCreateFlagsKHR(VkDisplayModeCreateFlagsKHR obj,const std::string & str,bool commaNeeded=true)30733 static void print_VkDisplayModeCreateFlagsKHR(VkDisplayModeCreateFlagsKHR obj, const std::string &str,
30734                                               bool commaNeeded = true)
30735 {
30736     PRINT_SPACE
30737     if (commaNeeded)
30738         _OUT << "\"" << str << "\""
30739              << " : " << obj << "," << std::endl;
30740     else
30741         _OUT << "\"" << str << "\""
30742              << " : " << obj << std::endl;
30743 }
print_VkDisplayModeCreateFlagsKHR(const VkDisplayModeCreateFlagsKHR * obj,const std::string & str,bool commaNeeded=true)30744 static void print_VkDisplayModeCreateFlagsKHR(const VkDisplayModeCreateFlagsKHR *obj, const std::string &str,
30745                                               bool commaNeeded = true)
30746 {
30747     PRINT_SPACE
30748     if (commaNeeded)
30749         _OUT << "\"" << str << "\""
30750              << " : " << obj << "," << std::endl;
30751     else
30752         _OUT << "\"" << str << "\""
30753              << " : " << obj << std::endl;
30754 }
30755 
print_VkDisplayPlaneAlphaFlagsKHR(VkDisplayPlaneAlphaFlagsKHR obj,const std::string & str,bool commaNeeded=true)30756 static void print_VkDisplayPlaneAlphaFlagsKHR(VkDisplayPlaneAlphaFlagsKHR obj, const std::string &str,
30757                                               bool commaNeeded = true)
30758 {
30759     PRINT_SPACE
30760     if (str != "")
30761         _OUT << "\"" << str << "\""
30762              << " : ";
30763     const int max_bits = 64; // We don't expect the number to be larger.
30764     std::bitset<max_bits> b(obj);
30765     _OUT << "\"";
30766     if (obj == 0)
30767         _OUT << "0";
30768     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
30769     {
30770         if (b[i] == 1)
30771         {
30772             bitCount++;
30773             if (bitCount < b.count())
30774                 _OUT << VkDisplayPlaneAlphaFlagBitsKHR_map[1ULL << i] << " | ";
30775             else
30776                 _OUT << VkDisplayPlaneAlphaFlagBitsKHR_map[1ULL << i];
30777         }
30778     }
30779     if (commaNeeded)
30780         _OUT << "\""
30781              << ",";
30782     else
30783         _OUT << "\""
30784              << "";
30785     _OUT << std::endl;
30786 }
print_VkDisplayPlaneAlphaFlagsKHR(const VkDisplayPlaneAlphaFlagsKHR * obj,const std::string & str,bool commaNeeded=true)30787 static void print_VkDisplayPlaneAlphaFlagsKHR(const VkDisplayPlaneAlphaFlagsKHR *obj, const std::string &str,
30788                                               bool commaNeeded = true)
30789 {
30790     PRINT_SPACE
30791     if (str != "")
30792         _OUT << "\"" << str << "\""
30793              << " : ";
30794     const int max_bits = 64; // We don't expect the number to be larger.
30795     std::bitset<max_bits> b(obj);
30796     _OUT << "\"";
30797     if (obj == 0)
30798         _OUT << "0";
30799     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
30800     {
30801         if (b[i] == 1)
30802         {
30803             bitCount++;
30804             if (bitCount < b.count())
30805                 _OUT << VkDisplayPlaneAlphaFlagBitsKHR_map[1ULL << i] << " | ";
30806             else
30807                 _OUT << VkDisplayPlaneAlphaFlagBitsKHR_map[1ULL << i];
30808         }
30809     }
30810     if (commaNeeded)
30811         _OUT << "\""
30812              << ",";
30813     else
30814         _OUT << "\""
30815              << "";
30816     _OUT << std::endl;
30817 }
30818 
print_VkDisplaySurfaceCreateFlagsKHR(VkDisplaySurfaceCreateFlagsKHR obj,const std::string & str,bool commaNeeded=true)30819 static void print_VkDisplaySurfaceCreateFlagsKHR(VkDisplaySurfaceCreateFlagsKHR obj, const std::string &str,
30820                                                  bool commaNeeded = true)
30821 {
30822     PRINT_SPACE
30823     if (commaNeeded)
30824         _OUT << "\"" << str << "\""
30825              << " : " << obj << "," << std::endl;
30826     else
30827         _OUT << "\"" << str << "\""
30828              << " : " << obj << std::endl;
30829 }
print_VkDisplaySurfaceCreateFlagsKHR(const VkDisplaySurfaceCreateFlagsKHR * obj,const std::string & str,bool commaNeeded=true)30830 static void print_VkDisplaySurfaceCreateFlagsKHR(const VkDisplaySurfaceCreateFlagsKHR *obj, const std::string &str,
30831                                                  bool commaNeeded = true)
30832 {
30833     PRINT_SPACE
30834     if (commaNeeded)
30835         _OUT << "\"" << str << "\""
30836              << " : " << obj << "," << std::endl;
30837     else
30838         _OUT << "\"" << str << "\""
30839              << " : " << obj << std::endl;
30840 }
30841 
print_VkDisplayModeParametersKHR(VkDisplayModeParametersKHR obj,const std::string & s,bool commaNeeded=true)30842 static void print_VkDisplayModeParametersKHR(VkDisplayModeParametersKHR obj, const std::string &s,
30843                                              bool commaNeeded = true)
30844 {
30845     PRINT_SPACE
30846     _OUT << "{" << std::endl;
30847     INDENT(4);
30848 
30849     PRINT_SPACE
30850     _OUT << "\"visibleRegion\": " << std::endl;
30851     {
30852         print_VkExtent2D(obj.visibleRegion, "visibleRegion", 1);
30853     }
30854 
30855     print_uint32_t(obj.refreshRate, "refreshRate", 0);
30856 
30857     INDENT(-4);
30858     PRINT_SPACE
30859     if (commaNeeded)
30860         _OUT << "}," << std::endl;
30861     else
30862         _OUT << "}" << std::endl;
30863 }
print_VkDisplayModeParametersKHR(const VkDisplayModeParametersKHR * obj,const std::string & s,bool commaNeeded=true)30864 static void print_VkDisplayModeParametersKHR(const VkDisplayModeParametersKHR *obj, const std::string &s,
30865                                              bool commaNeeded = true)
30866 {
30867     PRINT_SPACE
30868     _OUT << "{" << std::endl;
30869     INDENT(4);
30870 
30871     PRINT_SPACE
30872     _OUT << "\"visibleRegion\": " << std::endl;
30873     {
30874         print_VkExtent2D(obj->visibleRegion, "visibleRegion", 1);
30875     }
30876 
30877     print_uint32_t(obj->refreshRate, "refreshRate", 0);
30878 
30879     INDENT(-4);
30880     PRINT_SPACE
30881     if (commaNeeded)
30882         _OUT << "}," << std::endl;
30883     else
30884         _OUT << "}" << std::endl;
30885 }
30886 
print_VkDisplayModeCreateInfoKHR(VkDisplayModeCreateInfoKHR obj,const std::string & s,bool commaNeeded=true)30887 static void print_VkDisplayModeCreateInfoKHR(VkDisplayModeCreateInfoKHR obj, const std::string &s,
30888                                              bool commaNeeded = true)
30889 {
30890     PRINT_SPACE
30891     _OUT << "{" << std::endl;
30892     INDENT(4);
30893 
30894     print_VkStructureType(obj.sType, "sType", 1);
30895 
30896     if (obj.pNext)
30897     {
30898         dumpPNextChain(obj.pNext);
30899     }
30900     else
30901     {
30902         PRINT_SPACE
30903         _OUT << "\"pNext\":"
30904              << "\"NULL\""
30905              << "," << std::endl;
30906     }
30907 
30908     print_VkDisplayModeCreateFlagsKHR(obj.flags, "flags", 1);
30909 
30910     PRINT_SPACE
30911     _OUT << "\"parameters\": " << std::endl;
30912     {
30913         print_VkDisplayModeParametersKHR(obj.parameters, "parameters", 0);
30914     }
30915 
30916     INDENT(-4);
30917     PRINT_SPACE
30918     if (commaNeeded)
30919         _OUT << "}," << std::endl;
30920     else
30921         _OUT << "}" << std::endl;
30922 }
print_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR * obj,const std::string & s,bool commaNeeded=true)30923 static void print_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR *obj, const std::string &s,
30924                                              bool commaNeeded = true)
30925 {
30926     PRINT_SPACE
30927     _OUT << "{" << std::endl;
30928     INDENT(4);
30929 
30930     print_VkStructureType(obj->sType, "sType", 1);
30931 
30932     if (obj->pNext)
30933     {
30934         dumpPNextChain(obj->pNext);
30935     }
30936     else
30937     {
30938         PRINT_SPACE
30939         _OUT << "\"pNext\":"
30940              << "\"NULL\""
30941              << "," << std::endl;
30942     }
30943 
30944     print_VkDisplayModeCreateFlagsKHR(obj->flags, "flags", 1);
30945 
30946     PRINT_SPACE
30947     _OUT << "\"parameters\": " << std::endl;
30948     {
30949         print_VkDisplayModeParametersKHR(obj->parameters, "parameters", 0);
30950     }
30951 
30952     INDENT(-4);
30953     PRINT_SPACE
30954     if (commaNeeded)
30955         _OUT << "}," << std::endl;
30956     else
30957         _OUT << "}" << std::endl;
30958 }
30959 
print_VkDisplayModePropertiesKHR(VkDisplayModePropertiesKHR obj,const std::string & s,bool commaNeeded=true)30960 static void print_VkDisplayModePropertiesKHR(VkDisplayModePropertiesKHR obj, const std::string &s,
30961                                              bool commaNeeded = true)
30962 {
30963     PRINT_SPACE
30964     _OUT << "{" << std::endl;
30965     INDENT(4);
30966 
30967     // CTS : required value
30968     PRINT_SPACE _OUT << "\""
30969                      << "displayMode"
30970                      << "\""
30971                      << " : "
30972                      << "\""
30973                      << "\"," << std::endl;
30974 
30975     PRINT_SPACE
30976     _OUT << "\"parameters\": " << std::endl;
30977     {
30978         print_VkDisplayModeParametersKHR(obj.parameters, "parameters", 0);
30979     }
30980 
30981     INDENT(-4);
30982     PRINT_SPACE
30983     if (commaNeeded)
30984         _OUT << "}," << std::endl;
30985     else
30986         _OUT << "}" << std::endl;
30987 }
print_VkDisplayModePropertiesKHR(const VkDisplayModePropertiesKHR * obj,const std::string & s,bool commaNeeded=true)30988 static void print_VkDisplayModePropertiesKHR(const VkDisplayModePropertiesKHR *obj, const std::string &s,
30989                                              bool commaNeeded = true)
30990 {
30991     PRINT_SPACE
30992     _OUT << "{" << std::endl;
30993     INDENT(4);
30994 
30995     // CTS : required value
30996     PRINT_SPACE _OUT << "\""
30997                      << "displayMode"
30998                      << "\""
30999                      << " : "
31000                      << "\""
31001                      << "\"," << std::endl;
31002 
31003     PRINT_SPACE
31004     _OUT << "\"parameters\": " << std::endl;
31005     {
31006         print_VkDisplayModeParametersKHR(obj->parameters, "parameters", 0);
31007     }
31008 
31009     INDENT(-4);
31010     PRINT_SPACE
31011     if (commaNeeded)
31012         _OUT << "}," << std::endl;
31013     else
31014         _OUT << "}" << std::endl;
31015 }
31016 
print_VkDisplayPlaneCapabilitiesKHR(VkDisplayPlaneCapabilitiesKHR obj,const std::string & s,bool commaNeeded=true)31017 static void print_VkDisplayPlaneCapabilitiesKHR(VkDisplayPlaneCapabilitiesKHR obj, const std::string &s,
31018                                                 bool commaNeeded = true)
31019 {
31020     PRINT_SPACE
31021     _OUT << "{" << std::endl;
31022     INDENT(4);
31023 
31024     print_VkDisplayPlaneAlphaFlagsKHR(obj.supportedAlpha, "supportedAlpha", 1);
31025 
31026     PRINT_SPACE
31027     _OUT << "\"minSrcPosition\": " << std::endl;
31028     {
31029         print_VkOffset2D(obj.minSrcPosition, "minSrcPosition", 1);
31030     }
31031 
31032     PRINT_SPACE
31033     _OUT << "\"maxSrcPosition\": " << std::endl;
31034     {
31035         print_VkOffset2D(obj.maxSrcPosition, "maxSrcPosition", 1);
31036     }
31037 
31038     PRINT_SPACE
31039     _OUT << "\"minSrcExtent\": " << std::endl;
31040     {
31041         print_VkExtent2D(obj.minSrcExtent, "minSrcExtent", 1);
31042     }
31043 
31044     PRINT_SPACE
31045     _OUT << "\"maxSrcExtent\": " << std::endl;
31046     {
31047         print_VkExtent2D(obj.maxSrcExtent, "maxSrcExtent", 1);
31048     }
31049 
31050     PRINT_SPACE
31051     _OUT << "\"minDstPosition\": " << std::endl;
31052     {
31053         print_VkOffset2D(obj.minDstPosition, "minDstPosition", 1);
31054     }
31055 
31056     PRINT_SPACE
31057     _OUT << "\"maxDstPosition\": " << std::endl;
31058     {
31059         print_VkOffset2D(obj.maxDstPosition, "maxDstPosition", 1);
31060     }
31061 
31062     PRINT_SPACE
31063     _OUT << "\"minDstExtent\": " << std::endl;
31064     {
31065         print_VkExtent2D(obj.minDstExtent, "minDstExtent", 1);
31066     }
31067 
31068     PRINT_SPACE
31069     _OUT << "\"maxDstExtent\": " << std::endl;
31070     {
31071         print_VkExtent2D(obj.maxDstExtent, "maxDstExtent", 0);
31072     }
31073 
31074     INDENT(-4);
31075     PRINT_SPACE
31076     if (commaNeeded)
31077         _OUT << "}," << std::endl;
31078     else
31079         _OUT << "}" << std::endl;
31080 }
print_VkDisplayPlaneCapabilitiesKHR(const VkDisplayPlaneCapabilitiesKHR * obj,const std::string & s,bool commaNeeded=true)31081 static void print_VkDisplayPlaneCapabilitiesKHR(const VkDisplayPlaneCapabilitiesKHR *obj, const std::string &s,
31082                                                 bool commaNeeded = true)
31083 {
31084     PRINT_SPACE
31085     _OUT << "{" << std::endl;
31086     INDENT(4);
31087 
31088     print_VkDisplayPlaneAlphaFlagsKHR(obj->supportedAlpha, "supportedAlpha", 1);
31089 
31090     PRINT_SPACE
31091     _OUT << "\"minSrcPosition\": " << std::endl;
31092     {
31093         print_VkOffset2D(obj->minSrcPosition, "minSrcPosition", 1);
31094     }
31095 
31096     PRINT_SPACE
31097     _OUT << "\"maxSrcPosition\": " << std::endl;
31098     {
31099         print_VkOffset2D(obj->maxSrcPosition, "maxSrcPosition", 1);
31100     }
31101 
31102     PRINT_SPACE
31103     _OUT << "\"minSrcExtent\": " << std::endl;
31104     {
31105         print_VkExtent2D(obj->minSrcExtent, "minSrcExtent", 1);
31106     }
31107 
31108     PRINT_SPACE
31109     _OUT << "\"maxSrcExtent\": " << std::endl;
31110     {
31111         print_VkExtent2D(obj->maxSrcExtent, "maxSrcExtent", 1);
31112     }
31113 
31114     PRINT_SPACE
31115     _OUT << "\"minDstPosition\": " << std::endl;
31116     {
31117         print_VkOffset2D(obj->minDstPosition, "minDstPosition", 1);
31118     }
31119 
31120     PRINT_SPACE
31121     _OUT << "\"maxDstPosition\": " << std::endl;
31122     {
31123         print_VkOffset2D(obj->maxDstPosition, "maxDstPosition", 1);
31124     }
31125 
31126     PRINT_SPACE
31127     _OUT << "\"minDstExtent\": " << std::endl;
31128     {
31129         print_VkExtent2D(obj->minDstExtent, "minDstExtent", 1);
31130     }
31131 
31132     PRINT_SPACE
31133     _OUT << "\"maxDstExtent\": " << std::endl;
31134     {
31135         print_VkExtent2D(obj->maxDstExtent, "maxDstExtent", 0);
31136     }
31137 
31138     INDENT(-4);
31139     PRINT_SPACE
31140     if (commaNeeded)
31141         _OUT << "}," << std::endl;
31142     else
31143         _OUT << "}" << std::endl;
31144 }
31145 
print_VkDisplayPlanePropertiesKHR(VkDisplayPlanePropertiesKHR obj,const std::string & s,bool commaNeeded=true)31146 static void print_VkDisplayPlanePropertiesKHR(VkDisplayPlanePropertiesKHR obj, const std::string &s,
31147                                               bool commaNeeded = true)
31148 {
31149     PRINT_SPACE
31150     _OUT << "{" << std::endl;
31151     INDENT(4);
31152 
31153     // CTS : required value
31154     PRINT_SPACE _OUT << "\""
31155                      << "currentDisplay"
31156                      << "\""
31157                      << " : "
31158                      << "\""
31159                      << "\"," << std::endl;
31160 
31161     print_uint32_t(obj.currentStackIndex, "currentStackIndex", 0);
31162 
31163     INDENT(-4);
31164     PRINT_SPACE
31165     if (commaNeeded)
31166         _OUT << "}," << std::endl;
31167     else
31168         _OUT << "}" << std::endl;
31169 }
print_VkDisplayPlanePropertiesKHR(const VkDisplayPlanePropertiesKHR * obj,const std::string & s,bool commaNeeded=true)31170 static void print_VkDisplayPlanePropertiesKHR(const VkDisplayPlanePropertiesKHR *obj, const std::string &s,
31171                                               bool commaNeeded = true)
31172 {
31173     PRINT_SPACE
31174     _OUT << "{" << std::endl;
31175     INDENT(4);
31176 
31177     // CTS : required value
31178     PRINT_SPACE _OUT << "\""
31179                      << "currentDisplay"
31180                      << "\""
31181                      << " : "
31182                      << "\""
31183                      << "\"," << std::endl;
31184 
31185     print_uint32_t(obj->currentStackIndex, "currentStackIndex", 0);
31186 
31187     INDENT(-4);
31188     PRINT_SPACE
31189     if (commaNeeded)
31190         _OUT << "}," << std::endl;
31191     else
31192         _OUT << "}" << std::endl;
31193 }
31194 
print_VkDisplayPropertiesKHR(VkDisplayPropertiesKHR obj,const std::string & s,bool commaNeeded=true)31195 static void print_VkDisplayPropertiesKHR(VkDisplayPropertiesKHR obj, const std::string &s, bool commaNeeded = true)
31196 {
31197     PRINT_SPACE
31198     _OUT << "{" << std::endl;
31199     INDENT(4);
31200 
31201     // CTS : required value
31202     PRINT_SPACE _OUT << "\""
31203                      << "display"
31204                      << "\""
31205                      << " : "
31206                      << "\""
31207                      << "\"," << std::endl;
31208 
31209     print_char(obj.displayName, "displayName", 1);
31210 
31211     PRINT_SPACE
31212     _OUT << "\"physicalDimensions\": " << std::endl;
31213     {
31214         print_VkExtent2D(obj.physicalDimensions, "physicalDimensions", 1);
31215     }
31216 
31217     PRINT_SPACE
31218     _OUT << "\"physicalResolution\": " << std::endl;
31219     {
31220         print_VkExtent2D(obj.physicalResolution, "physicalResolution", 1);
31221     }
31222 
31223     print_VkSurfaceTransformFlagsKHR(obj.supportedTransforms, "supportedTransforms", 1);
31224 
31225     print_VkBool32(obj.planeReorderPossible, "planeReorderPossible", 1);
31226 
31227     print_VkBool32(obj.persistentContent, "persistentContent", 0);
31228 
31229     INDENT(-4);
31230     PRINT_SPACE
31231     if (commaNeeded)
31232         _OUT << "}," << std::endl;
31233     else
31234         _OUT << "}" << std::endl;
31235 }
print_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR * obj,const std::string & s,bool commaNeeded=true)31236 static void print_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR *obj, const std::string &s,
31237                                          bool commaNeeded = true)
31238 {
31239     PRINT_SPACE
31240     _OUT << "{" << std::endl;
31241     INDENT(4);
31242 
31243     // CTS : required value
31244     PRINT_SPACE _OUT << "\""
31245                      << "display"
31246                      << "\""
31247                      << " : "
31248                      << "\""
31249                      << "\"," << std::endl;
31250 
31251     print_char(obj->displayName, "displayName", 1);
31252 
31253     PRINT_SPACE
31254     _OUT << "\"physicalDimensions\": " << std::endl;
31255     {
31256         print_VkExtent2D(obj->physicalDimensions, "physicalDimensions", 1);
31257     }
31258 
31259     PRINT_SPACE
31260     _OUT << "\"physicalResolution\": " << std::endl;
31261     {
31262         print_VkExtent2D(obj->physicalResolution, "physicalResolution", 1);
31263     }
31264 
31265     print_VkSurfaceTransformFlagsKHR(obj->supportedTransforms, "supportedTransforms", 1);
31266 
31267     print_VkBool32(obj->planeReorderPossible, "planeReorderPossible", 1);
31268 
31269     print_VkBool32(obj->persistentContent, "persistentContent", 0);
31270 
31271     INDENT(-4);
31272     PRINT_SPACE
31273     if (commaNeeded)
31274         _OUT << "}," << std::endl;
31275     else
31276         _OUT << "}" << std::endl;
31277 }
31278 
print_VkDisplaySurfaceCreateInfoKHR(VkDisplaySurfaceCreateInfoKHR obj,const std::string & s,bool commaNeeded=true)31279 static void print_VkDisplaySurfaceCreateInfoKHR(VkDisplaySurfaceCreateInfoKHR obj, const std::string &s,
31280                                                 bool commaNeeded = true)
31281 {
31282     PRINT_SPACE
31283     _OUT << "{" << std::endl;
31284     INDENT(4);
31285 
31286     print_VkStructureType(obj.sType, "sType", 1);
31287 
31288     if (obj.pNext)
31289     {
31290         dumpPNextChain(obj.pNext);
31291     }
31292     else
31293     {
31294         PRINT_SPACE
31295         _OUT << "\"pNext\":"
31296              << "\"NULL\""
31297              << "," << std::endl;
31298     }
31299 
31300     print_VkDisplaySurfaceCreateFlagsKHR(obj.flags, "flags", 1);
31301 
31302     // CTS : required value
31303     PRINT_SPACE _OUT << "\""
31304                      << "displayMode"
31305                      << "\""
31306                      << " : "
31307                      << "\""
31308                      << "\"," << std::endl;
31309 
31310     print_uint32_t(obj.planeIndex, "planeIndex", 1);
31311 
31312     print_uint32_t(obj.planeStackIndex, "planeStackIndex", 1);
31313 
31314     print_VkSurfaceTransformFlagBitsKHR(obj.transform, "transform", 1);
31315 
31316     print_float(obj.globalAlpha, "globalAlpha", 1);
31317 
31318     print_VkDisplayPlaneAlphaFlagBitsKHR(obj.alphaMode, "alphaMode", 1);
31319 
31320     PRINT_SPACE
31321     _OUT << "\"imageExtent\": " << std::endl;
31322     {
31323         print_VkExtent2D(obj.imageExtent, "imageExtent", 0);
31324     }
31325 
31326     INDENT(-4);
31327     PRINT_SPACE
31328     if (commaNeeded)
31329         _OUT << "}," << std::endl;
31330     else
31331         _OUT << "}" << std::endl;
31332 }
print_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR * obj,const std::string & s,bool commaNeeded=true)31333 static void print_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR *obj, const std::string &s,
31334                                                 bool commaNeeded = true)
31335 {
31336     PRINT_SPACE
31337     _OUT << "{" << std::endl;
31338     INDENT(4);
31339 
31340     print_VkStructureType(obj->sType, "sType", 1);
31341 
31342     if (obj->pNext)
31343     {
31344         dumpPNextChain(obj->pNext);
31345     }
31346     else
31347     {
31348         PRINT_SPACE
31349         _OUT << "\"pNext\":"
31350              << "\"NULL\""
31351              << "," << std::endl;
31352     }
31353 
31354     print_VkDisplaySurfaceCreateFlagsKHR(obj->flags, "flags", 1);
31355 
31356     // CTS : required value
31357     PRINT_SPACE _OUT << "\""
31358                      << "displayMode"
31359                      << "\""
31360                      << " : "
31361                      << "\""
31362                      << "\"," << std::endl;
31363 
31364     print_uint32_t(obj->planeIndex, "planeIndex", 1);
31365 
31366     print_uint32_t(obj->planeStackIndex, "planeStackIndex", 1);
31367 
31368     print_VkSurfaceTransformFlagBitsKHR(obj->transform, "transform", 1);
31369 
31370     print_float(obj->globalAlpha, "globalAlpha", 1);
31371 
31372     print_VkDisplayPlaneAlphaFlagBitsKHR(obj->alphaMode, "alphaMode", 1);
31373 
31374     PRINT_SPACE
31375     _OUT << "\"imageExtent\": " << std::endl;
31376     {
31377         print_VkExtent2D(obj->imageExtent, "imageExtent", 0);
31378     }
31379 
31380     INDENT(-4);
31381     PRINT_SPACE
31382     if (commaNeeded)
31383         _OUT << "}," << std::endl;
31384     else
31385         _OUT << "}" << std::endl;
31386 }
31387 
print_VkDisplayPresentInfoKHR(VkDisplayPresentInfoKHR obj,const std::string & s,bool commaNeeded=true)31388 static void print_VkDisplayPresentInfoKHR(VkDisplayPresentInfoKHR obj, const std::string &s, bool commaNeeded = true)
31389 {
31390     PRINT_SPACE
31391     _OUT << "{" << std::endl;
31392     INDENT(4);
31393 
31394     print_VkStructureType(obj.sType, "sType", 1);
31395 
31396     if (obj.pNext)
31397     {
31398         dumpPNextChain(obj.pNext);
31399     }
31400     else
31401     {
31402         PRINT_SPACE
31403         _OUT << "\"pNext\":"
31404              << "\"NULL\""
31405              << "," << std::endl;
31406     }
31407 
31408     PRINT_SPACE
31409     _OUT << "\"srcRect\": " << std::endl;
31410     {
31411         print_VkRect2D(obj.srcRect, "srcRect", 1);
31412     }
31413 
31414     PRINT_SPACE
31415     _OUT << "\"dstRect\": " << std::endl;
31416     {
31417         print_VkRect2D(obj.dstRect, "dstRect", 1);
31418     }
31419 
31420     print_VkBool32(obj.persistent, "persistent", 0);
31421 
31422     INDENT(-4);
31423     PRINT_SPACE
31424     if (commaNeeded)
31425         _OUT << "}," << std::endl;
31426     else
31427         _OUT << "}" << std::endl;
31428 }
print_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR * obj,const std::string & s,bool commaNeeded=true)31429 static void print_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR *obj, const std::string &s,
31430                                           bool commaNeeded = true)
31431 {
31432     PRINT_SPACE
31433     _OUT << "{" << std::endl;
31434     INDENT(4);
31435 
31436     print_VkStructureType(obj->sType, "sType", 1);
31437 
31438     if (obj->pNext)
31439     {
31440         dumpPNextChain(obj->pNext);
31441     }
31442     else
31443     {
31444         PRINT_SPACE
31445         _OUT << "\"pNext\":"
31446              << "\"NULL\""
31447              << "," << std::endl;
31448     }
31449 
31450     PRINT_SPACE
31451     _OUT << "\"srcRect\": " << std::endl;
31452     {
31453         print_VkRect2D(obj->srcRect, "srcRect", 1);
31454     }
31455 
31456     PRINT_SPACE
31457     _OUT << "\"dstRect\": " << std::endl;
31458     {
31459         print_VkRect2D(obj->dstRect, "dstRect", 1);
31460     }
31461 
31462     print_VkBool32(obj->persistent, "persistent", 0);
31463 
31464     INDENT(-4);
31465     PRINT_SPACE
31466     if (commaNeeded)
31467         _OUT << "}," << std::endl;
31468     else
31469         _OUT << "}" << std::endl;
31470 }
31471 
print_VkImportMemoryFdInfoKHR(VkImportMemoryFdInfoKHR obj,const std::string & s,bool commaNeeded=true)31472 static void print_VkImportMemoryFdInfoKHR(VkImportMemoryFdInfoKHR obj, const std::string &s, bool commaNeeded = true)
31473 {
31474     PRINT_SPACE
31475     _OUT << "{" << std::endl;
31476     INDENT(4);
31477 
31478     print_VkStructureType(obj.sType, "sType", 1);
31479 
31480     if (obj.pNext)
31481     {
31482         dumpPNextChain(obj.pNext);
31483     }
31484     else
31485     {
31486         PRINT_SPACE
31487         _OUT << "\"pNext\":"
31488              << "\"NULL\""
31489              << "," << std::endl;
31490     }
31491 
31492     print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 1);
31493 
31494     print_int(obj.fd, "fd", 0);
31495 
31496     INDENT(-4);
31497     PRINT_SPACE
31498     if (commaNeeded)
31499         _OUT << "}," << std::endl;
31500     else
31501         _OUT << "}" << std::endl;
31502 }
print_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR * obj,const std::string & s,bool commaNeeded=true)31503 static void print_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR *obj, const std::string &s,
31504                                           bool commaNeeded = true)
31505 {
31506     PRINT_SPACE
31507     _OUT << "{" << std::endl;
31508     INDENT(4);
31509 
31510     print_VkStructureType(obj->sType, "sType", 1);
31511 
31512     if (obj->pNext)
31513     {
31514         dumpPNextChain(obj->pNext);
31515     }
31516     else
31517     {
31518         PRINT_SPACE
31519         _OUT << "\"pNext\":"
31520              << "\"NULL\""
31521              << "," << std::endl;
31522     }
31523 
31524     print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 1);
31525 
31526     print_int(obj->fd, "fd", 0);
31527 
31528     INDENT(-4);
31529     PRINT_SPACE
31530     if (commaNeeded)
31531         _OUT << "}," << std::endl;
31532     else
31533         _OUT << "}" << std::endl;
31534 }
31535 
print_VkMemoryFdPropertiesKHR(VkMemoryFdPropertiesKHR obj,const std::string & s,bool commaNeeded=true)31536 static void print_VkMemoryFdPropertiesKHR(VkMemoryFdPropertiesKHR obj, const std::string &s, bool commaNeeded = true)
31537 {
31538     PRINT_SPACE
31539     _OUT << "{" << std::endl;
31540     INDENT(4);
31541 
31542     print_VkStructureType(obj.sType, "sType", 1);
31543 
31544     if (obj.pNext)
31545     {
31546         dumpPNextChain(obj.pNext);
31547     }
31548     else
31549     {
31550         PRINT_SPACE
31551         _OUT << "\"pNext\":"
31552              << "\"NULL\""
31553              << "," << std::endl;
31554     }
31555 
31556     print_uint32_t(obj.memoryTypeBits, "memoryTypeBits", 0);
31557 
31558     INDENT(-4);
31559     PRINT_SPACE
31560     if (commaNeeded)
31561         _OUT << "}," << std::endl;
31562     else
31563         _OUT << "}" << std::endl;
31564 }
print_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR * obj,const std::string & s,bool commaNeeded=true)31565 static void print_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR *obj, const std::string &s,
31566                                           bool commaNeeded = true)
31567 {
31568     PRINT_SPACE
31569     _OUT << "{" << std::endl;
31570     INDENT(4);
31571 
31572     print_VkStructureType(obj->sType, "sType", 1);
31573 
31574     if (obj->pNext)
31575     {
31576         dumpPNextChain(obj->pNext);
31577     }
31578     else
31579     {
31580         PRINT_SPACE
31581         _OUT << "\"pNext\":"
31582              << "\"NULL\""
31583              << "," << std::endl;
31584     }
31585 
31586     print_uint32_t(obj->memoryTypeBits, "memoryTypeBits", 0);
31587 
31588     INDENT(-4);
31589     PRINT_SPACE
31590     if (commaNeeded)
31591         _OUT << "}," << std::endl;
31592     else
31593         _OUT << "}" << std::endl;
31594 }
31595 
print_VkMemoryGetFdInfoKHR(VkMemoryGetFdInfoKHR obj,const std::string & s,bool commaNeeded=true)31596 static void print_VkMemoryGetFdInfoKHR(VkMemoryGetFdInfoKHR obj, const std::string &s, bool commaNeeded = true)
31597 {
31598     PRINT_SPACE
31599     _OUT << "{" << std::endl;
31600     INDENT(4);
31601 
31602     print_VkStructureType(obj.sType, "sType", 1);
31603 
31604     if (obj.pNext)
31605     {
31606         dumpPNextChain(obj.pNext);
31607     }
31608     else
31609     {
31610         PRINT_SPACE
31611         _OUT << "\"pNext\":"
31612              << "\"NULL\""
31613              << "," << std::endl;
31614     }
31615 
31616     // CTS : required value
31617     PRINT_SPACE _OUT << "\""
31618                      << "memory"
31619                      << "\""
31620                      << " : "
31621                      << "\""
31622                      << "\"," << std::endl;
31623 
31624     print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 0);
31625 
31626     INDENT(-4);
31627     PRINT_SPACE
31628     if (commaNeeded)
31629         _OUT << "}," << std::endl;
31630     else
31631         _OUT << "}" << std::endl;
31632 }
print_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR * obj,const std::string & s,bool commaNeeded=true)31633 static void print_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR *obj, const std::string &s, bool commaNeeded = true)
31634 {
31635     PRINT_SPACE
31636     _OUT << "{" << std::endl;
31637     INDENT(4);
31638 
31639     print_VkStructureType(obj->sType, "sType", 1);
31640 
31641     if (obj->pNext)
31642     {
31643         dumpPNextChain(obj->pNext);
31644     }
31645     else
31646     {
31647         PRINT_SPACE
31648         _OUT << "\"pNext\":"
31649              << "\"NULL\""
31650              << "," << std::endl;
31651     }
31652 
31653     // CTS : required value
31654     PRINT_SPACE _OUT << "\""
31655                      << "memory"
31656                      << "\""
31657                      << " : "
31658                      << "\""
31659                      << "\"," << std::endl;
31660 
31661     print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 0);
31662 
31663     INDENT(-4);
31664     PRINT_SPACE
31665     if (commaNeeded)
31666         _OUT << "}," << std::endl;
31667     else
31668         _OUT << "}" << std::endl;
31669 }
31670 
print_VkImportSemaphoreFdInfoKHR(VkImportSemaphoreFdInfoKHR obj,const std::string & s,bool commaNeeded=true)31671 static void print_VkImportSemaphoreFdInfoKHR(VkImportSemaphoreFdInfoKHR obj, const std::string &s,
31672                                              bool commaNeeded = true)
31673 {
31674     PRINT_SPACE
31675     _OUT << "{" << std::endl;
31676     INDENT(4);
31677 
31678     print_VkStructureType(obj.sType, "sType", 1);
31679 
31680     if (obj.pNext)
31681     {
31682         dumpPNextChain(obj.pNext);
31683     }
31684     else
31685     {
31686         PRINT_SPACE
31687         _OUT << "\"pNext\":"
31688              << "\"NULL\""
31689              << "," << std::endl;
31690     }
31691 
31692     // CTS : required value
31693     PRINT_SPACE _OUT << "\""
31694                      << "semaphore"
31695                      << "\""
31696                      << " : "
31697                      << "\""
31698                      << "\"," << std::endl;
31699 
31700     print_VkSemaphoreImportFlags(obj.flags, "flags", 1);
31701 
31702     print_VkExternalSemaphoreHandleTypeFlagBits(obj.handleType, "handleType", 1);
31703 
31704     print_int(obj.fd, "fd", 0);
31705 
31706     INDENT(-4);
31707     PRINT_SPACE
31708     if (commaNeeded)
31709         _OUT << "}," << std::endl;
31710     else
31711         _OUT << "}" << std::endl;
31712 }
print_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR * obj,const std::string & s,bool commaNeeded=true)31713 static void print_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR *obj, const std::string &s,
31714                                              bool commaNeeded = true)
31715 {
31716     PRINT_SPACE
31717     _OUT << "{" << std::endl;
31718     INDENT(4);
31719 
31720     print_VkStructureType(obj->sType, "sType", 1);
31721 
31722     if (obj->pNext)
31723     {
31724         dumpPNextChain(obj->pNext);
31725     }
31726     else
31727     {
31728         PRINT_SPACE
31729         _OUT << "\"pNext\":"
31730              << "\"NULL\""
31731              << "," << std::endl;
31732     }
31733 
31734     // CTS : required value
31735     PRINT_SPACE _OUT << "\""
31736                      << "semaphore"
31737                      << "\""
31738                      << " : "
31739                      << "\""
31740                      << "\"," << std::endl;
31741 
31742     print_VkSemaphoreImportFlags(obj->flags, "flags", 1);
31743 
31744     print_VkExternalSemaphoreHandleTypeFlagBits(obj->handleType, "handleType", 1);
31745 
31746     print_int(obj->fd, "fd", 0);
31747 
31748     INDENT(-4);
31749     PRINT_SPACE
31750     if (commaNeeded)
31751         _OUT << "}," << std::endl;
31752     else
31753         _OUT << "}" << std::endl;
31754 }
31755 
print_VkSemaphoreGetFdInfoKHR(VkSemaphoreGetFdInfoKHR obj,const std::string & s,bool commaNeeded=true)31756 static void print_VkSemaphoreGetFdInfoKHR(VkSemaphoreGetFdInfoKHR obj, const std::string &s, bool commaNeeded = true)
31757 {
31758     PRINT_SPACE
31759     _OUT << "{" << std::endl;
31760     INDENT(4);
31761 
31762     print_VkStructureType(obj.sType, "sType", 1);
31763 
31764     if (obj.pNext)
31765     {
31766         dumpPNextChain(obj.pNext);
31767     }
31768     else
31769     {
31770         PRINT_SPACE
31771         _OUT << "\"pNext\":"
31772              << "\"NULL\""
31773              << "," << std::endl;
31774     }
31775 
31776     // CTS : required value
31777     PRINT_SPACE _OUT << "\""
31778                      << "semaphore"
31779                      << "\""
31780                      << " : "
31781                      << "\""
31782                      << "\"," << std::endl;
31783 
31784     print_VkExternalSemaphoreHandleTypeFlagBits(obj.handleType, "handleType", 0);
31785 
31786     INDENT(-4);
31787     PRINT_SPACE
31788     if (commaNeeded)
31789         _OUT << "}," << std::endl;
31790     else
31791         _OUT << "}" << std::endl;
31792 }
print_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR * obj,const std::string & s,bool commaNeeded=true)31793 static void print_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR *obj, const std::string &s,
31794                                           bool commaNeeded = true)
31795 {
31796     PRINT_SPACE
31797     _OUT << "{" << std::endl;
31798     INDENT(4);
31799 
31800     print_VkStructureType(obj->sType, "sType", 1);
31801 
31802     if (obj->pNext)
31803     {
31804         dumpPNextChain(obj->pNext);
31805     }
31806     else
31807     {
31808         PRINT_SPACE
31809         _OUT << "\"pNext\":"
31810              << "\"NULL\""
31811              << "," << std::endl;
31812     }
31813 
31814     // CTS : required value
31815     PRINT_SPACE _OUT << "\""
31816                      << "semaphore"
31817                      << "\""
31818                      << " : "
31819                      << "\""
31820                      << "\"," << std::endl;
31821 
31822     print_VkExternalSemaphoreHandleTypeFlagBits(obj->handleType, "handleType", 0);
31823 
31824     INDENT(-4);
31825     PRINT_SPACE
31826     if (commaNeeded)
31827         _OUT << "}," << std::endl;
31828     else
31829         _OUT << "}" << std::endl;
31830 }
31831 
print_VkRectLayerKHR(VkRectLayerKHR obj,const std::string & s,bool commaNeeded=true)31832 static void print_VkRectLayerKHR(VkRectLayerKHR obj, const std::string &s, bool commaNeeded = true)
31833 {
31834     PRINT_SPACE
31835     _OUT << "{" << std::endl;
31836     INDENT(4);
31837 
31838     PRINT_SPACE
31839     _OUT << "\"offset\": " << std::endl;
31840     {
31841         print_VkOffset2D(obj.offset, "offset", 1);
31842     }
31843 
31844     PRINT_SPACE
31845     _OUT << "\"extent\": " << std::endl;
31846     {
31847         print_VkExtent2D(obj.extent, "extent", 1);
31848     }
31849 
31850     print_uint32_t(obj.layer, "layer", 0);
31851 
31852     INDENT(-4);
31853     PRINT_SPACE
31854     if (commaNeeded)
31855         _OUT << "}," << std::endl;
31856     else
31857         _OUT << "}" << std::endl;
31858 }
print_VkRectLayerKHR(const VkRectLayerKHR * obj,const std::string & s,bool commaNeeded=true)31859 static void print_VkRectLayerKHR(const VkRectLayerKHR *obj, const std::string &s, bool commaNeeded = true)
31860 {
31861     PRINT_SPACE
31862     _OUT << "{" << std::endl;
31863     INDENT(4);
31864 
31865     PRINT_SPACE
31866     _OUT << "\"offset\": " << std::endl;
31867     {
31868         print_VkOffset2D(obj->offset, "offset", 1);
31869     }
31870 
31871     PRINT_SPACE
31872     _OUT << "\"extent\": " << std::endl;
31873     {
31874         print_VkExtent2D(obj->extent, "extent", 1);
31875     }
31876 
31877     print_uint32_t(obj->layer, "layer", 0);
31878 
31879     INDENT(-4);
31880     PRINT_SPACE
31881     if (commaNeeded)
31882         _OUT << "}," << std::endl;
31883     else
31884         _OUT << "}" << std::endl;
31885 }
31886 
print_VkPresentRegionKHR(VkPresentRegionKHR obj,const std::string & s,bool commaNeeded=true)31887 static void print_VkPresentRegionKHR(VkPresentRegionKHR obj, const std::string &s, bool commaNeeded = true)
31888 {
31889     PRINT_SPACE
31890     _OUT << "{" << std::endl;
31891     INDENT(4);
31892 
31893     print_uint32_t(obj.rectangleCount, "rectangleCount", 1);
31894 
31895     PRINT_SPACE
31896     _OUT << "\"pRectangles\": " << std::endl;
31897     if (obj.pRectangles)
31898     {
31899         PRINT_SPACE
31900         _OUT << "[" << std::endl;
31901         for (unsigned int i = 0; i < obj.rectangleCount; i++)
31902         {
31903             if (i + 1 == obj.rectangleCount)
31904                 print_VkRectLayerKHR(obj.pRectangles[i], "pRectangles", 0);
31905             else
31906                 print_VkRectLayerKHR(obj.pRectangles[i], "pRectangles", 1);
31907         }
31908         PRINT_SPACE
31909         _OUT << "]" << std::endl;
31910     }
31911     else
31912     {
31913         PRINT_SPACE _OUT << "\"NULL\""
31914                          << "" << std::endl;
31915     }
31916 
31917     INDENT(-4);
31918     PRINT_SPACE
31919     if (commaNeeded)
31920         _OUT << "}," << std::endl;
31921     else
31922         _OUT << "}" << std::endl;
31923 }
print_VkPresentRegionKHR(const VkPresentRegionKHR * obj,const std::string & s,bool commaNeeded=true)31924 static void print_VkPresentRegionKHR(const VkPresentRegionKHR *obj, const std::string &s, bool commaNeeded = true)
31925 {
31926     PRINT_SPACE
31927     _OUT << "{" << std::endl;
31928     INDENT(4);
31929 
31930     print_uint32_t(obj->rectangleCount, "rectangleCount", 1);
31931 
31932     PRINT_SPACE
31933     _OUT << "\"pRectangles\": " << std::endl;
31934     if (obj->pRectangles)
31935     {
31936         PRINT_SPACE
31937         _OUT << "[" << std::endl;
31938         for (unsigned int i = 0; i < obj->rectangleCount; i++)
31939         {
31940             if (i + 1 == obj->rectangleCount)
31941                 print_VkRectLayerKHR(obj->pRectangles[i], "pRectangles", 0);
31942             else
31943                 print_VkRectLayerKHR(obj->pRectangles[i], "pRectangles", 1);
31944         }
31945         PRINT_SPACE
31946         _OUT << "]" << std::endl;
31947     }
31948     else
31949     {
31950         PRINT_SPACE _OUT << "\"NULL\""
31951                          << "" << std::endl;
31952     }
31953 
31954     INDENT(-4);
31955     PRINT_SPACE
31956     if (commaNeeded)
31957         _OUT << "}," << std::endl;
31958     else
31959         _OUT << "}" << std::endl;
31960 }
31961 
print_VkPresentRegionsKHR(VkPresentRegionsKHR obj,const std::string & s,bool commaNeeded=true)31962 static void print_VkPresentRegionsKHR(VkPresentRegionsKHR obj, const std::string &s, bool commaNeeded = true)
31963 {
31964     PRINT_SPACE
31965     _OUT << "{" << std::endl;
31966     INDENT(4);
31967 
31968     print_VkStructureType(obj.sType, "sType", 1);
31969 
31970     if (obj.pNext)
31971     {
31972         dumpPNextChain(obj.pNext);
31973     }
31974     else
31975     {
31976         PRINT_SPACE
31977         _OUT << "\"pNext\":"
31978              << "\"NULL\""
31979              << "," << std::endl;
31980     }
31981 
31982     print_uint32_t(obj.swapchainCount, "swapchainCount", 1);
31983 
31984     PRINT_SPACE
31985     _OUT << "\"pRegions\": " << std::endl;
31986     if (obj.pRegions)
31987     {
31988         PRINT_SPACE
31989         _OUT << "[" << std::endl;
31990         for (unsigned int i = 0; i < obj.swapchainCount; i++)
31991         {
31992             if (i + 1 == obj.swapchainCount)
31993                 print_VkPresentRegionKHR(obj.pRegions[i], "pRegions", 0);
31994             else
31995                 print_VkPresentRegionKHR(obj.pRegions[i], "pRegions", 1);
31996         }
31997         PRINT_SPACE
31998         _OUT << "]" << std::endl;
31999     }
32000     else
32001     {
32002         PRINT_SPACE _OUT << "\"NULL\""
32003                          << "" << std::endl;
32004     }
32005 
32006     INDENT(-4);
32007     PRINT_SPACE
32008     if (commaNeeded)
32009         _OUT << "}," << std::endl;
32010     else
32011         _OUT << "}" << std::endl;
32012 }
print_VkPresentRegionsKHR(const VkPresentRegionsKHR * obj,const std::string & s,bool commaNeeded=true)32013 static void print_VkPresentRegionsKHR(const VkPresentRegionsKHR *obj, const std::string &s, bool commaNeeded = true)
32014 {
32015     PRINT_SPACE
32016     _OUT << "{" << std::endl;
32017     INDENT(4);
32018 
32019     print_VkStructureType(obj->sType, "sType", 1);
32020 
32021     if (obj->pNext)
32022     {
32023         dumpPNextChain(obj->pNext);
32024     }
32025     else
32026     {
32027         PRINT_SPACE
32028         _OUT << "\"pNext\":"
32029              << "\"NULL\""
32030              << "," << std::endl;
32031     }
32032 
32033     print_uint32_t(obj->swapchainCount, "swapchainCount", 1);
32034 
32035     PRINT_SPACE
32036     _OUT << "\"pRegions\": " << std::endl;
32037     if (obj->pRegions)
32038     {
32039         PRINT_SPACE
32040         _OUT << "[" << std::endl;
32041         for (unsigned int i = 0; i < obj->swapchainCount; i++)
32042         {
32043             if (i + 1 == obj->swapchainCount)
32044                 print_VkPresentRegionKHR(obj->pRegions[i], "pRegions", 0);
32045             else
32046                 print_VkPresentRegionKHR(obj->pRegions[i], "pRegions", 1);
32047         }
32048         PRINT_SPACE
32049         _OUT << "]" << std::endl;
32050     }
32051     else
32052     {
32053         PRINT_SPACE _OUT << "\"NULL\""
32054                          << "" << std::endl;
32055     }
32056 
32057     INDENT(-4);
32058     PRINT_SPACE
32059     if (commaNeeded)
32060         _OUT << "}," << std::endl;
32061     else
32062         _OUT << "}" << std::endl;
32063 }
32064 
print_VkSharedPresentSurfaceCapabilitiesKHR(VkSharedPresentSurfaceCapabilitiesKHR obj,const std::string & s,bool commaNeeded=true)32065 static void print_VkSharedPresentSurfaceCapabilitiesKHR(VkSharedPresentSurfaceCapabilitiesKHR obj, const std::string &s,
32066                                                         bool commaNeeded = true)
32067 {
32068     PRINT_SPACE
32069     _OUT << "{" << std::endl;
32070     INDENT(4);
32071 
32072     print_VkStructureType(obj.sType, "sType", 1);
32073 
32074     if (obj.pNext)
32075     {
32076         dumpPNextChain(obj.pNext);
32077     }
32078     else
32079     {
32080         PRINT_SPACE
32081         _OUT << "\"pNext\":"
32082              << "\"NULL\""
32083              << "," << std::endl;
32084     }
32085 
32086     print_VkImageUsageFlags(obj.sharedPresentSupportedUsageFlags, "sharedPresentSupportedUsageFlags", 0);
32087 
32088     INDENT(-4);
32089     PRINT_SPACE
32090     if (commaNeeded)
32091         _OUT << "}," << std::endl;
32092     else
32093         _OUT << "}" << std::endl;
32094 }
print_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR * obj,const std::string & s,bool commaNeeded=true)32095 static void print_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR *obj,
32096                                                         const std::string &s, bool commaNeeded = true)
32097 {
32098     PRINT_SPACE
32099     _OUT << "{" << std::endl;
32100     INDENT(4);
32101 
32102     print_VkStructureType(obj->sType, "sType", 1);
32103 
32104     if (obj->pNext)
32105     {
32106         dumpPNextChain(obj->pNext);
32107     }
32108     else
32109     {
32110         PRINT_SPACE
32111         _OUT << "\"pNext\":"
32112              << "\"NULL\""
32113              << "," << std::endl;
32114     }
32115 
32116     print_VkImageUsageFlags(obj->sharedPresentSupportedUsageFlags, "sharedPresentSupportedUsageFlags", 0);
32117 
32118     INDENT(-4);
32119     PRINT_SPACE
32120     if (commaNeeded)
32121         _OUT << "}," << std::endl;
32122     else
32123         _OUT << "}" << std::endl;
32124 }
32125 
print_VkImportFenceFdInfoKHR(VkImportFenceFdInfoKHR obj,const std::string & s,bool commaNeeded=true)32126 static void print_VkImportFenceFdInfoKHR(VkImportFenceFdInfoKHR obj, const std::string &s, bool commaNeeded = true)
32127 {
32128     PRINT_SPACE
32129     _OUT << "{" << std::endl;
32130     INDENT(4);
32131 
32132     print_VkStructureType(obj.sType, "sType", 1);
32133 
32134     if (obj.pNext)
32135     {
32136         dumpPNextChain(obj.pNext);
32137     }
32138     else
32139     {
32140         PRINT_SPACE
32141         _OUT << "\"pNext\":"
32142              << "\"NULL\""
32143              << "," << std::endl;
32144     }
32145 
32146     // CTS : required value
32147     PRINT_SPACE _OUT << "\""
32148                      << "fence"
32149                      << "\""
32150                      << " : "
32151                      << "\""
32152                      << "\"," << std::endl;
32153 
32154     print_VkFenceImportFlags(obj.flags, "flags", 1);
32155 
32156     print_VkExternalFenceHandleTypeFlagBits(obj.handleType, "handleType", 1);
32157 
32158     print_int(obj.fd, "fd", 0);
32159 
32160     INDENT(-4);
32161     PRINT_SPACE
32162     if (commaNeeded)
32163         _OUT << "}," << std::endl;
32164     else
32165         _OUT << "}" << std::endl;
32166 }
print_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR * obj,const std::string & s,bool commaNeeded=true)32167 static void print_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR *obj, const std::string &s,
32168                                          bool commaNeeded = true)
32169 {
32170     PRINT_SPACE
32171     _OUT << "{" << std::endl;
32172     INDENT(4);
32173 
32174     print_VkStructureType(obj->sType, "sType", 1);
32175 
32176     if (obj->pNext)
32177     {
32178         dumpPNextChain(obj->pNext);
32179     }
32180     else
32181     {
32182         PRINT_SPACE
32183         _OUT << "\"pNext\":"
32184              << "\"NULL\""
32185              << "," << std::endl;
32186     }
32187 
32188     // CTS : required value
32189     PRINT_SPACE _OUT << "\""
32190                      << "fence"
32191                      << "\""
32192                      << " : "
32193                      << "\""
32194                      << "\"," << std::endl;
32195 
32196     print_VkFenceImportFlags(obj->flags, "flags", 1);
32197 
32198     print_VkExternalFenceHandleTypeFlagBits(obj->handleType, "handleType", 1);
32199 
32200     print_int(obj->fd, "fd", 0);
32201 
32202     INDENT(-4);
32203     PRINT_SPACE
32204     if (commaNeeded)
32205         _OUT << "}," << std::endl;
32206     else
32207         _OUT << "}" << std::endl;
32208 }
32209 
print_VkFenceGetFdInfoKHR(VkFenceGetFdInfoKHR obj,const std::string & s,bool commaNeeded=true)32210 static void print_VkFenceGetFdInfoKHR(VkFenceGetFdInfoKHR obj, const std::string &s, bool commaNeeded = true)
32211 {
32212     PRINT_SPACE
32213     _OUT << "{" << std::endl;
32214     INDENT(4);
32215 
32216     print_VkStructureType(obj.sType, "sType", 1);
32217 
32218     if (obj.pNext)
32219     {
32220         dumpPNextChain(obj.pNext);
32221     }
32222     else
32223     {
32224         PRINT_SPACE
32225         _OUT << "\"pNext\":"
32226              << "\"NULL\""
32227              << "," << std::endl;
32228     }
32229 
32230     // CTS : required value
32231     PRINT_SPACE _OUT << "\""
32232                      << "fence"
32233                      << "\""
32234                      << " : "
32235                      << "\""
32236                      << "\"," << std::endl;
32237 
32238     print_VkExternalFenceHandleTypeFlagBits(obj.handleType, "handleType", 0);
32239 
32240     INDENT(-4);
32241     PRINT_SPACE
32242     if (commaNeeded)
32243         _OUT << "}," << std::endl;
32244     else
32245         _OUT << "}" << std::endl;
32246 }
print_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR * obj,const std::string & s,bool commaNeeded=true)32247 static void print_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR *obj, const std::string &s, bool commaNeeded = true)
32248 {
32249     PRINT_SPACE
32250     _OUT << "{" << std::endl;
32251     INDENT(4);
32252 
32253     print_VkStructureType(obj->sType, "sType", 1);
32254 
32255     if (obj->pNext)
32256     {
32257         dumpPNextChain(obj->pNext);
32258     }
32259     else
32260     {
32261         PRINT_SPACE
32262         _OUT << "\"pNext\":"
32263              << "\"NULL\""
32264              << "," << std::endl;
32265     }
32266 
32267     // CTS : required value
32268     PRINT_SPACE _OUT << "\""
32269                      << "fence"
32270                      << "\""
32271                      << " : "
32272                      << "\""
32273                      << "\"," << std::endl;
32274 
32275     print_VkExternalFenceHandleTypeFlagBits(obj->handleType, "handleType", 0);
32276 
32277     INDENT(-4);
32278     PRINT_SPACE
32279     if (commaNeeded)
32280         _OUT << "}," << std::endl;
32281     else
32282         _OUT << "}" << std::endl;
32283 }
32284 
32285 static std::map<uint64_t, std::string> VkPerformanceCounterUnitKHR_map = {
32286     std::make_pair(0, "VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR"),
32287     std::make_pair(1, "VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR"),
32288     std::make_pair(2, "VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR"),
32289     std::make_pair(3, "VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR"),
32290     std::make_pair(4, "VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR"),
32291     std::make_pair(5, "VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR"),
32292     std::make_pair(6, "VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR"),
32293     std::make_pair(7, "VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR"),
32294     std::make_pair(8, "VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR"),
32295     std::make_pair(9, "VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR"),
32296     std::make_pair(10, "VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR"),
32297 };
print_VkPerformanceCounterUnitKHR(VkPerformanceCounterUnitKHR obj,const std::string & str,bool commaNeeded=true)32298 static void print_VkPerformanceCounterUnitKHR(VkPerformanceCounterUnitKHR obj, const std::string &str,
32299                                               bool commaNeeded = true)
32300 {
32301     PRINT_SPACE
32302     if (str != "")
32303         _OUT << "\"" << str << "\""
32304              << " : ";
32305     if (commaNeeded)
32306         _OUT << "\"" << VkPerformanceCounterUnitKHR_map[obj] << "\"," << std::endl;
32307     else
32308         _OUT << "\"" << VkPerformanceCounterUnitKHR_map[obj] << "\"" << std::endl;
32309 }
print_VkPerformanceCounterUnitKHR(const VkPerformanceCounterUnitKHR * obj,const std::string & str,bool commaNeeded=true)32310 static void print_VkPerformanceCounterUnitKHR(const VkPerformanceCounterUnitKHR *obj, const std::string &str,
32311                                               bool commaNeeded = true)
32312 {
32313     PRINT_SPACE
32314     if (str != "")
32315         _OUT << "\"" << str << "\""
32316              << " : ";
32317     if (commaNeeded)
32318         _OUT << "\"" << VkPerformanceCounterUnitKHR_map[*obj] << "\"," << std::endl;
32319     else
32320         _OUT << "\"" << VkPerformanceCounterUnitKHR_map[*obj] << "\"" << std::endl;
32321 }
32322 
32323 static std::map<uint64_t, std::string> VkPerformanceCounterScopeKHR_map = {
32324     std::make_pair(0, "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR"),
32325     std::make_pair(1, "VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR"),
32326     std::make_pair(2, "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR"),
32327 };
print_VkPerformanceCounterScopeKHR(VkPerformanceCounterScopeKHR obj,const std::string & str,bool commaNeeded=true)32328 static void print_VkPerformanceCounterScopeKHR(VkPerformanceCounterScopeKHR obj, const std::string &str,
32329                                                bool commaNeeded = true)
32330 {
32331     PRINT_SPACE
32332     if (str != "")
32333         _OUT << "\"" << str << "\""
32334              << " : ";
32335     if (commaNeeded)
32336         _OUT << "\"" << VkPerformanceCounterScopeKHR_map[obj] << "\"," << std::endl;
32337     else
32338         _OUT << "\"" << VkPerformanceCounterScopeKHR_map[obj] << "\"" << std::endl;
32339 }
print_VkPerformanceCounterScopeKHR(const VkPerformanceCounterScopeKHR * obj,const std::string & str,bool commaNeeded=true)32340 static void print_VkPerformanceCounterScopeKHR(const VkPerformanceCounterScopeKHR *obj, const std::string &str,
32341                                                bool commaNeeded = true)
32342 {
32343     PRINT_SPACE
32344     if (str != "")
32345         _OUT << "\"" << str << "\""
32346              << " : ";
32347     if (commaNeeded)
32348         _OUT << "\"" << VkPerformanceCounterScopeKHR_map[*obj] << "\"," << std::endl;
32349     else
32350         _OUT << "\"" << VkPerformanceCounterScopeKHR_map[*obj] << "\"" << std::endl;
32351 }
32352 
32353 static std::map<uint64_t, std::string> VkPerformanceCounterStorageKHR_map = {
32354     std::make_pair(0, "VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR"),
32355     std::make_pair(1, "VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR"),
32356     std::make_pair(2, "VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR"),
32357     std::make_pair(3, "VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR"),
32358     std::make_pair(4, "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR"),
32359     std::make_pair(5, "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR"),
32360 };
print_VkPerformanceCounterStorageKHR(VkPerformanceCounterStorageKHR obj,const std::string & str,bool commaNeeded=true)32361 static void print_VkPerformanceCounterStorageKHR(VkPerformanceCounterStorageKHR obj, const std::string &str,
32362                                                  bool commaNeeded = true)
32363 {
32364     PRINT_SPACE
32365     if (str != "")
32366         _OUT << "\"" << str << "\""
32367              << " : ";
32368     if (commaNeeded)
32369         _OUT << "\"" << VkPerformanceCounterStorageKHR_map[obj] << "\"," << std::endl;
32370     else
32371         _OUT << "\"" << VkPerformanceCounterStorageKHR_map[obj] << "\"" << std::endl;
32372 }
print_VkPerformanceCounterStorageKHR(const VkPerformanceCounterStorageKHR * obj,const std::string & str,bool commaNeeded=true)32373 static void print_VkPerformanceCounterStorageKHR(const VkPerformanceCounterStorageKHR *obj, const std::string &str,
32374                                                  bool commaNeeded = true)
32375 {
32376     PRINT_SPACE
32377     if (str != "")
32378         _OUT << "\"" << str << "\""
32379              << " : ";
32380     if (commaNeeded)
32381         _OUT << "\"" << VkPerformanceCounterStorageKHR_map[*obj] << "\"," << std::endl;
32382     else
32383         _OUT << "\"" << VkPerformanceCounterStorageKHR_map[*obj] << "\"" << std::endl;
32384 }
32385 
32386 static std::map<uint64_t, std::string> VkPerformanceCounterDescriptionFlagBitsKHR_map = {
32387     std::make_pair(1ULL << 0, "VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR"),
32388     std::make_pair(1ULL << 1, "VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR"),
32389 };
print_VkPerformanceCounterDescriptionFlagBitsKHR(VkPerformanceCounterDescriptionFlagBitsKHR obj,const std::string & str,bool commaNeeded=true)32390 static void print_VkPerformanceCounterDescriptionFlagBitsKHR(VkPerformanceCounterDescriptionFlagBitsKHR obj,
32391                                                              const std::string &str, bool commaNeeded = true)
32392 {
32393     PRINT_SPACE
32394     if (str != "")
32395         _OUT << "\"" << str << "\""
32396              << " : ";
32397     if (commaNeeded)
32398         _OUT << "\"" << VkPerformanceCounterDescriptionFlagBitsKHR_map[obj] << "\"," << std::endl;
32399     else
32400         _OUT << "\"" << VkPerformanceCounterDescriptionFlagBitsKHR_map[obj] << "\"" << std::endl;
32401 }
print_VkPerformanceCounterDescriptionFlagBitsKHR(const VkPerformanceCounterDescriptionFlagBitsKHR * obj,const std::string & str,bool commaNeeded=true)32402 static void print_VkPerformanceCounterDescriptionFlagBitsKHR(const VkPerformanceCounterDescriptionFlagBitsKHR *obj,
32403                                                              const std::string &str, bool commaNeeded = true)
32404 {
32405     PRINT_SPACE
32406     if (str != "")
32407         _OUT << "\"" << str << "\""
32408              << " : ";
32409     if (commaNeeded)
32410         _OUT << "\"" << VkPerformanceCounterDescriptionFlagBitsKHR_map[*obj] << "\"," << std::endl;
32411     else
32412         _OUT << "\"" << VkPerformanceCounterDescriptionFlagBitsKHR_map[*obj] << "\"" << std::endl;
32413 }
32414 
32415 static std::map<uint64_t, std::string> VkAcquireProfilingLockFlagBitsKHR_map = {};
print_VkAcquireProfilingLockFlagBitsKHR(VkAcquireProfilingLockFlagBitsKHR obj,const std::string & str,bool commaNeeded=true)32416 static void print_VkAcquireProfilingLockFlagBitsKHR(VkAcquireProfilingLockFlagBitsKHR obj, const std::string &str,
32417                                                     bool commaNeeded = true)
32418 {
32419     PRINT_SPACE
32420     if (str != "")
32421         _OUT << "\"" << str << "\""
32422              << " : ";
32423     if (commaNeeded)
32424         _OUT << "\"" << VkAcquireProfilingLockFlagBitsKHR_map[obj] << "\"," << std::endl;
32425     else
32426         _OUT << "\"" << VkAcquireProfilingLockFlagBitsKHR_map[obj] << "\"" << std::endl;
32427 }
print_VkAcquireProfilingLockFlagBitsKHR(const VkAcquireProfilingLockFlagBitsKHR * obj,const std::string & str,bool commaNeeded=true)32428 static void print_VkAcquireProfilingLockFlagBitsKHR(const VkAcquireProfilingLockFlagBitsKHR *obj,
32429                                                     const std::string &str, bool commaNeeded = true)
32430 {
32431     PRINT_SPACE
32432     if (str != "")
32433         _OUT << "\"" << str << "\""
32434              << " : ";
32435     if (commaNeeded)
32436         _OUT << "\"" << VkAcquireProfilingLockFlagBitsKHR_map[*obj] << "\"," << std::endl;
32437     else
32438         _OUT << "\"" << VkAcquireProfilingLockFlagBitsKHR_map[*obj] << "\"" << std::endl;
32439 }
32440 
print_VkPerformanceCounterDescriptionFlagsKHR(VkPerformanceCounterDescriptionFlagsKHR obj,const std::string & str,bool commaNeeded=true)32441 static void print_VkPerformanceCounterDescriptionFlagsKHR(VkPerformanceCounterDescriptionFlagsKHR obj,
32442                                                           const std::string &str, bool commaNeeded = true)
32443 {
32444     PRINT_SPACE
32445     if (str != "")
32446         _OUT << "\"" << str << "\""
32447              << " : ";
32448     const int max_bits = 64; // We don't expect the number to be larger.
32449     std::bitset<max_bits> b(obj);
32450     _OUT << "\"";
32451     if (obj == 0)
32452         _OUT << "0";
32453     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
32454     {
32455         if (b[i] == 1)
32456         {
32457             bitCount++;
32458             if (bitCount < b.count())
32459                 _OUT << VkPerformanceCounterDescriptionFlagBitsKHR_map[1ULL << i] << " | ";
32460             else
32461                 _OUT << VkPerformanceCounterDescriptionFlagBitsKHR_map[1ULL << i];
32462         }
32463     }
32464     if (commaNeeded)
32465         _OUT << "\""
32466              << ",";
32467     else
32468         _OUT << "\""
32469              << "";
32470     _OUT << std::endl;
32471 }
print_VkPerformanceCounterDescriptionFlagsKHR(const VkPerformanceCounterDescriptionFlagsKHR * obj,const std::string & str,bool commaNeeded=true)32472 static void print_VkPerformanceCounterDescriptionFlagsKHR(const VkPerformanceCounterDescriptionFlagsKHR *obj,
32473                                                           const std::string &str, bool commaNeeded = true)
32474 {
32475     PRINT_SPACE
32476     if (str != "")
32477         _OUT << "\"" << str << "\""
32478              << " : ";
32479     const int max_bits = 64; // We don't expect the number to be larger.
32480     std::bitset<max_bits> b(obj);
32481     _OUT << "\"";
32482     if (obj == 0)
32483         _OUT << "0";
32484     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
32485     {
32486         if (b[i] == 1)
32487         {
32488             bitCount++;
32489             if (bitCount < b.count())
32490                 _OUT << VkPerformanceCounterDescriptionFlagBitsKHR_map[1ULL << i] << " | ";
32491             else
32492                 _OUT << VkPerformanceCounterDescriptionFlagBitsKHR_map[1ULL << i];
32493         }
32494     }
32495     if (commaNeeded)
32496         _OUT << "\""
32497              << ",";
32498     else
32499         _OUT << "\""
32500              << "";
32501     _OUT << std::endl;
32502 }
32503 
print_VkAcquireProfilingLockFlagsKHR(VkAcquireProfilingLockFlagsKHR obj,const std::string & str,bool commaNeeded=true)32504 static void print_VkAcquireProfilingLockFlagsKHR(VkAcquireProfilingLockFlagsKHR obj, const std::string &str,
32505                                                  bool commaNeeded = true)
32506 {
32507     PRINT_SPACE
32508     if (str != "")
32509         _OUT << "\"" << str << "\""
32510              << " : ";
32511     const int max_bits = 64; // We don't expect the number to be larger.
32512     std::bitset<max_bits> b(obj);
32513     _OUT << "\"";
32514     if (obj == 0)
32515         _OUT << "0";
32516     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
32517     {
32518         if (b[i] == 1)
32519         {
32520             bitCount++;
32521             if (bitCount < b.count())
32522                 _OUT << VkAcquireProfilingLockFlagBitsKHR_map[1ULL << i] << " | ";
32523             else
32524                 _OUT << VkAcquireProfilingLockFlagBitsKHR_map[1ULL << i];
32525         }
32526     }
32527     if (commaNeeded)
32528         _OUT << "\""
32529              << ",";
32530     else
32531         _OUT << "\""
32532              << "";
32533     _OUT << std::endl;
32534 }
print_VkAcquireProfilingLockFlagsKHR(const VkAcquireProfilingLockFlagsKHR * obj,const std::string & str,bool commaNeeded=true)32535 static void print_VkAcquireProfilingLockFlagsKHR(const VkAcquireProfilingLockFlagsKHR *obj, const std::string &str,
32536                                                  bool commaNeeded = true)
32537 {
32538     PRINT_SPACE
32539     if (str != "")
32540         _OUT << "\"" << str << "\""
32541              << " : ";
32542     const int max_bits = 64; // We don't expect the number to be larger.
32543     std::bitset<max_bits> b(obj);
32544     _OUT << "\"";
32545     if (obj == 0)
32546         _OUT << "0";
32547     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
32548     {
32549         if (b[i] == 1)
32550         {
32551             bitCount++;
32552             if (bitCount < b.count())
32553                 _OUT << VkAcquireProfilingLockFlagBitsKHR_map[1ULL << i] << " | ";
32554             else
32555                 _OUT << VkAcquireProfilingLockFlagBitsKHR_map[1ULL << i];
32556         }
32557     }
32558     if (commaNeeded)
32559         _OUT << "\""
32560              << ",";
32561     else
32562         _OUT << "\""
32563              << "";
32564     _OUT << std::endl;
32565 }
32566 
print_VkPhysicalDevicePerformanceQueryFeaturesKHR(VkPhysicalDevicePerformanceQueryFeaturesKHR obj,const std::string & s,bool commaNeeded=true)32567 static void print_VkPhysicalDevicePerformanceQueryFeaturesKHR(VkPhysicalDevicePerformanceQueryFeaturesKHR obj,
32568                                                               const std::string &s, bool commaNeeded = true)
32569 {
32570     PRINT_SPACE
32571     _OUT << "{" << std::endl;
32572     INDENT(4);
32573 
32574     print_VkStructureType(obj.sType, "sType", 1);
32575 
32576     if (obj.pNext)
32577     {
32578         dumpPNextChain(obj.pNext);
32579     }
32580     else
32581     {
32582         PRINT_SPACE
32583         _OUT << "\"pNext\":"
32584              << "\"NULL\""
32585              << "," << std::endl;
32586     }
32587 
32588     print_VkBool32(obj.performanceCounterQueryPools, "performanceCounterQueryPools", 1);
32589 
32590     print_VkBool32(obj.performanceCounterMultipleQueryPools, "performanceCounterMultipleQueryPools", 0);
32591 
32592     INDENT(-4);
32593     PRINT_SPACE
32594     if (commaNeeded)
32595         _OUT << "}," << std::endl;
32596     else
32597         _OUT << "}" << std::endl;
32598 }
print_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR * obj,const std::string & s,bool commaNeeded=true)32599 static void print_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR *obj,
32600                                                               const std::string &s, bool commaNeeded = true)
32601 {
32602     PRINT_SPACE
32603     _OUT << "{" << std::endl;
32604     INDENT(4);
32605 
32606     print_VkStructureType(obj->sType, "sType", 1);
32607 
32608     if (obj->pNext)
32609     {
32610         dumpPNextChain(obj->pNext);
32611     }
32612     else
32613     {
32614         PRINT_SPACE
32615         _OUT << "\"pNext\":"
32616              << "\"NULL\""
32617              << "," << std::endl;
32618     }
32619 
32620     print_VkBool32(obj->performanceCounterQueryPools, "performanceCounterQueryPools", 1);
32621 
32622     print_VkBool32(obj->performanceCounterMultipleQueryPools, "performanceCounterMultipleQueryPools", 0);
32623 
32624     INDENT(-4);
32625     PRINT_SPACE
32626     if (commaNeeded)
32627         _OUT << "}," << std::endl;
32628     else
32629         _OUT << "}" << std::endl;
32630 }
32631 
print_VkPhysicalDevicePerformanceQueryPropertiesKHR(VkPhysicalDevicePerformanceQueryPropertiesKHR obj,const std::string & s,bool commaNeeded=true)32632 static void print_VkPhysicalDevicePerformanceQueryPropertiesKHR(VkPhysicalDevicePerformanceQueryPropertiesKHR obj,
32633                                                                 const std::string &s, bool commaNeeded = true)
32634 {
32635     PRINT_SPACE
32636     _OUT << "{" << std::endl;
32637     INDENT(4);
32638 
32639     print_VkStructureType(obj.sType, "sType", 1);
32640 
32641     if (obj.pNext)
32642     {
32643         dumpPNextChain(obj.pNext);
32644     }
32645     else
32646     {
32647         PRINT_SPACE
32648         _OUT << "\"pNext\":"
32649              << "\"NULL\""
32650              << "," << std::endl;
32651     }
32652 
32653     print_VkBool32(obj.allowCommandBufferQueryCopies, "allowCommandBufferQueryCopies", 0);
32654 
32655     INDENT(-4);
32656     PRINT_SPACE
32657     if (commaNeeded)
32658         _OUT << "}," << std::endl;
32659     else
32660         _OUT << "}" << std::endl;
32661 }
print_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR * obj,const std::string & s,bool commaNeeded=true)32662 static void print_VkPhysicalDevicePerformanceQueryPropertiesKHR(
32663     const VkPhysicalDevicePerformanceQueryPropertiesKHR *obj, const std::string &s, bool commaNeeded = true)
32664 {
32665     PRINT_SPACE
32666     _OUT << "{" << std::endl;
32667     INDENT(4);
32668 
32669     print_VkStructureType(obj->sType, "sType", 1);
32670 
32671     if (obj->pNext)
32672     {
32673         dumpPNextChain(obj->pNext);
32674     }
32675     else
32676     {
32677         PRINT_SPACE
32678         _OUT << "\"pNext\":"
32679              << "\"NULL\""
32680              << "," << std::endl;
32681     }
32682 
32683     print_VkBool32(obj->allowCommandBufferQueryCopies, "allowCommandBufferQueryCopies", 0);
32684 
32685     INDENT(-4);
32686     PRINT_SPACE
32687     if (commaNeeded)
32688         _OUT << "}," << std::endl;
32689     else
32690         _OUT << "}" << std::endl;
32691 }
32692 
print_VkPerformanceCounterKHR(VkPerformanceCounterKHR obj,const std::string & s,bool commaNeeded=true)32693 static void print_VkPerformanceCounterKHR(VkPerformanceCounterKHR obj, const std::string &s, bool commaNeeded = true)
32694 {
32695     PRINT_SPACE
32696     _OUT << "{" << std::endl;
32697     INDENT(4);
32698 
32699     print_VkStructureType(obj.sType, "sType", 1);
32700 
32701     if (obj.pNext)
32702     {
32703         dumpPNextChain(obj.pNext);
32704     }
32705     else
32706     {
32707         PRINT_SPACE
32708         _OUT << "\"pNext\":"
32709              << "\"NULL\""
32710              << "," << std::endl;
32711     }
32712 
32713     print_VkPerformanceCounterUnitKHR(obj.unit, "unit", 1);
32714 
32715     print_VkPerformanceCounterScopeKHR(obj.scope, "scope", 1);
32716 
32717     print_VkPerformanceCounterStorageKHR(obj.storage, "storage", 1);
32718 
32719     PRINT_SPACE
32720     _OUT << "\"uuid\":" << std::endl;
32721     PRINT_SPACE
32722     _OUT << "[" << std::endl;
32723     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
32724     {
32725         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
32726         print_uint8_t(obj.uuid[i], "", isCommaNeeded);
32727     }
32728     PRINT_SPACE
32729     _OUT << "]"
32730          << "" << std::endl;
32731 
32732     INDENT(-4);
32733     PRINT_SPACE
32734     if (commaNeeded)
32735         _OUT << "}," << std::endl;
32736     else
32737         _OUT << "}" << std::endl;
32738 }
print_VkPerformanceCounterKHR(const VkPerformanceCounterKHR * obj,const std::string & s,bool commaNeeded=true)32739 static void print_VkPerformanceCounterKHR(const VkPerformanceCounterKHR *obj, const std::string &s,
32740                                           bool commaNeeded = true)
32741 {
32742     PRINT_SPACE
32743     _OUT << "{" << std::endl;
32744     INDENT(4);
32745 
32746     print_VkStructureType(obj->sType, "sType", 1);
32747 
32748     if (obj->pNext)
32749     {
32750         dumpPNextChain(obj->pNext);
32751     }
32752     else
32753     {
32754         PRINT_SPACE
32755         _OUT << "\"pNext\":"
32756              << "\"NULL\""
32757              << "," << std::endl;
32758     }
32759 
32760     print_VkPerformanceCounterUnitKHR(obj->unit, "unit", 1);
32761 
32762     print_VkPerformanceCounterScopeKHR(obj->scope, "scope", 1);
32763 
32764     print_VkPerformanceCounterStorageKHR(obj->storage, "storage", 1);
32765 
32766     PRINT_SPACE
32767     _OUT << "\"uuid\":" << std::endl;
32768     PRINT_SPACE
32769     _OUT << "[" << std::endl;
32770     for (unsigned int i = 0; i < VK_UUID_SIZE; i++)
32771     {
32772         bool isCommaNeeded = (i + 1) != VK_UUID_SIZE;
32773         print_uint8_t(obj->uuid[i], "", isCommaNeeded);
32774     }
32775     PRINT_SPACE
32776     _OUT << "]"
32777          << "" << std::endl;
32778 
32779     INDENT(-4);
32780     PRINT_SPACE
32781     if (commaNeeded)
32782         _OUT << "}," << std::endl;
32783     else
32784         _OUT << "}" << std::endl;
32785 }
32786 
print_VkPerformanceCounterDescriptionKHR(VkPerformanceCounterDescriptionKHR obj,const std::string & s,bool commaNeeded=true)32787 static void print_VkPerformanceCounterDescriptionKHR(VkPerformanceCounterDescriptionKHR obj, const std::string &s,
32788                                                      bool commaNeeded = true)
32789 {
32790     PRINT_SPACE
32791     _OUT << "{" << std::endl;
32792     INDENT(4);
32793 
32794     print_VkStructureType(obj.sType, "sType", 1);
32795 
32796     if (obj.pNext)
32797     {
32798         dumpPNextChain(obj.pNext);
32799     }
32800     else
32801     {
32802         PRINT_SPACE
32803         _OUT << "\"pNext\":"
32804              << "\"NULL\""
32805              << "," << std::endl;
32806     }
32807 
32808     print_VkPerformanceCounterDescriptionFlagsKHR(obj.flags, "flags", 1);
32809 
32810     PRINT_SPACE
32811     _OUT << "\"name\":" << std::endl;
32812     PRINT_SPACE
32813     _OUT << "[" << std::endl;
32814     for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++)
32815     {
32816         bool isCommaNeeded = (i + 1) != VK_MAX_DESCRIPTION_SIZE;
32817         print_char(obj.name[i], "", isCommaNeeded);
32818     }
32819     PRINT_SPACE
32820     _OUT << "]"
32821          << "," << std::endl;
32822 
32823     PRINT_SPACE
32824     _OUT << "\"category\":" << std::endl;
32825     PRINT_SPACE
32826     _OUT << "[" << std::endl;
32827     for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++)
32828     {
32829         bool isCommaNeeded = (i + 1) != VK_MAX_DESCRIPTION_SIZE;
32830         print_char(obj.category[i], "", isCommaNeeded);
32831     }
32832     PRINT_SPACE
32833     _OUT << "]"
32834          << "," << std::endl;
32835 
32836     PRINT_SPACE
32837     _OUT << "\"description\":" << std::endl;
32838     PRINT_SPACE
32839     _OUT << "[" << std::endl;
32840     for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++)
32841     {
32842         bool isCommaNeeded = (i + 1) != VK_MAX_DESCRIPTION_SIZE;
32843         print_char(obj.description[i], "", isCommaNeeded);
32844     }
32845     PRINT_SPACE
32846     _OUT << "]"
32847          << "" << std::endl;
32848 
32849     INDENT(-4);
32850     PRINT_SPACE
32851     if (commaNeeded)
32852         _OUT << "}," << std::endl;
32853     else
32854         _OUT << "}" << std::endl;
32855 }
print_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR * obj,const std::string & s,bool commaNeeded=true)32856 static void print_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR *obj,
32857                                                      const std::string &s, bool commaNeeded = true)
32858 {
32859     PRINT_SPACE
32860     _OUT << "{" << std::endl;
32861     INDENT(4);
32862 
32863     print_VkStructureType(obj->sType, "sType", 1);
32864 
32865     if (obj->pNext)
32866     {
32867         dumpPNextChain(obj->pNext);
32868     }
32869     else
32870     {
32871         PRINT_SPACE
32872         _OUT << "\"pNext\":"
32873              << "\"NULL\""
32874              << "," << std::endl;
32875     }
32876 
32877     print_VkPerformanceCounterDescriptionFlagsKHR(obj->flags, "flags", 1);
32878 
32879     PRINT_SPACE
32880     _OUT << "\"name\":" << std::endl;
32881     PRINT_SPACE
32882     _OUT << "[" << std::endl;
32883     for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++)
32884     {
32885         bool isCommaNeeded = (i + 1) != VK_MAX_DESCRIPTION_SIZE;
32886         print_char(obj->name[i], "", isCommaNeeded);
32887     }
32888     PRINT_SPACE
32889     _OUT << "]"
32890          << "," << std::endl;
32891 
32892     PRINT_SPACE
32893     _OUT << "\"category\":" << std::endl;
32894     PRINT_SPACE
32895     _OUT << "[" << std::endl;
32896     for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++)
32897     {
32898         bool isCommaNeeded = (i + 1) != VK_MAX_DESCRIPTION_SIZE;
32899         print_char(obj->category[i], "", isCommaNeeded);
32900     }
32901     PRINT_SPACE
32902     _OUT << "]"
32903          << "," << std::endl;
32904 
32905     PRINT_SPACE
32906     _OUT << "\"description\":" << std::endl;
32907     PRINT_SPACE
32908     _OUT << "[" << std::endl;
32909     for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++)
32910     {
32911         bool isCommaNeeded = (i + 1) != VK_MAX_DESCRIPTION_SIZE;
32912         print_char(obj->description[i], "", isCommaNeeded);
32913     }
32914     PRINT_SPACE
32915     _OUT << "]"
32916          << "" << std::endl;
32917 
32918     INDENT(-4);
32919     PRINT_SPACE
32920     if (commaNeeded)
32921         _OUT << "}," << std::endl;
32922     else
32923         _OUT << "}" << std::endl;
32924 }
32925 
print_VkQueryPoolPerformanceCreateInfoKHR(VkQueryPoolPerformanceCreateInfoKHR obj,const std::string & s,bool commaNeeded=true)32926 static void print_VkQueryPoolPerformanceCreateInfoKHR(VkQueryPoolPerformanceCreateInfoKHR obj, const std::string &s,
32927                                                       bool commaNeeded = true)
32928 {
32929     PRINT_SPACE
32930     _OUT << "{" << std::endl;
32931     INDENT(4);
32932 
32933     print_VkStructureType(obj.sType, "sType", 1);
32934 
32935     if (obj.pNext)
32936     {
32937         dumpPNextChain(obj.pNext);
32938     }
32939     else
32940     {
32941         PRINT_SPACE
32942         _OUT << "\"pNext\":"
32943              << "\"NULL\""
32944              << "," << std::endl;
32945     }
32946 
32947     print_uint32_t(obj.queueFamilyIndex, "queueFamilyIndex", 1);
32948 
32949     print_uint32_t(obj.counterIndexCount, "counterIndexCount", 1);
32950 
32951     PRINT_SPACE
32952     _OUT << "\"pCounterIndices\":" << std::endl;
32953     PRINT_SPACE
32954     if (obj.pCounterIndices)
32955     {
32956         _OUT << "[" << std::endl;
32957         for (unsigned int i = 0; i < obj.counterIndexCount; i++)
32958         {
32959             bool isCommaNeeded = (i + 1) != obj.counterIndexCount;
32960             print_uint32_t(obj.pCounterIndices[i], "", isCommaNeeded);
32961         }
32962         PRINT_SPACE
32963         _OUT << "]"
32964              << "" << std::endl;
32965     }
32966     else
32967     {
32968         _OUT << "\"NULL\""
32969              << "" << std::endl;
32970     }
32971 
32972     INDENT(-4);
32973     PRINT_SPACE
32974     if (commaNeeded)
32975         _OUT << "}," << std::endl;
32976     else
32977         _OUT << "}" << std::endl;
32978 }
print_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR * obj,const std::string & s,bool commaNeeded=true)32979 static void print_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR *obj,
32980                                                       const std::string &s, bool commaNeeded = true)
32981 {
32982     PRINT_SPACE
32983     _OUT << "{" << std::endl;
32984     INDENT(4);
32985 
32986     print_VkStructureType(obj->sType, "sType", 1);
32987 
32988     if (obj->pNext)
32989     {
32990         dumpPNextChain(obj->pNext);
32991     }
32992     else
32993     {
32994         PRINT_SPACE
32995         _OUT << "\"pNext\":"
32996              << "\"NULL\""
32997              << "," << std::endl;
32998     }
32999 
33000     print_uint32_t(obj->queueFamilyIndex, "queueFamilyIndex", 1);
33001 
33002     print_uint32_t(obj->counterIndexCount, "counterIndexCount", 1);
33003 
33004     PRINT_SPACE
33005     _OUT << "\"pCounterIndices\":" << std::endl;
33006     PRINT_SPACE
33007     if (obj->pCounterIndices)
33008     {
33009         _OUT << "[" << std::endl;
33010         for (unsigned int i = 0; i < obj->counterIndexCount; i++)
33011         {
33012             bool isCommaNeeded = (i + 1) != obj->counterIndexCount;
33013             print_uint32_t(obj->pCounterIndices[i], "", isCommaNeeded);
33014         }
33015         PRINT_SPACE
33016         _OUT << "]"
33017              << "" << std::endl;
33018     }
33019     else
33020     {
33021         _OUT << "\"NULL\""
33022              << "" << std::endl;
33023     }
33024 
33025     INDENT(-4);
33026     PRINT_SPACE
33027     if (commaNeeded)
33028         _OUT << "}," << std::endl;
33029     else
33030         _OUT << "}" << std::endl;
33031 }
33032 
print_VkPerformanceCounterResultKHR(VkPerformanceCounterResultKHR obj,const std::string & s,bool commaNeeded=true)33033 static void print_VkPerformanceCounterResultKHR(VkPerformanceCounterResultKHR obj, const std::string &s,
33034                                                 bool commaNeeded = true)
33035 {
33036     PRINT_SPACE
33037     _OUT << "{" << std::endl;
33038     INDENT(4);
33039 
33040     print_int32_t(obj.int32, "int32", 1);
33041 
33042     print_int64_t(obj.int64, "int64", 1);
33043 
33044     print_uint32_t(obj.uint32, "uint32", 1);
33045 
33046     print_uint64_t(obj.uint64, "uint64", 1);
33047 
33048     print_float(obj.float32, "float32", 1);
33049 
33050     print_double(obj.float64, "float64", 0);
33051 
33052     INDENT(-4);
33053     PRINT_SPACE
33054     if (commaNeeded)
33055         _OUT << "}," << std::endl;
33056     else
33057         _OUT << "}" << std::endl;
33058 }
print_VkPerformanceCounterResultKHR(const VkPerformanceCounterResultKHR * obj,const std::string & s,bool commaNeeded=true)33059 static void print_VkPerformanceCounterResultKHR(const VkPerformanceCounterResultKHR *obj, const std::string &s,
33060                                                 bool commaNeeded = true)
33061 {
33062     PRINT_SPACE
33063     _OUT << "{" << std::endl;
33064     INDENT(4);
33065 
33066     print_int32_t(obj->int32, "int32", 1);
33067 
33068     print_int64_t(obj->int64, "int64", 1);
33069 
33070     print_uint32_t(obj->uint32, "uint32", 1);
33071 
33072     print_uint64_t(obj->uint64, "uint64", 1);
33073 
33074     print_float(obj->float32, "float32", 1);
33075 
33076     print_double(obj->float64, "float64", 0);
33077 
33078     INDENT(-4);
33079     PRINT_SPACE
33080     if (commaNeeded)
33081         _OUT << "}," << std::endl;
33082     else
33083         _OUT << "}" << std::endl;
33084 }
33085 
print_VkAcquireProfilingLockInfoKHR(VkAcquireProfilingLockInfoKHR obj,const std::string & s,bool commaNeeded=true)33086 static void print_VkAcquireProfilingLockInfoKHR(VkAcquireProfilingLockInfoKHR obj, const std::string &s,
33087                                                 bool commaNeeded = true)
33088 {
33089     PRINT_SPACE
33090     _OUT << "{" << std::endl;
33091     INDENT(4);
33092 
33093     print_VkStructureType(obj.sType, "sType", 1);
33094 
33095     if (obj.pNext)
33096     {
33097         dumpPNextChain(obj.pNext);
33098     }
33099     else
33100     {
33101         PRINT_SPACE
33102         _OUT << "\"pNext\":"
33103              << "\"NULL\""
33104              << "," << std::endl;
33105     }
33106 
33107     print_VkAcquireProfilingLockFlagsKHR(obj.flags, "flags", 1);
33108 
33109     print_uint64_t(obj.timeout, "timeout", 0);
33110 
33111     INDENT(-4);
33112     PRINT_SPACE
33113     if (commaNeeded)
33114         _OUT << "}," << std::endl;
33115     else
33116         _OUT << "}" << std::endl;
33117 }
print_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR * obj,const std::string & s,bool commaNeeded=true)33118 static void print_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR *obj, const std::string &s,
33119                                                 bool commaNeeded = true)
33120 {
33121     PRINT_SPACE
33122     _OUT << "{" << std::endl;
33123     INDENT(4);
33124 
33125     print_VkStructureType(obj->sType, "sType", 1);
33126 
33127     if (obj->pNext)
33128     {
33129         dumpPNextChain(obj->pNext);
33130     }
33131     else
33132     {
33133         PRINT_SPACE
33134         _OUT << "\"pNext\":"
33135              << "\"NULL\""
33136              << "," << std::endl;
33137     }
33138 
33139     print_VkAcquireProfilingLockFlagsKHR(obj->flags, "flags", 1);
33140 
33141     print_uint64_t(obj->timeout, "timeout", 0);
33142 
33143     INDENT(-4);
33144     PRINT_SPACE
33145     if (commaNeeded)
33146         _OUT << "}," << std::endl;
33147     else
33148         _OUT << "}" << std::endl;
33149 }
33150 
print_VkPerformanceQuerySubmitInfoKHR(VkPerformanceQuerySubmitInfoKHR obj,const std::string & s,bool commaNeeded=true)33151 static void print_VkPerformanceQuerySubmitInfoKHR(VkPerformanceQuerySubmitInfoKHR obj, const std::string &s,
33152                                                   bool commaNeeded = true)
33153 {
33154     PRINT_SPACE
33155     _OUT << "{" << std::endl;
33156     INDENT(4);
33157 
33158     print_VkStructureType(obj.sType, "sType", 1);
33159 
33160     if (obj.pNext)
33161     {
33162         dumpPNextChain(obj.pNext);
33163     }
33164     else
33165     {
33166         PRINT_SPACE
33167         _OUT << "\"pNext\":"
33168              << "\"NULL\""
33169              << "," << std::endl;
33170     }
33171 
33172     print_uint32_t(obj.counterPassIndex, "counterPassIndex", 0);
33173 
33174     INDENT(-4);
33175     PRINT_SPACE
33176     if (commaNeeded)
33177         _OUT << "}," << std::endl;
33178     else
33179         _OUT << "}" << std::endl;
33180 }
print_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR * obj,const std::string & s,bool commaNeeded=true)33181 static void print_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR *obj, const std::string &s,
33182                                                   bool commaNeeded = true)
33183 {
33184     PRINT_SPACE
33185     _OUT << "{" << std::endl;
33186     INDENT(4);
33187 
33188     print_VkStructureType(obj->sType, "sType", 1);
33189 
33190     if (obj->pNext)
33191     {
33192         dumpPNextChain(obj->pNext);
33193     }
33194     else
33195     {
33196         PRINT_SPACE
33197         _OUT << "\"pNext\":"
33198              << "\"NULL\""
33199              << "," << std::endl;
33200     }
33201 
33202     print_uint32_t(obj->counterPassIndex, "counterPassIndex", 0);
33203 
33204     INDENT(-4);
33205     PRINT_SPACE
33206     if (commaNeeded)
33207         _OUT << "}," << std::endl;
33208     else
33209         _OUT << "}" << std::endl;
33210 }
33211 
print_VkPerformanceQueryReservationInfoKHR(VkPerformanceQueryReservationInfoKHR obj,const std::string & s,bool commaNeeded=true)33212 static void print_VkPerformanceQueryReservationInfoKHR(VkPerformanceQueryReservationInfoKHR obj, const std::string &s,
33213                                                        bool commaNeeded = true)
33214 {
33215     PRINT_SPACE
33216     _OUT << "{" << std::endl;
33217     INDENT(4);
33218 
33219     print_VkStructureType(obj.sType, "sType", 1);
33220 
33221     if (obj.pNext)
33222     {
33223         dumpPNextChain(obj.pNext);
33224     }
33225     else
33226     {
33227         PRINT_SPACE
33228         _OUT << "\"pNext\":"
33229              << "\"NULL\""
33230              << "," << std::endl;
33231     }
33232 
33233     print_uint32_t(obj.maxPerformanceQueriesPerPool, "maxPerformanceQueriesPerPool", 0);
33234 
33235     INDENT(-4);
33236     PRINT_SPACE
33237     if (commaNeeded)
33238         _OUT << "}," << std::endl;
33239     else
33240         _OUT << "}" << std::endl;
33241 }
print_VkPerformanceQueryReservationInfoKHR(const VkPerformanceQueryReservationInfoKHR * obj,const std::string & s,bool commaNeeded=true)33242 static void print_VkPerformanceQueryReservationInfoKHR(const VkPerformanceQueryReservationInfoKHR *obj,
33243                                                        const std::string &s, bool commaNeeded = true)
33244 {
33245     PRINT_SPACE
33246     _OUT << "{" << std::endl;
33247     INDENT(4);
33248 
33249     print_VkStructureType(obj->sType, "sType", 1);
33250 
33251     if (obj->pNext)
33252     {
33253         dumpPNextChain(obj->pNext);
33254     }
33255     else
33256     {
33257         PRINT_SPACE
33258         _OUT << "\"pNext\":"
33259              << "\"NULL\""
33260              << "," << std::endl;
33261     }
33262 
33263     print_uint32_t(obj->maxPerformanceQueriesPerPool, "maxPerformanceQueriesPerPool", 0);
33264 
33265     INDENT(-4);
33266     PRINT_SPACE
33267     if (commaNeeded)
33268         _OUT << "}," << std::endl;
33269     else
33270         _OUT << "}" << std::endl;
33271 }
33272 
print_VkPhysicalDeviceSurfaceInfo2KHR(VkPhysicalDeviceSurfaceInfo2KHR obj,const std::string & s,bool commaNeeded=true)33273 static void print_VkPhysicalDeviceSurfaceInfo2KHR(VkPhysicalDeviceSurfaceInfo2KHR obj, const std::string &s,
33274                                                   bool commaNeeded = true)
33275 {
33276     PRINT_SPACE
33277     _OUT << "{" << std::endl;
33278     INDENT(4);
33279 
33280     print_VkStructureType(obj.sType, "sType", 1);
33281 
33282     if (obj.pNext)
33283     {
33284         dumpPNextChain(obj.pNext);
33285     }
33286     else
33287     {
33288         PRINT_SPACE
33289         _OUT << "\"pNext\":"
33290              << "\"NULL\""
33291              << "," << std::endl;
33292     }
33293 
33294     // CTS : required value
33295     PRINT_SPACE _OUT << "\""
33296                      << "surface"
33297                      << "\""
33298                      << " : "
33299                      << "\""
33300                      << "\"" << std::endl;
33301 
33302     INDENT(-4);
33303     PRINT_SPACE
33304     if (commaNeeded)
33305         _OUT << "}," << std::endl;
33306     else
33307         _OUT << "}" << std::endl;
33308 }
print_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR * obj,const std::string & s,bool commaNeeded=true)33309 static void print_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR *obj, const std::string &s,
33310                                                   bool commaNeeded = true)
33311 {
33312     PRINT_SPACE
33313     _OUT << "{" << std::endl;
33314     INDENT(4);
33315 
33316     print_VkStructureType(obj->sType, "sType", 1);
33317 
33318     if (obj->pNext)
33319     {
33320         dumpPNextChain(obj->pNext);
33321     }
33322     else
33323     {
33324         PRINT_SPACE
33325         _OUT << "\"pNext\":"
33326              << "\"NULL\""
33327              << "," << std::endl;
33328     }
33329 
33330     // CTS : required value
33331     PRINT_SPACE _OUT << "\""
33332                      << "surface"
33333                      << "\""
33334                      << " : "
33335                      << "\""
33336                      << "\"" << std::endl;
33337 
33338     INDENT(-4);
33339     PRINT_SPACE
33340     if (commaNeeded)
33341         _OUT << "}," << std::endl;
33342     else
33343         _OUT << "}" << std::endl;
33344 }
33345 
print_VkSurfaceCapabilities2KHR(VkSurfaceCapabilities2KHR obj,const std::string & s,bool commaNeeded=true)33346 static void print_VkSurfaceCapabilities2KHR(VkSurfaceCapabilities2KHR obj, const std::string &s,
33347                                             bool commaNeeded = true)
33348 {
33349     PRINT_SPACE
33350     _OUT << "{" << std::endl;
33351     INDENT(4);
33352 
33353     print_VkStructureType(obj.sType, "sType", 1);
33354 
33355     if (obj.pNext)
33356     {
33357         dumpPNextChain(obj.pNext);
33358     }
33359     else
33360     {
33361         PRINT_SPACE
33362         _OUT << "\"pNext\":"
33363              << "\"NULL\""
33364              << "," << std::endl;
33365     }
33366 
33367     PRINT_SPACE
33368     _OUT << "\"surfaceCapabilities\": " << std::endl;
33369     {
33370         print_VkSurfaceCapabilitiesKHR(obj.surfaceCapabilities, "surfaceCapabilities", 0);
33371     }
33372 
33373     INDENT(-4);
33374     PRINT_SPACE
33375     if (commaNeeded)
33376         _OUT << "}," << std::endl;
33377     else
33378         _OUT << "}" << std::endl;
33379 }
print_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR * obj,const std::string & s,bool commaNeeded=true)33380 static void print_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR *obj, const std::string &s,
33381                                             bool commaNeeded = true)
33382 {
33383     PRINT_SPACE
33384     _OUT << "{" << std::endl;
33385     INDENT(4);
33386 
33387     print_VkStructureType(obj->sType, "sType", 1);
33388 
33389     if (obj->pNext)
33390     {
33391         dumpPNextChain(obj->pNext);
33392     }
33393     else
33394     {
33395         PRINT_SPACE
33396         _OUT << "\"pNext\":"
33397              << "\"NULL\""
33398              << "," << std::endl;
33399     }
33400 
33401     PRINT_SPACE
33402     _OUT << "\"surfaceCapabilities\": " << std::endl;
33403     {
33404         print_VkSurfaceCapabilitiesKHR(obj->surfaceCapabilities, "surfaceCapabilities", 0);
33405     }
33406 
33407     INDENT(-4);
33408     PRINT_SPACE
33409     if (commaNeeded)
33410         _OUT << "}," << std::endl;
33411     else
33412         _OUT << "}" << std::endl;
33413 }
33414 
print_VkSurfaceFormat2KHR(VkSurfaceFormat2KHR obj,const std::string & s,bool commaNeeded=true)33415 static void print_VkSurfaceFormat2KHR(VkSurfaceFormat2KHR obj, const std::string &s, bool commaNeeded = true)
33416 {
33417     PRINT_SPACE
33418     _OUT << "{" << std::endl;
33419     INDENT(4);
33420 
33421     print_VkStructureType(obj.sType, "sType", 1);
33422 
33423     if (obj.pNext)
33424     {
33425         dumpPNextChain(obj.pNext);
33426     }
33427     else
33428     {
33429         PRINT_SPACE
33430         _OUT << "\"pNext\":"
33431              << "\"NULL\""
33432              << "," << std::endl;
33433     }
33434 
33435     PRINT_SPACE
33436     _OUT << "\"surfaceFormat\": " << std::endl;
33437     {
33438         print_VkSurfaceFormatKHR(obj.surfaceFormat, "surfaceFormat", 0);
33439     }
33440 
33441     INDENT(-4);
33442     PRINT_SPACE
33443     if (commaNeeded)
33444         _OUT << "}," << std::endl;
33445     else
33446         _OUT << "}" << std::endl;
33447 }
print_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR * obj,const std::string & s,bool commaNeeded=true)33448 static void print_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR *obj, const std::string &s, bool commaNeeded = true)
33449 {
33450     PRINT_SPACE
33451     _OUT << "{" << std::endl;
33452     INDENT(4);
33453 
33454     print_VkStructureType(obj->sType, "sType", 1);
33455 
33456     if (obj->pNext)
33457     {
33458         dumpPNextChain(obj->pNext);
33459     }
33460     else
33461     {
33462         PRINT_SPACE
33463         _OUT << "\"pNext\":"
33464              << "\"NULL\""
33465              << "," << std::endl;
33466     }
33467 
33468     PRINT_SPACE
33469     _OUT << "\"surfaceFormat\": " << std::endl;
33470     {
33471         print_VkSurfaceFormatKHR(obj->surfaceFormat, "surfaceFormat", 0);
33472     }
33473 
33474     INDENT(-4);
33475     PRINT_SPACE
33476     if (commaNeeded)
33477         _OUT << "}," << std::endl;
33478     else
33479         _OUT << "}" << std::endl;
33480 }
33481 
print_VkDisplayProperties2KHR(VkDisplayProperties2KHR obj,const std::string & s,bool commaNeeded=true)33482 static void print_VkDisplayProperties2KHR(VkDisplayProperties2KHR obj, const std::string &s, bool commaNeeded = true)
33483 {
33484     PRINT_SPACE
33485     _OUT << "{" << std::endl;
33486     INDENT(4);
33487 
33488     print_VkStructureType(obj.sType, "sType", 1);
33489 
33490     if (obj.pNext)
33491     {
33492         dumpPNextChain(obj.pNext);
33493     }
33494     else
33495     {
33496         PRINT_SPACE
33497         _OUT << "\"pNext\":"
33498              << "\"NULL\""
33499              << "," << std::endl;
33500     }
33501 
33502     PRINT_SPACE
33503     _OUT << "\"displayProperties\": " << std::endl;
33504     {
33505         print_VkDisplayPropertiesKHR(obj.displayProperties, "displayProperties", 0);
33506     }
33507 
33508     INDENT(-4);
33509     PRINT_SPACE
33510     if (commaNeeded)
33511         _OUT << "}," << std::endl;
33512     else
33513         _OUT << "}" << std::endl;
33514 }
print_VkDisplayProperties2KHR(const VkDisplayProperties2KHR * obj,const std::string & s,bool commaNeeded=true)33515 static void print_VkDisplayProperties2KHR(const VkDisplayProperties2KHR *obj, const std::string &s,
33516                                           bool commaNeeded = true)
33517 {
33518     PRINT_SPACE
33519     _OUT << "{" << std::endl;
33520     INDENT(4);
33521 
33522     print_VkStructureType(obj->sType, "sType", 1);
33523 
33524     if (obj->pNext)
33525     {
33526         dumpPNextChain(obj->pNext);
33527     }
33528     else
33529     {
33530         PRINT_SPACE
33531         _OUT << "\"pNext\":"
33532              << "\"NULL\""
33533              << "," << std::endl;
33534     }
33535 
33536     PRINT_SPACE
33537     _OUT << "\"displayProperties\": " << std::endl;
33538     {
33539         print_VkDisplayPropertiesKHR(obj->displayProperties, "displayProperties", 0);
33540     }
33541 
33542     INDENT(-4);
33543     PRINT_SPACE
33544     if (commaNeeded)
33545         _OUT << "}," << std::endl;
33546     else
33547         _OUT << "}" << std::endl;
33548 }
33549 
print_VkDisplayPlaneProperties2KHR(VkDisplayPlaneProperties2KHR obj,const std::string & s,bool commaNeeded=true)33550 static void print_VkDisplayPlaneProperties2KHR(VkDisplayPlaneProperties2KHR obj, const std::string &s,
33551                                                bool commaNeeded = true)
33552 {
33553     PRINT_SPACE
33554     _OUT << "{" << std::endl;
33555     INDENT(4);
33556 
33557     print_VkStructureType(obj.sType, "sType", 1);
33558 
33559     if (obj.pNext)
33560     {
33561         dumpPNextChain(obj.pNext);
33562     }
33563     else
33564     {
33565         PRINT_SPACE
33566         _OUT << "\"pNext\":"
33567              << "\"NULL\""
33568              << "," << std::endl;
33569     }
33570 
33571     PRINT_SPACE
33572     _OUT << "\"displayPlaneProperties\": " << std::endl;
33573     {
33574         print_VkDisplayPlanePropertiesKHR(obj.displayPlaneProperties, "displayPlaneProperties", 0);
33575     }
33576 
33577     INDENT(-4);
33578     PRINT_SPACE
33579     if (commaNeeded)
33580         _OUT << "}," << std::endl;
33581     else
33582         _OUT << "}" << std::endl;
33583 }
print_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR * obj,const std::string & s,bool commaNeeded=true)33584 static void print_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR *obj, const std::string &s,
33585                                                bool commaNeeded = true)
33586 {
33587     PRINT_SPACE
33588     _OUT << "{" << std::endl;
33589     INDENT(4);
33590 
33591     print_VkStructureType(obj->sType, "sType", 1);
33592 
33593     if (obj->pNext)
33594     {
33595         dumpPNextChain(obj->pNext);
33596     }
33597     else
33598     {
33599         PRINT_SPACE
33600         _OUT << "\"pNext\":"
33601              << "\"NULL\""
33602              << "," << std::endl;
33603     }
33604 
33605     PRINT_SPACE
33606     _OUT << "\"displayPlaneProperties\": " << std::endl;
33607     {
33608         print_VkDisplayPlanePropertiesKHR(obj->displayPlaneProperties, "displayPlaneProperties", 0);
33609     }
33610 
33611     INDENT(-4);
33612     PRINT_SPACE
33613     if (commaNeeded)
33614         _OUT << "}," << std::endl;
33615     else
33616         _OUT << "}" << std::endl;
33617 }
33618 
print_VkDisplayModeProperties2KHR(VkDisplayModeProperties2KHR obj,const std::string & s,bool commaNeeded=true)33619 static void print_VkDisplayModeProperties2KHR(VkDisplayModeProperties2KHR obj, const std::string &s,
33620                                               bool commaNeeded = true)
33621 {
33622     PRINT_SPACE
33623     _OUT << "{" << std::endl;
33624     INDENT(4);
33625 
33626     print_VkStructureType(obj.sType, "sType", 1);
33627 
33628     if (obj.pNext)
33629     {
33630         dumpPNextChain(obj.pNext);
33631     }
33632     else
33633     {
33634         PRINT_SPACE
33635         _OUT << "\"pNext\":"
33636              << "\"NULL\""
33637              << "," << std::endl;
33638     }
33639 
33640     PRINT_SPACE
33641     _OUT << "\"displayModeProperties\": " << std::endl;
33642     {
33643         print_VkDisplayModePropertiesKHR(obj.displayModeProperties, "displayModeProperties", 0);
33644     }
33645 
33646     INDENT(-4);
33647     PRINT_SPACE
33648     if (commaNeeded)
33649         _OUT << "}," << std::endl;
33650     else
33651         _OUT << "}" << std::endl;
33652 }
print_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR * obj,const std::string & s,bool commaNeeded=true)33653 static void print_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR *obj, const std::string &s,
33654                                               bool commaNeeded = true)
33655 {
33656     PRINT_SPACE
33657     _OUT << "{" << std::endl;
33658     INDENT(4);
33659 
33660     print_VkStructureType(obj->sType, "sType", 1);
33661 
33662     if (obj->pNext)
33663     {
33664         dumpPNextChain(obj->pNext);
33665     }
33666     else
33667     {
33668         PRINT_SPACE
33669         _OUT << "\"pNext\":"
33670              << "\"NULL\""
33671              << "," << std::endl;
33672     }
33673 
33674     PRINT_SPACE
33675     _OUT << "\"displayModeProperties\": " << std::endl;
33676     {
33677         print_VkDisplayModePropertiesKHR(obj->displayModeProperties, "displayModeProperties", 0);
33678     }
33679 
33680     INDENT(-4);
33681     PRINT_SPACE
33682     if (commaNeeded)
33683         _OUT << "}," << std::endl;
33684     else
33685         _OUT << "}" << std::endl;
33686 }
33687 
print_VkDisplayPlaneInfo2KHR(VkDisplayPlaneInfo2KHR obj,const std::string & s,bool commaNeeded=true)33688 static void print_VkDisplayPlaneInfo2KHR(VkDisplayPlaneInfo2KHR obj, const std::string &s, bool commaNeeded = true)
33689 {
33690     PRINT_SPACE
33691     _OUT << "{" << std::endl;
33692     INDENT(4);
33693 
33694     print_VkStructureType(obj.sType, "sType", 1);
33695 
33696     if (obj.pNext)
33697     {
33698         dumpPNextChain(obj.pNext);
33699     }
33700     else
33701     {
33702         PRINT_SPACE
33703         _OUT << "\"pNext\":"
33704              << "\"NULL\""
33705              << "," << std::endl;
33706     }
33707 
33708     // CTS : required value
33709     PRINT_SPACE _OUT << "\""
33710                      << "mode"
33711                      << "\""
33712                      << " : "
33713                      << "\""
33714                      << "\"," << std::endl;
33715 
33716     print_uint32_t(obj.planeIndex, "planeIndex", 0);
33717 
33718     INDENT(-4);
33719     PRINT_SPACE
33720     if (commaNeeded)
33721         _OUT << "}," << std::endl;
33722     else
33723         _OUT << "}" << std::endl;
33724 }
print_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR * obj,const std::string & s,bool commaNeeded=true)33725 static void print_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR *obj, const std::string &s,
33726                                          bool commaNeeded = true)
33727 {
33728     PRINT_SPACE
33729     _OUT << "{" << std::endl;
33730     INDENT(4);
33731 
33732     print_VkStructureType(obj->sType, "sType", 1);
33733 
33734     if (obj->pNext)
33735     {
33736         dumpPNextChain(obj->pNext);
33737     }
33738     else
33739     {
33740         PRINT_SPACE
33741         _OUT << "\"pNext\":"
33742              << "\"NULL\""
33743              << "," << std::endl;
33744     }
33745 
33746     // CTS : required value
33747     PRINT_SPACE _OUT << "\""
33748                      << "mode"
33749                      << "\""
33750                      << " : "
33751                      << "\""
33752                      << "\"," << std::endl;
33753 
33754     print_uint32_t(obj->planeIndex, "planeIndex", 0);
33755 
33756     INDENT(-4);
33757     PRINT_SPACE
33758     if (commaNeeded)
33759         _OUT << "}," << std::endl;
33760     else
33761         _OUT << "}" << std::endl;
33762 }
33763 
print_VkDisplayPlaneCapabilities2KHR(VkDisplayPlaneCapabilities2KHR obj,const std::string & s,bool commaNeeded=true)33764 static void print_VkDisplayPlaneCapabilities2KHR(VkDisplayPlaneCapabilities2KHR obj, const std::string &s,
33765                                                  bool commaNeeded = true)
33766 {
33767     PRINT_SPACE
33768     _OUT << "{" << std::endl;
33769     INDENT(4);
33770 
33771     print_VkStructureType(obj.sType, "sType", 1);
33772 
33773     if (obj.pNext)
33774     {
33775         dumpPNextChain(obj.pNext);
33776     }
33777     else
33778     {
33779         PRINT_SPACE
33780         _OUT << "\"pNext\":"
33781              << "\"NULL\""
33782              << "," << std::endl;
33783     }
33784 
33785     PRINT_SPACE
33786     _OUT << "\"capabilities\": " << std::endl;
33787     {
33788         print_VkDisplayPlaneCapabilitiesKHR(obj.capabilities, "capabilities", 0);
33789     }
33790 
33791     INDENT(-4);
33792     PRINT_SPACE
33793     if (commaNeeded)
33794         _OUT << "}," << std::endl;
33795     else
33796         _OUT << "}" << std::endl;
33797 }
print_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR * obj,const std::string & s,bool commaNeeded=true)33798 static void print_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR *obj, const std::string &s,
33799                                                  bool commaNeeded = true)
33800 {
33801     PRINT_SPACE
33802     _OUT << "{" << std::endl;
33803     INDENT(4);
33804 
33805     print_VkStructureType(obj->sType, "sType", 1);
33806 
33807     if (obj->pNext)
33808     {
33809         dumpPNextChain(obj->pNext);
33810     }
33811     else
33812     {
33813         PRINT_SPACE
33814         _OUT << "\"pNext\":"
33815              << "\"NULL\""
33816              << "," << std::endl;
33817     }
33818 
33819     PRINT_SPACE
33820     _OUT << "\"capabilities\": " << std::endl;
33821     {
33822         print_VkDisplayPlaneCapabilitiesKHR(obj->capabilities, "capabilities", 0);
33823     }
33824 
33825     INDENT(-4);
33826     PRINT_SPACE
33827     if (commaNeeded)
33828         _OUT << "}," << std::endl;
33829     else
33830         _OUT << "}" << std::endl;
33831 }
33832 
print_VkPhysicalDeviceShaderClockFeaturesKHR(VkPhysicalDeviceShaderClockFeaturesKHR obj,const std::string & s,bool commaNeeded=true)33833 static void print_VkPhysicalDeviceShaderClockFeaturesKHR(VkPhysicalDeviceShaderClockFeaturesKHR obj,
33834                                                          const std::string &s, bool commaNeeded = true)
33835 {
33836     PRINT_SPACE
33837     _OUT << "{" << std::endl;
33838     INDENT(4);
33839 
33840     print_VkStructureType(obj.sType, "sType", 1);
33841 
33842     if (obj.pNext)
33843     {
33844         dumpPNextChain(obj.pNext);
33845     }
33846     else
33847     {
33848         PRINT_SPACE
33849         _OUT << "\"pNext\":"
33850              << "\"NULL\""
33851              << "," << std::endl;
33852     }
33853 
33854     print_VkBool32(obj.shaderSubgroupClock, "shaderSubgroupClock", 1);
33855 
33856     print_VkBool32(obj.shaderDeviceClock, "shaderDeviceClock", 0);
33857 
33858     INDENT(-4);
33859     PRINT_SPACE
33860     if (commaNeeded)
33861         _OUT << "}," << std::endl;
33862     else
33863         _OUT << "}" << std::endl;
33864 }
print_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR * obj,const std::string & s,bool commaNeeded=true)33865 static void print_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR *obj,
33866                                                          const std::string &s, bool commaNeeded = true)
33867 {
33868     PRINT_SPACE
33869     _OUT << "{" << std::endl;
33870     INDENT(4);
33871 
33872     print_VkStructureType(obj->sType, "sType", 1);
33873 
33874     if (obj->pNext)
33875     {
33876         dumpPNextChain(obj->pNext);
33877     }
33878     else
33879     {
33880         PRINT_SPACE
33881         _OUT << "\"pNext\":"
33882              << "\"NULL\""
33883              << "," << std::endl;
33884     }
33885 
33886     print_VkBool32(obj->shaderSubgroupClock, "shaderSubgroupClock", 1);
33887 
33888     print_VkBool32(obj->shaderDeviceClock, "shaderDeviceClock", 0);
33889 
33890     INDENT(-4);
33891     PRINT_SPACE
33892     if (commaNeeded)
33893         _OUT << "}," << std::endl;
33894     else
33895         _OUT << "}" << std::endl;
33896 }
33897 
print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR obj,const std::string & s,bool commaNeeded=true)33898 static void print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
33899     VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR obj, const std::string &s, bool commaNeeded = true)
33900 {
33901     PRINT_SPACE
33902     _OUT << "{" << std::endl;
33903     INDENT(4);
33904 
33905     print_VkStructureType(obj.sType, "sType", 1);
33906 
33907     if (obj.pNext)
33908     {
33909         dumpPNextChain(obj.pNext);
33910     }
33911     else
33912     {
33913         PRINT_SPACE
33914         _OUT << "\"pNext\":"
33915              << "\"NULL\""
33916              << "," << std::endl;
33917     }
33918 
33919     print_VkBool32(obj.shaderTerminateInvocation, "shaderTerminateInvocation", 0);
33920 
33921     INDENT(-4);
33922     PRINT_SPACE
33923     if (commaNeeded)
33924         _OUT << "}," << std::endl;
33925     else
33926         _OUT << "}" << std::endl;
33927 }
print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR * obj,const std::string & s,bool commaNeeded=true)33928 static void print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
33929     const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *obj, const std::string &s, bool commaNeeded = true)
33930 {
33931     PRINT_SPACE
33932     _OUT << "{" << std::endl;
33933     INDENT(4);
33934 
33935     print_VkStructureType(obj->sType, "sType", 1);
33936 
33937     if (obj->pNext)
33938     {
33939         dumpPNextChain(obj->pNext);
33940     }
33941     else
33942     {
33943         PRINT_SPACE
33944         _OUT << "\"pNext\":"
33945              << "\"NULL\""
33946              << "," << std::endl;
33947     }
33948 
33949     print_VkBool32(obj->shaderTerminateInvocation, "shaderTerminateInvocation", 0);
33950 
33951     INDENT(-4);
33952     PRINT_SPACE
33953     if (commaNeeded)
33954         _OUT << "}," << std::endl;
33955     else
33956         _OUT << "}" << std::endl;
33957 }
33958 
33959 static std::map<uint64_t, std::string> VkFragmentShadingRateCombinerOpKHR_map = {
33960     std::make_pair(0, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR"),
33961     std::make_pair(1, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR"),
33962     std::make_pair(2, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR"),
33963     std::make_pair(3, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR"),
33964     std::make_pair(4, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR"),
33965 };
print_VkFragmentShadingRateCombinerOpKHR(VkFragmentShadingRateCombinerOpKHR obj,const std::string & str,bool commaNeeded=true)33966 static void print_VkFragmentShadingRateCombinerOpKHR(VkFragmentShadingRateCombinerOpKHR obj, const std::string &str,
33967                                                      bool commaNeeded = true)
33968 {
33969     PRINT_SPACE
33970     if (str != "")
33971         _OUT << "\"" << str << "\""
33972              << " : ";
33973     if (commaNeeded)
33974         _OUT << "\"" << VkFragmentShadingRateCombinerOpKHR_map[obj] << "\"," << std::endl;
33975     else
33976         _OUT << "\"" << VkFragmentShadingRateCombinerOpKHR_map[obj] << "\"" << std::endl;
33977 }
print_VkFragmentShadingRateCombinerOpKHR(const VkFragmentShadingRateCombinerOpKHR * obj,const std::string & str,bool commaNeeded=true)33978 static void print_VkFragmentShadingRateCombinerOpKHR(const VkFragmentShadingRateCombinerOpKHR *obj,
33979                                                      const std::string &str, bool commaNeeded = true)
33980 {
33981     PRINT_SPACE
33982     if (str != "")
33983         _OUT << "\"" << str << "\""
33984              << " : ";
33985     if (commaNeeded)
33986         _OUT << "\"" << VkFragmentShadingRateCombinerOpKHR_map[*obj] << "\"," << std::endl;
33987     else
33988         _OUT << "\"" << VkFragmentShadingRateCombinerOpKHR_map[*obj] << "\"" << std::endl;
33989 }
33990 
print_VkFragmentShadingRateAttachmentInfoKHR(VkFragmentShadingRateAttachmentInfoKHR obj,const std::string & s,bool commaNeeded=true)33991 static void print_VkFragmentShadingRateAttachmentInfoKHR(VkFragmentShadingRateAttachmentInfoKHR obj,
33992                                                          const std::string &s, bool commaNeeded = true)
33993 {
33994     PRINT_SPACE
33995     _OUT << "{" << std::endl;
33996     INDENT(4);
33997 
33998     print_VkStructureType(obj.sType, "sType", 1);
33999 
34000     if (obj.pNext)
34001     {
34002         dumpPNextChain(obj.pNext);
34003     }
34004     else
34005     {
34006         PRINT_SPACE
34007         _OUT << "\"pNext\":"
34008              << "\"NULL\""
34009              << "," << std::endl;
34010     }
34011 
34012     PRINT_SPACE
34013     _OUT << "\"pFragmentShadingRateAttachment\": " << std::endl;
34014     if (obj.pFragmentShadingRateAttachment)
34015     {
34016         print_VkAttachmentReference2(obj.pFragmentShadingRateAttachment, "pFragmentShadingRateAttachment", 1);
34017     }
34018     else
34019     {
34020         PRINT_SPACE _OUT << "\"NULL\""
34021                          << "," << std::endl;
34022     }
34023 
34024     PRINT_SPACE
34025     _OUT << "\"shadingRateAttachmentTexelSize\": " << std::endl;
34026     {
34027         print_VkExtent2D(obj.shadingRateAttachmentTexelSize, "shadingRateAttachmentTexelSize", 0);
34028     }
34029 
34030     INDENT(-4);
34031     PRINT_SPACE
34032     if (commaNeeded)
34033         _OUT << "}," << std::endl;
34034     else
34035         _OUT << "}" << std::endl;
34036 }
print_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR * obj,const std::string & s,bool commaNeeded=true)34037 static void print_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR *obj,
34038                                                          const std::string &s, bool commaNeeded = true)
34039 {
34040     PRINT_SPACE
34041     _OUT << "{" << std::endl;
34042     INDENT(4);
34043 
34044     print_VkStructureType(obj->sType, "sType", 1);
34045 
34046     if (obj->pNext)
34047     {
34048         dumpPNextChain(obj->pNext);
34049     }
34050     else
34051     {
34052         PRINT_SPACE
34053         _OUT << "\"pNext\":"
34054              << "\"NULL\""
34055              << "," << std::endl;
34056     }
34057 
34058     PRINT_SPACE
34059     _OUT << "\"pFragmentShadingRateAttachment\": " << std::endl;
34060     if (obj->pFragmentShadingRateAttachment)
34061     {
34062         print_VkAttachmentReference2(obj->pFragmentShadingRateAttachment, "pFragmentShadingRateAttachment", 1);
34063     }
34064     else
34065     {
34066         PRINT_SPACE _OUT << "\"NULL\""
34067                          << "," << std::endl;
34068     }
34069 
34070     PRINT_SPACE
34071     _OUT << "\"shadingRateAttachmentTexelSize\": " << std::endl;
34072     {
34073         print_VkExtent2D(obj->shadingRateAttachmentTexelSize, "shadingRateAttachmentTexelSize", 0);
34074     }
34075 
34076     INDENT(-4);
34077     PRINT_SPACE
34078     if (commaNeeded)
34079         _OUT << "}," << std::endl;
34080     else
34081         _OUT << "}" << std::endl;
34082 }
34083 
print_VkPipelineFragmentShadingRateStateCreateInfoKHR(VkPipelineFragmentShadingRateStateCreateInfoKHR obj,const std::string & s,bool commaNeeded=true)34084 static void print_VkPipelineFragmentShadingRateStateCreateInfoKHR(VkPipelineFragmentShadingRateStateCreateInfoKHR obj,
34085                                                                   const std::string &s, bool commaNeeded = true)
34086 {
34087     PRINT_SPACE
34088     _OUT << "{" << std::endl;
34089     INDENT(4);
34090 
34091     print_VkStructureType(obj.sType, "sType", 1);
34092 
34093     if (obj.pNext)
34094     {
34095         dumpPNextChain(obj.pNext);
34096     }
34097     else
34098     {
34099         PRINT_SPACE
34100         _OUT << "\"pNext\":"
34101              << "\"NULL\""
34102              << "," << std::endl;
34103     }
34104 
34105     PRINT_SPACE
34106     _OUT << "\"fragmentSize\": " << std::endl;
34107     {
34108         print_VkExtent2D(obj.fragmentSize, "fragmentSize", 1);
34109     }
34110 
34111     PRINT_SPACE
34112     _OUT << "\"combinerOps\":" << std::endl;
34113     PRINT_SPACE
34114     _OUT << "[" << std::endl;
34115     for (unsigned int i = 0; i < 2; i++)
34116     {
34117         bool isCommaNeeded = (i + 1) != 2;
34118         print_VkFragmentShadingRateCombinerOpKHR(obj.combinerOps[i], "", isCommaNeeded);
34119     }
34120     PRINT_SPACE
34121     _OUT << "]"
34122          << "" << std::endl;
34123 
34124     INDENT(-4);
34125     PRINT_SPACE
34126     if (commaNeeded)
34127         _OUT << "}," << std::endl;
34128     else
34129         _OUT << "}" << std::endl;
34130 }
print_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR * obj,const std::string & s,bool commaNeeded=true)34131 static void print_VkPipelineFragmentShadingRateStateCreateInfoKHR(
34132     const VkPipelineFragmentShadingRateStateCreateInfoKHR *obj, const std::string &s, bool commaNeeded = true)
34133 {
34134     PRINT_SPACE
34135     _OUT << "{" << std::endl;
34136     INDENT(4);
34137 
34138     print_VkStructureType(obj->sType, "sType", 1);
34139 
34140     if (obj->pNext)
34141     {
34142         dumpPNextChain(obj->pNext);
34143     }
34144     else
34145     {
34146         PRINT_SPACE
34147         _OUT << "\"pNext\":"
34148              << "\"NULL\""
34149              << "," << std::endl;
34150     }
34151 
34152     PRINT_SPACE
34153     _OUT << "\"fragmentSize\": " << std::endl;
34154     {
34155         print_VkExtent2D(obj->fragmentSize, "fragmentSize", 1);
34156     }
34157 
34158     PRINT_SPACE
34159     _OUT << "\"combinerOps\":" << std::endl;
34160     PRINT_SPACE
34161     _OUT << "[" << std::endl;
34162     for (unsigned int i = 0; i < 2; i++)
34163     {
34164         bool isCommaNeeded = (i + 1) != 2;
34165         print_VkFragmentShadingRateCombinerOpKHR(obj->combinerOps[i], "", isCommaNeeded);
34166     }
34167     PRINT_SPACE
34168     _OUT << "]"
34169          << "" << std::endl;
34170 
34171     INDENT(-4);
34172     PRINT_SPACE
34173     if (commaNeeded)
34174         _OUT << "}," << std::endl;
34175     else
34176         _OUT << "}" << std::endl;
34177 }
34178 
print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(VkPhysicalDeviceFragmentShadingRateFeaturesKHR obj,const std::string & s,bool commaNeeded=true)34179 static void print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(VkPhysicalDeviceFragmentShadingRateFeaturesKHR obj,
34180                                                                  const std::string &s, bool commaNeeded = true)
34181 {
34182     PRINT_SPACE
34183     _OUT << "{" << std::endl;
34184     INDENT(4);
34185 
34186     print_VkStructureType(obj.sType, "sType", 1);
34187 
34188     if (obj.pNext)
34189     {
34190         dumpPNextChain(obj.pNext);
34191     }
34192     else
34193     {
34194         PRINT_SPACE
34195         _OUT << "\"pNext\":"
34196              << "\"NULL\""
34197              << "," << std::endl;
34198     }
34199 
34200     print_VkBool32(obj.pipelineFragmentShadingRate, "pipelineFragmentShadingRate", 1);
34201 
34202     print_VkBool32(obj.primitiveFragmentShadingRate, "primitiveFragmentShadingRate", 1);
34203 
34204     print_VkBool32(obj.attachmentFragmentShadingRate, "attachmentFragmentShadingRate", 0);
34205 
34206     INDENT(-4);
34207     PRINT_SPACE
34208     if (commaNeeded)
34209         _OUT << "}," << std::endl;
34210     else
34211         _OUT << "}" << std::endl;
34212 }
print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR * obj,const std::string & s,bool commaNeeded=true)34213 static void print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
34214     const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *obj, const std::string &s, bool commaNeeded = true)
34215 {
34216     PRINT_SPACE
34217     _OUT << "{" << std::endl;
34218     INDENT(4);
34219 
34220     print_VkStructureType(obj->sType, "sType", 1);
34221 
34222     if (obj->pNext)
34223     {
34224         dumpPNextChain(obj->pNext);
34225     }
34226     else
34227     {
34228         PRINT_SPACE
34229         _OUT << "\"pNext\":"
34230              << "\"NULL\""
34231              << "," << std::endl;
34232     }
34233 
34234     print_VkBool32(obj->pipelineFragmentShadingRate, "pipelineFragmentShadingRate", 1);
34235 
34236     print_VkBool32(obj->primitiveFragmentShadingRate, "primitiveFragmentShadingRate", 1);
34237 
34238     print_VkBool32(obj->attachmentFragmentShadingRate, "attachmentFragmentShadingRate", 0);
34239 
34240     INDENT(-4);
34241     PRINT_SPACE
34242     if (commaNeeded)
34243         _OUT << "}," << std::endl;
34244     else
34245         _OUT << "}" << std::endl;
34246 }
34247 
print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(VkPhysicalDeviceFragmentShadingRatePropertiesKHR obj,const std::string & s,bool commaNeeded=true)34248 static void print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(VkPhysicalDeviceFragmentShadingRatePropertiesKHR obj,
34249                                                                    const std::string &s, bool commaNeeded = true)
34250 {
34251     PRINT_SPACE
34252     _OUT << "{" << std::endl;
34253     INDENT(4);
34254 
34255     print_VkStructureType(obj.sType, "sType", 1);
34256 
34257     if (obj.pNext)
34258     {
34259         dumpPNextChain(obj.pNext);
34260     }
34261     else
34262     {
34263         PRINT_SPACE
34264         _OUT << "\"pNext\":"
34265              << "\"NULL\""
34266              << "," << std::endl;
34267     }
34268 
34269     PRINT_SPACE
34270     _OUT << "\"minFragmentShadingRateAttachmentTexelSize\": " << std::endl;
34271     {
34272         print_VkExtent2D(obj.minFragmentShadingRateAttachmentTexelSize, "minFragmentShadingRateAttachmentTexelSize", 1);
34273     }
34274 
34275     PRINT_SPACE
34276     _OUT << "\"maxFragmentShadingRateAttachmentTexelSize\": " << std::endl;
34277     {
34278         print_VkExtent2D(obj.maxFragmentShadingRateAttachmentTexelSize, "maxFragmentShadingRateAttachmentTexelSize", 1);
34279     }
34280 
34281     print_uint32_t(obj.maxFragmentShadingRateAttachmentTexelSizeAspectRatio,
34282                    "maxFragmentShadingRateAttachmentTexelSizeAspectRatio", 1);
34283 
34284     print_VkBool32(obj.primitiveFragmentShadingRateWithMultipleViewports,
34285                    "primitiveFragmentShadingRateWithMultipleViewports", 1);
34286 
34287     print_VkBool32(obj.layeredShadingRateAttachments, "layeredShadingRateAttachments", 1);
34288 
34289     print_VkBool32(obj.fragmentShadingRateNonTrivialCombinerOps, "fragmentShadingRateNonTrivialCombinerOps", 1);
34290 
34291     PRINT_SPACE
34292     _OUT << "\"maxFragmentSize\": " << std::endl;
34293     {
34294         print_VkExtent2D(obj.maxFragmentSize, "maxFragmentSize", 1);
34295     }
34296 
34297     print_uint32_t(obj.maxFragmentSizeAspectRatio, "maxFragmentSizeAspectRatio", 1);
34298 
34299     print_uint32_t(obj.maxFragmentShadingRateCoverageSamples, "maxFragmentShadingRateCoverageSamples", 1);
34300 
34301     print_VkSampleCountFlagBits(obj.maxFragmentShadingRateRasterizationSamples,
34302                                 "maxFragmentShadingRateRasterizationSamples", 1);
34303 
34304     print_VkBool32(obj.fragmentShadingRateWithShaderDepthStencilWrites,
34305                    "fragmentShadingRateWithShaderDepthStencilWrites", 1);
34306 
34307     print_VkBool32(obj.fragmentShadingRateWithSampleMask, "fragmentShadingRateWithSampleMask", 1);
34308 
34309     print_VkBool32(obj.fragmentShadingRateWithShaderSampleMask, "fragmentShadingRateWithShaderSampleMask", 1);
34310 
34311     print_VkBool32(obj.fragmentShadingRateWithConservativeRasterization,
34312                    "fragmentShadingRateWithConservativeRasterization", 1);
34313 
34314     print_VkBool32(obj.fragmentShadingRateWithFragmentShaderInterlock, "fragmentShadingRateWithFragmentShaderInterlock",
34315                    1);
34316 
34317     print_VkBool32(obj.fragmentShadingRateWithCustomSampleLocations, "fragmentShadingRateWithCustomSampleLocations", 1);
34318 
34319     print_VkBool32(obj.fragmentShadingRateStrictMultiplyCombiner, "fragmentShadingRateStrictMultiplyCombiner", 0);
34320 
34321     INDENT(-4);
34322     PRINT_SPACE
34323     if (commaNeeded)
34324         _OUT << "}," << std::endl;
34325     else
34326         _OUT << "}" << std::endl;
34327 }
print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR * obj,const std::string & s,bool commaNeeded=true)34328 static void print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
34329     const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *obj, const std::string &s, bool commaNeeded = true)
34330 {
34331     PRINT_SPACE
34332     _OUT << "{" << std::endl;
34333     INDENT(4);
34334 
34335     print_VkStructureType(obj->sType, "sType", 1);
34336 
34337     if (obj->pNext)
34338     {
34339         dumpPNextChain(obj->pNext);
34340     }
34341     else
34342     {
34343         PRINT_SPACE
34344         _OUT << "\"pNext\":"
34345              << "\"NULL\""
34346              << "," << std::endl;
34347     }
34348 
34349     PRINT_SPACE
34350     _OUT << "\"minFragmentShadingRateAttachmentTexelSize\": " << std::endl;
34351     {
34352         print_VkExtent2D(obj->minFragmentShadingRateAttachmentTexelSize, "minFragmentShadingRateAttachmentTexelSize",
34353                          1);
34354     }
34355 
34356     PRINT_SPACE
34357     _OUT << "\"maxFragmentShadingRateAttachmentTexelSize\": " << std::endl;
34358     {
34359         print_VkExtent2D(obj->maxFragmentShadingRateAttachmentTexelSize, "maxFragmentShadingRateAttachmentTexelSize",
34360                          1);
34361     }
34362 
34363     print_uint32_t(obj->maxFragmentShadingRateAttachmentTexelSizeAspectRatio,
34364                    "maxFragmentShadingRateAttachmentTexelSizeAspectRatio", 1);
34365 
34366     print_VkBool32(obj->primitiveFragmentShadingRateWithMultipleViewports,
34367                    "primitiveFragmentShadingRateWithMultipleViewports", 1);
34368 
34369     print_VkBool32(obj->layeredShadingRateAttachments, "layeredShadingRateAttachments", 1);
34370 
34371     print_VkBool32(obj->fragmentShadingRateNonTrivialCombinerOps, "fragmentShadingRateNonTrivialCombinerOps", 1);
34372 
34373     PRINT_SPACE
34374     _OUT << "\"maxFragmentSize\": " << std::endl;
34375     {
34376         print_VkExtent2D(obj->maxFragmentSize, "maxFragmentSize", 1);
34377     }
34378 
34379     print_uint32_t(obj->maxFragmentSizeAspectRatio, "maxFragmentSizeAspectRatio", 1);
34380 
34381     print_uint32_t(obj->maxFragmentShadingRateCoverageSamples, "maxFragmentShadingRateCoverageSamples", 1);
34382 
34383     print_VkSampleCountFlagBits(obj->maxFragmentShadingRateRasterizationSamples,
34384                                 "maxFragmentShadingRateRasterizationSamples", 1);
34385 
34386     print_VkBool32(obj->fragmentShadingRateWithShaderDepthStencilWrites,
34387                    "fragmentShadingRateWithShaderDepthStencilWrites", 1);
34388 
34389     print_VkBool32(obj->fragmentShadingRateWithSampleMask, "fragmentShadingRateWithSampleMask", 1);
34390 
34391     print_VkBool32(obj->fragmentShadingRateWithShaderSampleMask, "fragmentShadingRateWithShaderSampleMask", 1);
34392 
34393     print_VkBool32(obj->fragmentShadingRateWithConservativeRasterization,
34394                    "fragmentShadingRateWithConservativeRasterization", 1);
34395 
34396     print_VkBool32(obj->fragmentShadingRateWithFragmentShaderInterlock,
34397                    "fragmentShadingRateWithFragmentShaderInterlock", 1);
34398 
34399     print_VkBool32(obj->fragmentShadingRateWithCustomSampleLocations, "fragmentShadingRateWithCustomSampleLocations",
34400                    1);
34401 
34402     print_VkBool32(obj->fragmentShadingRateStrictMultiplyCombiner, "fragmentShadingRateStrictMultiplyCombiner", 0);
34403 
34404     INDENT(-4);
34405     PRINT_SPACE
34406     if (commaNeeded)
34407         _OUT << "}," << std::endl;
34408     else
34409         _OUT << "}" << std::endl;
34410 }
34411 
print_VkPhysicalDeviceFragmentShadingRateKHR(VkPhysicalDeviceFragmentShadingRateKHR obj,const std::string & s,bool commaNeeded=true)34412 static void print_VkPhysicalDeviceFragmentShadingRateKHR(VkPhysicalDeviceFragmentShadingRateKHR obj,
34413                                                          const std::string &s, bool commaNeeded = true)
34414 {
34415     PRINT_SPACE
34416     _OUT << "{" << std::endl;
34417     INDENT(4);
34418 
34419     print_VkStructureType(obj.sType, "sType", 1);
34420 
34421     if (obj.pNext)
34422     {
34423         dumpPNextChain(obj.pNext);
34424     }
34425     else
34426     {
34427         PRINT_SPACE
34428         _OUT << "\"pNext\":"
34429              << "\"NULL\""
34430              << "," << std::endl;
34431     }
34432 
34433     print_VkSampleCountFlags(obj.sampleCounts, "sampleCounts", 1);
34434 
34435     PRINT_SPACE
34436     _OUT << "\"fragmentSize\": " << std::endl;
34437     {
34438         print_VkExtent2D(obj.fragmentSize, "fragmentSize", 0);
34439     }
34440 
34441     INDENT(-4);
34442     PRINT_SPACE
34443     if (commaNeeded)
34444         _OUT << "}," << std::endl;
34445     else
34446         _OUT << "}" << std::endl;
34447 }
print_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR * obj,const std::string & s,bool commaNeeded=true)34448 static void print_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR *obj,
34449                                                          const std::string &s, bool commaNeeded = true)
34450 {
34451     PRINT_SPACE
34452     _OUT << "{" << std::endl;
34453     INDENT(4);
34454 
34455     print_VkStructureType(obj->sType, "sType", 1);
34456 
34457     if (obj->pNext)
34458     {
34459         dumpPNextChain(obj->pNext);
34460     }
34461     else
34462     {
34463         PRINT_SPACE
34464         _OUT << "\"pNext\":"
34465              << "\"NULL\""
34466              << "," << std::endl;
34467     }
34468 
34469     print_VkSampleCountFlags(obj->sampleCounts, "sampleCounts", 1);
34470 
34471     PRINT_SPACE
34472     _OUT << "\"fragmentSize\": " << std::endl;
34473     {
34474         print_VkExtent2D(obj->fragmentSize, "fragmentSize", 0);
34475     }
34476 
34477     INDENT(-4);
34478     PRINT_SPACE
34479     if (commaNeeded)
34480         _OUT << "}," << std::endl;
34481     else
34482         _OUT << "}" << std::endl;
34483 }
34484 
34485 static std::map<uint64_t, std::string> VkRefreshObjectFlagBitsKHR_map = {};
print_VkRefreshObjectFlagBitsKHR(VkRefreshObjectFlagBitsKHR obj,const std::string & str,bool commaNeeded=true)34486 static void print_VkRefreshObjectFlagBitsKHR(VkRefreshObjectFlagBitsKHR obj, const std::string &str,
34487                                              bool commaNeeded = true)
34488 {
34489     PRINT_SPACE
34490     if (str != "")
34491         _OUT << "\"" << str << "\""
34492              << " : ";
34493     if (commaNeeded)
34494         _OUT << "\"" << VkRefreshObjectFlagBitsKHR_map[obj] << "\"," << std::endl;
34495     else
34496         _OUT << "\"" << VkRefreshObjectFlagBitsKHR_map[obj] << "\"" << std::endl;
34497 }
print_VkRefreshObjectFlagBitsKHR(const VkRefreshObjectFlagBitsKHR * obj,const std::string & str,bool commaNeeded=true)34498 static void print_VkRefreshObjectFlagBitsKHR(const VkRefreshObjectFlagBitsKHR *obj, const std::string &str,
34499                                              bool commaNeeded = true)
34500 {
34501     PRINT_SPACE
34502     if (str != "")
34503         _OUT << "\"" << str << "\""
34504              << " : ";
34505     if (commaNeeded)
34506         _OUT << "\"" << VkRefreshObjectFlagBitsKHR_map[*obj] << "\"," << std::endl;
34507     else
34508         _OUT << "\"" << VkRefreshObjectFlagBitsKHR_map[*obj] << "\"" << std::endl;
34509 }
34510 
print_VkRefreshObjectFlagsKHR(VkRefreshObjectFlagsKHR obj,const std::string & str,bool commaNeeded=true)34511 static void print_VkRefreshObjectFlagsKHR(VkRefreshObjectFlagsKHR obj, const std::string &str, bool commaNeeded = true)
34512 {
34513     PRINT_SPACE
34514     if (str != "")
34515         _OUT << "\"" << str << "\""
34516              << " : ";
34517     const int max_bits = 64; // We don't expect the number to be larger.
34518     std::bitset<max_bits> b(obj);
34519     _OUT << "\"";
34520     if (obj == 0)
34521         _OUT << "0";
34522     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
34523     {
34524         if (b[i] == 1)
34525         {
34526             bitCount++;
34527             if (bitCount < b.count())
34528                 _OUT << VkRefreshObjectFlagBitsKHR_map[1ULL << i] << " | ";
34529             else
34530                 _OUT << VkRefreshObjectFlagBitsKHR_map[1ULL << i];
34531         }
34532     }
34533     if (commaNeeded)
34534         _OUT << "\""
34535              << ",";
34536     else
34537         _OUT << "\""
34538              << "";
34539     _OUT << std::endl;
34540 }
print_VkRefreshObjectFlagsKHR(const VkRefreshObjectFlagsKHR * obj,const std::string & str,bool commaNeeded=true)34541 static void print_VkRefreshObjectFlagsKHR(const VkRefreshObjectFlagsKHR *obj, const std::string &str,
34542                                           bool commaNeeded = true)
34543 {
34544     PRINT_SPACE
34545     if (str != "")
34546         _OUT << "\"" << str << "\""
34547              << " : ";
34548     const int max_bits = 64; // We don't expect the number to be larger.
34549     std::bitset<max_bits> b(obj);
34550     _OUT << "\"";
34551     if (obj == 0)
34552         _OUT << "0";
34553     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
34554     {
34555         if (b[i] == 1)
34556         {
34557             bitCount++;
34558             if (bitCount < b.count())
34559                 _OUT << VkRefreshObjectFlagBitsKHR_map[1ULL << i] << " | ";
34560             else
34561                 _OUT << VkRefreshObjectFlagBitsKHR_map[1ULL << i];
34562         }
34563     }
34564     if (commaNeeded)
34565         _OUT << "\""
34566              << ",";
34567     else
34568         _OUT << "\""
34569              << "";
34570     _OUT << std::endl;
34571 }
34572 
print_VkRefreshObjectKHR(VkRefreshObjectKHR obj,const std::string & s,bool commaNeeded=true)34573 static void print_VkRefreshObjectKHR(VkRefreshObjectKHR obj, const std::string &s, bool commaNeeded = true)
34574 {
34575     PRINT_SPACE
34576     _OUT << "{" << std::endl;
34577     INDENT(4);
34578 
34579     print_VkObjectType(obj.objectType, "objectType", 1);
34580 
34581     print_uint64_t(obj.objectHandle, "objectHandle", 1);
34582 
34583     print_VkRefreshObjectFlagsKHR(obj.flags, "flags", 0);
34584 
34585     INDENT(-4);
34586     PRINT_SPACE
34587     if (commaNeeded)
34588         _OUT << "}," << std::endl;
34589     else
34590         _OUT << "}" << std::endl;
34591 }
print_VkRefreshObjectKHR(const VkRefreshObjectKHR * obj,const std::string & s,bool commaNeeded=true)34592 static void print_VkRefreshObjectKHR(const VkRefreshObjectKHR *obj, const std::string &s, bool commaNeeded = true)
34593 {
34594     PRINT_SPACE
34595     _OUT << "{" << std::endl;
34596     INDENT(4);
34597 
34598     print_VkObjectType(obj->objectType, "objectType", 1);
34599 
34600     print_uint64_t(obj->objectHandle, "objectHandle", 1);
34601 
34602     print_VkRefreshObjectFlagsKHR(obj->flags, "flags", 0);
34603 
34604     INDENT(-4);
34605     PRINT_SPACE
34606     if (commaNeeded)
34607         _OUT << "}," << std::endl;
34608     else
34609         _OUT << "}" << std::endl;
34610 }
34611 
print_VkRefreshObjectListKHR(VkRefreshObjectListKHR obj,const std::string & s,bool commaNeeded=true)34612 static void print_VkRefreshObjectListKHR(VkRefreshObjectListKHR obj, const std::string &s, bool commaNeeded = true)
34613 {
34614     PRINT_SPACE
34615     _OUT << "{" << std::endl;
34616     INDENT(4);
34617 
34618     print_VkStructureType(obj.sType, "sType", 1);
34619 
34620     if (obj.pNext)
34621     {
34622         dumpPNextChain(obj.pNext);
34623     }
34624     else
34625     {
34626         PRINT_SPACE
34627         _OUT << "\"pNext\":"
34628              << "\"NULL\""
34629              << "," << std::endl;
34630     }
34631 
34632     print_uint32_t(obj.objectCount, "objectCount", 1);
34633 
34634     PRINT_SPACE
34635     _OUT << "\"pObjects\": " << std::endl;
34636     if (obj.pObjects)
34637     {
34638         PRINT_SPACE
34639         _OUT << "[" << std::endl;
34640         for (unsigned int i = 0; i < obj.objectCount; i++)
34641         {
34642             if (i + 1 == obj.objectCount)
34643                 print_VkRefreshObjectKHR(obj.pObjects[i], "pObjects", 0);
34644             else
34645                 print_VkRefreshObjectKHR(obj.pObjects[i], "pObjects", 1);
34646         }
34647         PRINT_SPACE
34648         _OUT << "]" << std::endl;
34649     }
34650     else
34651     {
34652         PRINT_SPACE _OUT << "\"NULL\""
34653                          << "" << std::endl;
34654     }
34655 
34656     INDENT(-4);
34657     PRINT_SPACE
34658     if (commaNeeded)
34659         _OUT << "}," << std::endl;
34660     else
34661         _OUT << "}" << std::endl;
34662 }
print_VkRefreshObjectListKHR(const VkRefreshObjectListKHR * obj,const std::string & s,bool commaNeeded=true)34663 static void print_VkRefreshObjectListKHR(const VkRefreshObjectListKHR *obj, const std::string &s,
34664                                          bool commaNeeded = true)
34665 {
34666     PRINT_SPACE
34667     _OUT << "{" << std::endl;
34668     INDENT(4);
34669 
34670     print_VkStructureType(obj->sType, "sType", 1);
34671 
34672     if (obj->pNext)
34673     {
34674         dumpPNextChain(obj->pNext);
34675     }
34676     else
34677     {
34678         PRINT_SPACE
34679         _OUT << "\"pNext\":"
34680              << "\"NULL\""
34681              << "," << std::endl;
34682     }
34683 
34684     print_uint32_t(obj->objectCount, "objectCount", 1);
34685 
34686     PRINT_SPACE
34687     _OUT << "\"pObjects\": " << std::endl;
34688     if (obj->pObjects)
34689     {
34690         PRINT_SPACE
34691         _OUT << "[" << std::endl;
34692         for (unsigned int i = 0; i < obj->objectCount; i++)
34693         {
34694             if (i + 1 == obj->objectCount)
34695                 print_VkRefreshObjectKHR(obj->pObjects[i], "pObjects", 0);
34696             else
34697                 print_VkRefreshObjectKHR(obj->pObjects[i], "pObjects", 1);
34698         }
34699         PRINT_SPACE
34700         _OUT << "]" << std::endl;
34701     }
34702     else
34703     {
34704         PRINT_SPACE _OUT << "\"NULL\""
34705                          << "" << std::endl;
34706     }
34707 
34708     INDENT(-4);
34709     PRINT_SPACE
34710     if (commaNeeded)
34711         _OUT << "}," << std::endl;
34712     else
34713         _OUT << "}" << std::endl;
34714 }
34715 
print_VkFlags64(VkFlags64 obj,const std::string & str,bool commaNeeded=true)34716 static void print_VkFlags64(VkFlags64 obj, const std::string &str, bool commaNeeded = true)
34717 {
34718     PRINT_SPACE
34719     _OUT << "\"" << str << "\""
34720          << " : "
34721          << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
34722 }
print_VkFlags64(const VkFlags64 * obj,const std::string & str,bool commaNeeded=true)34723 static void print_VkFlags64(const VkFlags64 *obj, const std::string &str, bool commaNeeded = true)
34724 {
34725     PRINT_SPACE
34726     _OUT << "\"" << str << "\""
34727          << " : "
34728          << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl;
34729 }
34730 
34731 static std::map<uint64_t, std::string> VkPipelineStageFlagBits2KHR_map = {
34732     std::make_pair(0, "VK_PIPELINE_STAGE_2_NONE_KHR"),
34733     std::make_pair(1ULL << 0, "VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR"),
34734     std::make_pair(1ULL << 1, "VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR"),
34735     std::make_pair(1ULL << 2, "VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR"),
34736     std::make_pair(1ULL << 3, "VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR"),
34737     std::make_pair(1ULL << 4, "VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR"),
34738     std::make_pair(1ULL << 5, "VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR"),
34739     std::make_pair(1ULL << 6, "VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR"),
34740     std::make_pair(1ULL << 7, "VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR"),
34741     std::make_pair(1ULL << 8, "VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR"),
34742     std::make_pair(1ULL << 9, "VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR"),
34743     std::make_pair(1ULL << 10, "VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR"),
34744     std::make_pair(1ULL << 11, "VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR"),
34745     std::make_pair(1ULL << 12, "VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR"),
34746     std::make_pair(1ULL << 13, "VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR"),
34747     std::make_pair(1ULL << 14, "VK_PIPELINE_STAGE_2_HOST_BIT_KHR"),
34748     std::make_pair(1ULL << 15, "VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR"),
34749     std::make_pair(1ULL << 16, "VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR"),
34750     std::make_pair(1ULL << 32, "VK_PIPELINE_STAGE_2_COPY_BIT_KHR"),
34751     std::make_pair(1ULL << 33, "VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR"),
34752     std::make_pair(1ULL << 34, "VK_PIPELINE_STAGE_2_BLIT_BIT_KHR"),
34753     std::make_pair(1ULL << 35, "VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR"),
34754     std::make_pair(1ULL << 36, "VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR"),
34755     std::make_pair(1ULL << 37, "VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR"),
34756     std::make_pair(1ULL << 38, "VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR"),
34757     std::make_pair(1ULL << 26, "VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR"),
34758     std::make_pair(1ULL << 27, "VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR"),
34759     std::make_pair(1ULL << 24, "VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT"),
34760     std::make_pair(1ULL << 18, "VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT"),
34761     std::make_pair(1ULL << 17, "VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV"),
34762     std::make_pair(1ULL << 22, "VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"),
34763     std::make_pair(1ULL << 25, "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"),
34764     std::make_pair(1ULL << 21, "VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR"),
34765     std::make_pair(1ULL << 23, "VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT"),
34766     std::make_pair(1ULL << 19, "VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV"),
34767     std::make_pair(1ULL << 20, "VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV"),
34768     std::make_pair(1ULL << 39, "VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI"),
34769     std::make_pair(1ULL << 40, "VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI"),
34770     std::make_pair(1ULL << 28, "VK_PIPELINE_STAGE_2_RESERVED_387_BIT_KHR"),
34771 };
print_VkPipelineStageFlagBits2KHR(VkPipelineStageFlagBits2KHR obj,const std::string & str,bool commaNeeded=true)34772 static void print_VkPipelineStageFlagBits2KHR(VkPipelineStageFlagBits2KHR obj, const std::string &str,
34773                                               bool commaNeeded = true)
34774 {
34775     PRINT_SPACE
34776     if (str != "")
34777         _OUT << "\"" << str << "\""
34778              << " : ";
34779     if (commaNeeded)
34780         _OUT << "\"" << VkPipelineStageFlagBits2KHR_map[obj] << "\"," << std::endl;
34781     else
34782         _OUT << "\"" << VkPipelineStageFlagBits2KHR_map[obj] << "\"" << std::endl;
34783 }
print_VkPipelineStageFlagBits2KHR(const VkPipelineStageFlagBits2KHR * obj,const std::string & str,bool commaNeeded=true)34784 static void print_VkPipelineStageFlagBits2KHR(const VkPipelineStageFlagBits2KHR *obj, const std::string &str,
34785                                               bool commaNeeded = true)
34786 {
34787     PRINT_SPACE
34788     if (str != "")
34789         _OUT << "\"" << str << "\""
34790              << " : ";
34791     if (commaNeeded)
34792         _OUT << "\"" << VkPipelineStageFlagBits2KHR_map[*obj] << "\"," << std::endl;
34793     else
34794         _OUT << "\"" << VkPipelineStageFlagBits2KHR_map[*obj] << "\"" << std::endl;
34795 }
34796 
34797 static std::map<uint64_t, std::string> VkAccessFlagBits2KHR_map = {
34798     std::make_pair(0, "VK_ACCESS_2_NONE_KHR"),
34799     std::make_pair(1ULL << 0, "VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR"),
34800     std::make_pair(1ULL << 1, "VK_ACCESS_2_INDEX_READ_BIT_KHR"),
34801     std::make_pair(1ULL << 2, "VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR"),
34802     std::make_pair(1ULL << 3, "VK_ACCESS_2_UNIFORM_READ_BIT_KHR"),
34803     std::make_pair(1ULL << 4, "VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR"),
34804     std::make_pair(1ULL << 5, "VK_ACCESS_2_SHADER_READ_BIT_KHR"),
34805     std::make_pair(1ULL << 6, "VK_ACCESS_2_SHADER_WRITE_BIT_KHR"),
34806     std::make_pair(1ULL << 7, "VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR"),
34807     std::make_pair(1ULL << 8, "VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR"),
34808     std::make_pair(1ULL << 9, "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR"),
34809     std::make_pair(1ULL << 10, "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR"),
34810     std::make_pair(1ULL << 11, "VK_ACCESS_2_TRANSFER_READ_BIT_KHR"),
34811     std::make_pair(1ULL << 12, "VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR"),
34812     std::make_pair(1ULL << 13, "VK_ACCESS_2_HOST_READ_BIT_KHR"),
34813     std::make_pair(1ULL << 14, "VK_ACCESS_2_HOST_WRITE_BIT_KHR"),
34814     std::make_pair(1ULL << 15, "VK_ACCESS_2_MEMORY_READ_BIT_KHR"),
34815     std::make_pair(1ULL << 16, "VK_ACCESS_2_MEMORY_WRITE_BIT_KHR"),
34816     std::make_pair(1ULL << 32, "VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR"),
34817     std::make_pair(1ULL << 33, "VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR"),
34818     std::make_pair(1ULL << 34, "VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR"),
34819     std::make_pair(1ULL << 35, "VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR"),
34820     std::make_pair(1ULL << 36, "VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR"),
34821     std::make_pair(1ULL << 37, "VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR"),
34822     std::make_pair(1ULL << 38, "VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR"),
34823     std::make_pair(1ULL << 25, "VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"),
34824     std::make_pair(1ULL << 26, "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"),
34825     std::make_pair(1ULL << 27, "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"),
34826     std::make_pair(1ULL << 20, "VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT"),
34827     std::make_pair(1ULL << 17, "VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV"),
34828     std::make_pair(1ULL << 18, "VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV"),
34829     std::make_pair(1ULL << 23, "VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"),
34830     std::make_pair(1ULL << 21, "VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR"),
34831     std::make_pair(1ULL << 22, "VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"),
34832     std::make_pair(1ULL << 24, "VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"),
34833     std::make_pair(1ULL << 19, "VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"),
34834     std::make_pair(1ULL << 41, "VK_ACCESS_2_RESERVED_41_BIT_AMD"),
34835     std::make_pair(1ULL << 39, "VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI"),
34836     std::make_pair(1ULL << 40, "VK_ACCESS_2_RESERVED_387_BIT_KHR"),
34837 };
print_VkAccessFlagBits2KHR(VkAccessFlagBits2KHR obj,const std::string & str,bool commaNeeded=true)34838 static void print_VkAccessFlagBits2KHR(VkAccessFlagBits2KHR obj, const std::string &str, bool commaNeeded = true)
34839 {
34840     PRINT_SPACE
34841     if (str != "")
34842         _OUT << "\"" << str << "\""
34843              << " : ";
34844     if (commaNeeded)
34845         _OUT << "\"" << VkAccessFlagBits2KHR_map[obj] << "\"," << std::endl;
34846     else
34847         _OUT << "\"" << VkAccessFlagBits2KHR_map[obj] << "\"" << std::endl;
34848 }
print_VkAccessFlagBits2KHR(const VkAccessFlagBits2KHR * obj,const std::string & str,bool commaNeeded=true)34849 static void print_VkAccessFlagBits2KHR(const VkAccessFlagBits2KHR *obj, const std::string &str, bool commaNeeded = true)
34850 {
34851     PRINT_SPACE
34852     if (str != "")
34853         _OUT << "\"" << str << "\""
34854              << " : ";
34855     if (commaNeeded)
34856         _OUT << "\"" << VkAccessFlagBits2KHR_map[*obj] << "\"," << std::endl;
34857     else
34858         _OUT << "\"" << VkAccessFlagBits2KHR_map[*obj] << "\"" << std::endl;
34859 }
34860 
34861 static std::map<uint64_t, std::string> VkSubmitFlagBitsKHR_map = {
34862     std::make_pair(1ULL << 0, "VK_SUBMIT_PROTECTED_BIT_KHR"),
34863 };
print_VkSubmitFlagBitsKHR(VkSubmitFlagBitsKHR obj,const std::string & str,bool commaNeeded=true)34864 static void print_VkSubmitFlagBitsKHR(VkSubmitFlagBitsKHR obj, const std::string &str, bool commaNeeded = true)
34865 {
34866     PRINT_SPACE
34867     if (str != "")
34868         _OUT << "\"" << str << "\""
34869              << " : ";
34870     if (commaNeeded)
34871         _OUT << "\"" << VkSubmitFlagBitsKHR_map[obj] << "\"," << std::endl;
34872     else
34873         _OUT << "\"" << VkSubmitFlagBitsKHR_map[obj] << "\"" << std::endl;
34874 }
print_VkSubmitFlagBitsKHR(const VkSubmitFlagBitsKHR * obj,const std::string & str,bool commaNeeded=true)34875 static void print_VkSubmitFlagBitsKHR(const VkSubmitFlagBitsKHR *obj, const std::string &str, bool commaNeeded = true)
34876 {
34877     PRINT_SPACE
34878     if (str != "")
34879         _OUT << "\"" << str << "\""
34880              << " : ";
34881     if (commaNeeded)
34882         _OUT << "\"" << VkSubmitFlagBitsKHR_map[*obj] << "\"," << std::endl;
34883     else
34884         _OUT << "\"" << VkSubmitFlagBitsKHR_map[*obj] << "\"" << std::endl;
34885 }
34886 
print_VkPipelineStageFlags2KHR(VkPipelineStageFlags2KHR obj,const std::string & str,bool commaNeeded=true)34887 static void print_VkPipelineStageFlags2KHR(VkPipelineStageFlags2KHR obj, const std::string &str,
34888                                            bool commaNeeded = true)
34889 {
34890     PRINT_SPACE
34891     if (commaNeeded)
34892         _OUT << "\"" << str << "\""
34893              << " : " << obj << "," << std::endl;
34894     else
34895         _OUT << "\"" << str << "\""
34896              << " : " << obj << std::endl;
34897 }
print_VkPipelineStageFlags2KHR(const VkPipelineStageFlags2KHR * obj,const std::string & str,bool commaNeeded=true)34898 static void print_VkPipelineStageFlags2KHR(const VkPipelineStageFlags2KHR *obj, const std::string &str,
34899                                            bool commaNeeded = true)
34900 {
34901     PRINT_SPACE
34902     if (commaNeeded)
34903         _OUT << "\"" << str << "\""
34904              << " : " << obj << "," << std::endl;
34905     else
34906         _OUT << "\"" << str << "\""
34907              << " : " << obj << std::endl;
34908 }
34909 
print_VkAccessFlags2KHR(VkAccessFlags2KHR obj,const std::string & str,bool commaNeeded=true)34910 static void print_VkAccessFlags2KHR(VkAccessFlags2KHR obj, const std::string &str, bool commaNeeded = true)
34911 {
34912     PRINT_SPACE
34913     if (commaNeeded)
34914         _OUT << "\"" << str << "\""
34915              << " : " << obj << "," << std::endl;
34916     else
34917         _OUT << "\"" << str << "\""
34918              << " : " << obj << std::endl;
34919 }
print_VkAccessFlags2KHR(const VkAccessFlags2KHR * obj,const std::string & str,bool commaNeeded=true)34920 static void print_VkAccessFlags2KHR(const VkAccessFlags2KHR *obj, const std::string &str, bool commaNeeded = true)
34921 {
34922     PRINT_SPACE
34923     if (commaNeeded)
34924         _OUT << "\"" << str << "\""
34925              << " : " << obj << "," << std::endl;
34926     else
34927         _OUT << "\"" << str << "\""
34928              << " : " << obj << std::endl;
34929 }
34930 
print_VkSubmitFlagsKHR(VkSubmitFlagsKHR obj,const std::string & str,bool commaNeeded=true)34931 static void print_VkSubmitFlagsKHR(VkSubmitFlagsKHR obj, const std::string &str, bool commaNeeded = true)
34932 {
34933     PRINT_SPACE
34934     if (str != "")
34935         _OUT << "\"" << str << "\""
34936              << " : ";
34937     const int max_bits = 64; // We don't expect the number to be larger.
34938     std::bitset<max_bits> b(obj);
34939     _OUT << "\"";
34940     if (obj == 0)
34941         _OUT << "0";
34942     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
34943     {
34944         if (b[i] == 1)
34945         {
34946             bitCount++;
34947             if (bitCount < b.count())
34948                 _OUT << VkSubmitFlagBitsKHR_map[1ULL << i] << " | ";
34949             else
34950                 _OUT << VkSubmitFlagBitsKHR_map[1ULL << i];
34951         }
34952     }
34953     if (commaNeeded)
34954         _OUT << "\""
34955              << ",";
34956     else
34957         _OUT << "\""
34958              << "";
34959     _OUT << std::endl;
34960 }
print_VkSubmitFlagsKHR(const VkSubmitFlagsKHR * obj,const std::string & str,bool commaNeeded=true)34961 static void print_VkSubmitFlagsKHR(const VkSubmitFlagsKHR *obj, const std::string &str, bool commaNeeded = true)
34962 {
34963     PRINT_SPACE
34964     if (str != "")
34965         _OUT << "\"" << str << "\""
34966              << " : ";
34967     const int max_bits = 64; // We don't expect the number to be larger.
34968     std::bitset<max_bits> b(obj);
34969     _OUT << "\"";
34970     if (obj == 0)
34971         _OUT << "0";
34972     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
34973     {
34974         if (b[i] == 1)
34975         {
34976             bitCount++;
34977             if (bitCount < b.count())
34978                 _OUT << VkSubmitFlagBitsKHR_map[1ULL << i] << " | ";
34979             else
34980                 _OUT << VkSubmitFlagBitsKHR_map[1ULL << i];
34981         }
34982     }
34983     if (commaNeeded)
34984         _OUT << "\""
34985              << ",";
34986     else
34987         _OUT << "\""
34988              << "";
34989     _OUT << std::endl;
34990 }
34991 
print_VkMemoryBarrier2KHR(VkMemoryBarrier2KHR obj,const std::string & s,bool commaNeeded=true)34992 static void print_VkMemoryBarrier2KHR(VkMemoryBarrier2KHR obj, const std::string &s, bool commaNeeded = true)
34993 {
34994     PRINT_SPACE
34995     _OUT << "{" << std::endl;
34996     INDENT(4);
34997 
34998     print_VkStructureType(obj.sType, "sType", 1);
34999 
35000     if (obj.pNext)
35001     {
35002         dumpPNextChain(obj.pNext);
35003     }
35004     else
35005     {
35006         PRINT_SPACE
35007         _OUT << "\"pNext\":"
35008              << "\"NULL\""
35009              << "," << std::endl;
35010     }
35011 
35012     print_VkPipelineStageFlags2KHR(obj.srcStageMask, "srcStageMask", 1);
35013 
35014     print_VkAccessFlags2KHR(obj.srcAccessMask, "srcAccessMask", 1);
35015 
35016     print_VkPipelineStageFlags2KHR(obj.dstStageMask, "dstStageMask", 1);
35017 
35018     print_VkAccessFlags2KHR(obj.dstAccessMask, "dstAccessMask", 0);
35019 
35020     INDENT(-4);
35021     PRINT_SPACE
35022     if (commaNeeded)
35023         _OUT << "}," << std::endl;
35024     else
35025         _OUT << "}" << std::endl;
35026 }
print_VkMemoryBarrier2KHR(const VkMemoryBarrier2KHR * obj,const std::string & s,bool commaNeeded=true)35027 static void print_VkMemoryBarrier2KHR(const VkMemoryBarrier2KHR *obj, const std::string &s, bool commaNeeded = true)
35028 {
35029     PRINT_SPACE
35030     _OUT << "{" << std::endl;
35031     INDENT(4);
35032 
35033     print_VkStructureType(obj->sType, "sType", 1);
35034 
35035     if (obj->pNext)
35036     {
35037         dumpPNextChain(obj->pNext);
35038     }
35039     else
35040     {
35041         PRINT_SPACE
35042         _OUT << "\"pNext\":"
35043              << "\"NULL\""
35044              << "," << std::endl;
35045     }
35046 
35047     print_VkPipelineStageFlags2KHR(obj->srcStageMask, "srcStageMask", 1);
35048 
35049     print_VkAccessFlags2KHR(obj->srcAccessMask, "srcAccessMask", 1);
35050 
35051     print_VkPipelineStageFlags2KHR(obj->dstStageMask, "dstStageMask", 1);
35052 
35053     print_VkAccessFlags2KHR(obj->dstAccessMask, "dstAccessMask", 0);
35054 
35055     INDENT(-4);
35056     PRINT_SPACE
35057     if (commaNeeded)
35058         _OUT << "}," << std::endl;
35059     else
35060         _OUT << "}" << std::endl;
35061 }
35062 
print_VkBufferMemoryBarrier2KHR(VkBufferMemoryBarrier2KHR obj,const std::string & s,bool commaNeeded=true)35063 static void print_VkBufferMemoryBarrier2KHR(VkBufferMemoryBarrier2KHR obj, const std::string &s,
35064                                             bool commaNeeded = true)
35065 {
35066     PRINT_SPACE
35067     _OUT << "{" << std::endl;
35068     INDENT(4);
35069 
35070     print_VkStructureType(obj.sType, "sType", 1);
35071 
35072     if (obj.pNext)
35073     {
35074         dumpPNextChain(obj.pNext);
35075     }
35076     else
35077     {
35078         PRINT_SPACE
35079         _OUT << "\"pNext\":"
35080              << "\"NULL\""
35081              << "," << std::endl;
35082     }
35083 
35084     print_VkPipelineStageFlags2KHR(obj.srcStageMask, "srcStageMask", 1);
35085 
35086     print_VkAccessFlags2KHR(obj.srcAccessMask, "srcAccessMask", 1);
35087 
35088     print_VkPipelineStageFlags2KHR(obj.dstStageMask, "dstStageMask", 1);
35089 
35090     print_VkAccessFlags2KHR(obj.dstAccessMask, "dstAccessMask", 1);
35091 
35092     print_uint32_t(obj.srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
35093 
35094     print_uint32_t(obj.dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
35095 
35096     // CTS : required value
35097     PRINT_SPACE _OUT << "\""
35098                      << "buffer"
35099                      << "\""
35100                      << " : "
35101                      << "\""
35102                      << "\"," << std::endl;
35103 
35104     print_VkDeviceSize(obj.offset, "offset", 1);
35105 
35106     print_VkDeviceSize(obj.size, "size", 0);
35107 
35108     INDENT(-4);
35109     PRINT_SPACE
35110     if (commaNeeded)
35111         _OUT << "}," << std::endl;
35112     else
35113         _OUT << "}" << std::endl;
35114 }
print_VkBufferMemoryBarrier2KHR(const VkBufferMemoryBarrier2KHR * obj,const std::string & s,bool commaNeeded=true)35115 static void print_VkBufferMemoryBarrier2KHR(const VkBufferMemoryBarrier2KHR *obj, const std::string &s,
35116                                             bool commaNeeded = true)
35117 {
35118     PRINT_SPACE
35119     _OUT << "{" << std::endl;
35120     INDENT(4);
35121 
35122     print_VkStructureType(obj->sType, "sType", 1);
35123 
35124     if (obj->pNext)
35125     {
35126         dumpPNextChain(obj->pNext);
35127     }
35128     else
35129     {
35130         PRINT_SPACE
35131         _OUT << "\"pNext\":"
35132              << "\"NULL\""
35133              << "," << std::endl;
35134     }
35135 
35136     print_VkPipelineStageFlags2KHR(obj->srcStageMask, "srcStageMask", 1);
35137 
35138     print_VkAccessFlags2KHR(obj->srcAccessMask, "srcAccessMask", 1);
35139 
35140     print_VkPipelineStageFlags2KHR(obj->dstStageMask, "dstStageMask", 1);
35141 
35142     print_VkAccessFlags2KHR(obj->dstAccessMask, "dstAccessMask", 1);
35143 
35144     print_uint32_t(obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
35145 
35146     print_uint32_t(obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
35147 
35148     // CTS : required value
35149     PRINT_SPACE _OUT << "\""
35150                      << "buffer"
35151                      << "\""
35152                      << " : "
35153                      << "\""
35154                      << "\"," << std::endl;
35155 
35156     print_VkDeviceSize(obj->offset, "offset", 1);
35157 
35158     print_VkDeviceSize(obj->size, "size", 0);
35159 
35160     INDENT(-4);
35161     PRINT_SPACE
35162     if (commaNeeded)
35163         _OUT << "}," << std::endl;
35164     else
35165         _OUT << "}" << std::endl;
35166 }
35167 
print_VkImageMemoryBarrier2KHR(VkImageMemoryBarrier2KHR obj,const std::string & s,bool commaNeeded=true)35168 static void print_VkImageMemoryBarrier2KHR(VkImageMemoryBarrier2KHR obj, const std::string &s, bool commaNeeded = true)
35169 {
35170     PRINT_SPACE
35171     _OUT << "{" << std::endl;
35172     INDENT(4);
35173 
35174     print_VkStructureType(obj.sType, "sType", 1);
35175 
35176     if (obj.pNext)
35177     {
35178         dumpPNextChain(obj.pNext);
35179     }
35180     else
35181     {
35182         PRINT_SPACE
35183         _OUT << "\"pNext\":"
35184              << "\"NULL\""
35185              << "," << std::endl;
35186     }
35187 
35188     print_VkPipelineStageFlags2KHR(obj.srcStageMask, "srcStageMask", 1);
35189 
35190     print_VkAccessFlags2KHR(obj.srcAccessMask, "srcAccessMask", 1);
35191 
35192     print_VkPipelineStageFlags2KHR(obj.dstStageMask, "dstStageMask", 1);
35193 
35194     print_VkAccessFlags2KHR(obj.dstAccessMask, "dstAccessMask", 1);
35195 
35196     print_VkImageLayout(obj.oldLayout, "oldLayout", 1);
35197 
35198     print_VkImageLayout(obj.newLayout, "newLayout", 1);
35199 
35200     print_uint32_t(obj.srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
35201 
35202     print_uint32_t(obj.dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
35203 
35204     // CTS : required value
35205     PRINT_SPACE _OUT << "\""
35206                      << "image"
35207                      << "\""
35208                      << " : "
35209                      << "\""
35210                      << "\"," << std::endl;
35211 
35212     PRINT_SPACE
35213     _OUT << "\"subresourceRange\": " << std::endl;
35214     {
35215         print_VkImageSubresourceRange(obj.subresourceRange, "subresourceRange", 0);
35216     }
35217 
35218     INDENT(-4);
35219     PRINT_SPACE
35220     if (commaNeeded)
35221         _OUT << "}," << std::endl;
35222     else
35223         _OUT << "}" << std::endl;
35224 }
print_VkImageMemoryBarrier2KHR(const VkImageMemoryBarrier2KHR * obj,const std::string & s,bool commaNeeded=true)35225 static void print_VkImageMemoryBarrier2KHR(const VkImageMemoryBarrier2KHR *obj, const std::string &s,
35226                                            bool commaNeeded = true)
35227 {
35228     PRINT_SPACE
35229     _OUT << "{" << std::endl;
35230     INDENT(4);
35231 
35232     print_VkStructureType(obj->sType, "sType", 1);
35233 
35234     if (obj->pNext)
35235     {
35236         dumpPNextChain(obj->pNext);
35237     }
35238     else
35239     {
35240         PRINT_SPACE
35241         _OUT << "\"pNext\":"
35242              << "\"NULL\""
35243              << "," << std::endl;
35244     }
35245 
35246     print_VkPipelineStageFlags2KHR(obj->srcStageMask, "srcStageMask", 1);
35247 
35248     print_VkAccessFlags2KHR(obj->srcAccessMask, "srcAccessMask", 1);
35249 
35250     print_VkPipelineStageFlags2KHR(obj->dstStageMask, "dstStageMask", 1);
35251 
35252     print_VkAccessFlags2KHR(obj->dstAccessMask, "dstAccessMask", 1);
35253 
35254     print_VkImageLayout(obj->oldLayout, "oldLayout", 1);
35255 
35256     print_VkImageLayout(obj->newLayout, "newLayout", 1);
35257 
35258     print_uint32_t(obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1);
35259 
35260     print_uint32_t(obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1);
35261 
35262     // CTS : required value
35263     PRINT_SPACE _OUT << "\""
35264                      << "image"
35265                      << "\""
35266                      << " : "
35267                      << "\""
35268                      << "\"," << std::endl;
35269 
35270     PRINT_SPACE
35271     _OUT << "\"subresourceRange\": " << std::endl;
35272     {
35273         print_VkImageSubresourceRange(obj->subresourceRange, "subresourceRange", 0);
35274     }
35275 
35276     INDENT(-4);
35277     PRINT_SPACE
35278     if (commaNeeded)
35279         _OUT << "}," << std::endl;
35280     else
35281         _OUT << "}" << std::endl;
35282 }
35283 
print_VkDependencyInfoKHR(VkDependencyInfoKHR obj,const std::string & s,bool commaNeeded=true)35284 static void print_VkDependencyInfoKHR(VkDependencyInfoKHR obj, const std::string &s, bool commaNeeded = true)
35285 {
35286     PRINT_SPACE
35287     _OUT << "{" << std::endl;
35288     INDENT(4);
35289 
35290     print_VkStructureType(obj.sType, "sType", 1);
35291 
35292     if (obj.pNext)
35293     {
35294         dumpPNextChain(obj.pNext);
35295     }
35296     else
35297     {
35298         PRINT_SPACE
35299         _OUT << "\"pNext\":"
35300              << "\"NULL\""
35301              << "," << std::endl;
35302     }
35303 
35304     print_VkDependencyFlags(obj.dependencyFlags, "dependencyFlags", 1);
35305 
35306     print_uint32_t(obj.memoryBarrierCount, "memoryBarrierCount", 1);
35307 
35308     PRINT_SPACE
35309     _OUT << "\"pMemoryBarriers\": " << std::endl;
35310     if (obj.pMemoryBarriers)
35311     {
35312         PRINT_SPACE
35313         _OUT << "[" << std::endl;
35314         for (unsigned int i = 0; i < obj.memoryBarrierCount; i++)
35315         {
35316             if (i + 1 == obj.memoryBarrierCount)
35317                 print_VkMemoryBarrier2KHR(obj.pMemoryBarriers[i], "pMemoryBarriers", 0);
35318             else
35319                 print_VkMemoryBarrier2KHR(obj.pMemoryBarriers[i], "pMemoryBarriers", 1);
35320         }
35321         PRINT_SPACE
35322         _OUT << "]," << std::endl;
35323     }
35324     else
35325     {
35326         PRINT_SPACE _OUT << "\"NULL\""
35327                          << "," << std::endl;
35328     }
35329 
35330     print_uint32_t(obj.bufferMemoryBarrierCount, "bufferMemoryBarrierCount", 1);
35331 
35332     PRINT_SPACE
35333     _OUT << "\"pBufferMemoryBarriers\": " << std::endl;
35334     if (obj.pBufferMemoryBarriers)
35335     {
35336         PRINT_SPACE
35337         _OUT << "[" << std::endl;
35338         for (unsigned int i = 0; i < obj.bufferMemoryBarrierCount; i++)
35339         {
35340             if (i + 1 == obj.bufferMemoryBarrierCount)
35341                 print_VkBufferMemoryBarrier2KHR(obj.pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 0);
35342             else
35343                 print_VkBufferMemoryBarrier2KHR(obj.pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 1);
35344         }
35345         PRINT_SPACE
35346         _OUT << "]," << std::endl;
35347     }
35348     else
35349     {
35350         PRINT_SPACE _OUT << "\"NULL\""
35351                          << "," << std::endl;
35352     }
35353 
35354     print_uint32_t(obj.imageMemoryBarrierCount, "imageMemoryBarrierCount", 1);
35355 
35356     PRINT_SPACE
35357     _OUT << "\"pImageMemoryBarriers\": " << std::endl;
35358     if (obj.pImageMemoryBarriers)
35359     {
35360         PRINT_SPACE
35361         _OUT << "[" << std::endl;
35362         for (unsigned int i = 0; i < obj.imageMemoryBarrierCount; i++)
35363         {
35364             if (i + 1 == obj.imageMemoryBarrierCount)
35365                 print_VkImageMemoryBarrier2KHR(obj.pImageMemoryBarriers[i], "pImageMemoryBarriers", 0);
35366             else
35367                 print_VkImageMemoryBarrier2KHR(obj.pImageMemoryBarriers[i], "pImageMemoryBarriers", 1);
35368         }
35369         PRINT_SPACE
35370         _OUT << "]" << std::endl;
35371     }
35372     else
35373     {
35374         PRINT_SPACE _OUT << "\"NULL\""
35375                          << "" << std::endl;
35376     }
35377 
35378     INDENT(-4);
35379     PRINT_SPACE
35380     if (commaNeeded)
35381         _OUT << "}," << std::endl;
35382     else
35383         _OUT << "}" << std::endl;
35384 }
print_VkDependencyInfoKHR(const VkDependencyInfoKHR * obj,const std::string & s,bool commaNeeded=true)35385 static void print_VkDependencyInfoKHR(const VkDependencyInfoKHR *obj, const std::string &s, bool commaNeeded = true)
35386 {
35387     PRINT_SPACE
35388     _OUT << "{" << std::endl;
35389     INDENT(4);
35390 
35391     print_VkStructureType(obj->sType, "sType", 1);
35392 
35393     if (obj->pNext)
35394     {
35395         dumpPNextChain(obj->pNext);
35396     }
35397     else
35398     {
35399         PRINT_SPACE
35400         _OUT << "\"pNext\":"
35401              << "\"NULL\""
35402              << "," << std::endl;
35403     }
35404 
35405     print_VkDependencyFlags(obj->dependencyFlags, "dependencyFlags", 1);
35406 
35407     print_uint32_t(obj->memoryBarrierCount, "memoryBarrierCount", 1);
35408 
35409     PRINT_SPACE
35410     _OUT << "\"pMemoryBarriers\": " << std::endl;
35411     if (obj->pMemoryBarriers)
35412     {
35413         PRINT_SPACE
35414         _OUT << "[" << std::endl;
35415         for (unsigned int i = 0; i < obj->memoryBarrierCount; i++)
35416         {
35417             if (i + 1 == obj->memoryBarrierCount)
35418                 print_VkMemoryBarrier2KHR(obj->pMemoryBarriers[i], "pMemoryBarriers", 0);
35419             else
35420                 print_VkMemoryBarrier2KHR(obj->pMemoryBarriers[i], "pMemoryBarriers", 1);
35421         }
35422         PRINT_SPACE
35423         _OUT << "]," << std::endl;
35424     }
35425     else
35426     {
35427         PRINT_SPACE _OUT << "\"NULL\""
35428                          << "," << std::endl;
35429     }
35430 
35431     print_uint32_t(obj->bufferMemoryBarrierCount, "bufferMemoryBarrierCount", 1);
35432 
35433     PRINT_SPACE
35434     _OUT << "\"pBufferMemoryBarriers\": " << std::endl;
35435     if (obj->pBufferMemoryBarriers)
35436     {
35437         PRINT_SPACE
35438         _OUT << "[" << std::endl;
35439         for (unsigned int i = 0; i < obj->bufferMemoryBarrierCount; i++)
35440         {
35441             if (i + 1 == obj->bufferMemoryBarrierCount)
35442                 print_VkBufferMemoryBarrier2KHR(obj->pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 0);
35443             else
35444                 print_VkBufferMemoryBarrier2KHR(obj->pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 1);
35445         }
35446         PRINT_SPACE
35447         _OUT << "]," << std::endl;
35448     }
35449     else
35450     {
35451         PRINT_SPACE _OUT << "\"NULL\""
35452                          << "," << std::endl;
35453     }
35454 
35455     print_uint32_t(obj->imageMemoryBarrierCount, "imageMemoryBarrierCount", 1);
35456 
35457     PRINT_SPACE
35458     _OUT << "\"pImageMemoryBarriers\": " << std::endl;
35459     if (obj->pImageMemoryBarriers)
35460     {
35461         PRINT_SPACE
35462         _OUT << "[" << std::endl;
35463         for (unsigned int i = 0; i < obj->imageMemoryBarrierCount; i++)
35464         {
35465             if (i + 1 == obj->imageMemoryBarrierCount)
35466                 print_VkImageMemoryBarrier2KHR(obj->pImageMemoryBarriers[i], "pImageMemoryBarriers", 0);
35467             else
35468                 print_VkImageMemoryBarrier2KHR(obj->pImageMemoryBarriers[i], "pImageMemoryBarriers", 1);
35469         }
35470         PRINT_SPACE
35471         _OUT << "]" << std::endl;
35472     }
35473     else
35474     {
35475         PRINT_SPACE _OUT << "\"NULL\""
35476                          << "" << std::endl;
35477     }
35478 
35479     INDENT(-4);
35480     PRINT_SPACE
35481     if (commaNeeded)
35482         _OUT << "}," << std::endl;
35483     else
35484         _OUT << "}" << std::endl;
35485 }
35486 
print_VkSemaphoreSubmitInfoKHR(VkSemaphoreSubmitInfoKHR obj,const std::string & s,bool commaNeeded=true)35487 static void print_VkSemaphoreSubmitInfoKHR(VkSemaphoreSubmitInfoKHR obj, const std::string &s, bool commaNeeded = true)
35488 {
35489     PRINT_SPACE
35490     _OUT << "{" << std::endl;
35491     INDENT(4);
35492 
35493     print_VkStructureType(obj.sType, "sType", 1);
35494 
35495     if (obj.pNext)
35496     {
35497         dumpPNextChain(obj.pNext);
35498     }
35499     else
35500     {
35501         PRINT_SPACE
35502         _OUT << "\"pNext\":"
35503              << "\"NULL\""
35504              << "," << std::endl;
35505     }
35506 
35507     // CTS : required value
35508     PRINT_SPACE _OUT << "\""
35509                      << "semaphore"
35510                      << "\""
35511                      << " : "
35512                      << "\""
35513                      << "\"," << std::endl;
35514 
35515     print_uint64_t(obj.value, "value", 1);
35516 
35517     print_VkPipelineStageFlags2KHR(obj.stageMask, "stageMask", 1);
35518 
35519     print_uint32_t(obj.deviceIndex, "deviceIndex", 0);
35520 
35521     INDENT(-4);
35522     PRINT_SPACE
35523     if (commaNeeded)
35524         _OUT << "}," << std::endl;
35525     else
35526         _OUT << "}" << std::endl;
35527 }
print_VkSemaphoreSubmitInfoKHR(const VkSemaphoreSubmitInfoKHR * obj,const std::string & s,bool commaNeeded=true)35528 static void print_VkSemaphoreSubmitInfoKHR(const VkSemaphoreSubmitInfoKHR *obj, const std::string &s,
35529                                            bool commaNeeded = true)
35530 {
35531     PRINT_SPACE
35532     _OUT << "{" << std::endl;
35533     INDENT(4);
35534 
35535     print_VkStructureType(obj->sType, "sType", 1);
35536 
35537     if (obj->pNext)
35538     {
35539         dumpPNextChain(obj->pNext);
35540     }
35541     else
35542     {
35543         PRINT_SPACE
35544         _OUT << "\"pNext\":"
35545              << "\"NULL\""
35546              << "," << std::endl;
35547     }
35548 
35549     // CTS : required value
35550     PRINT_SPACE _OUT << "\""
35551                      << "semaphore"
35552                      << "\""
35553                      << " : "
35554                      << "\""
35555                      << "\"," << std::endl;
35556 
35557     print_uint64_t(obj->value, "value", 1);
35558 
35559     print_VkPipelineStageFlags2KHR(obj->stageMask, "stageMask", 1);
35560 
35561     print_uint32_t(obj->deviceIndex, "deviceIndex", 0);
35562 
35563     INDENT(-4);
35564     PRINT_SPACE
35565     if (commaNeeded)
35566         _OUT << "}," << std::endl;
35567     else
35568         _OUT << "}" << std::endl;
35569 }
35570 
print_VkCommandBufferSubmitInfoKHR(VkCommandBufferSubmitInfoKHR obj,const std::string & s,bool commaNeeded=true)35571 static void print_VkCommandBufferSubmitInfoKHR(VkCommandBufferSubmitInfoKHR obj, const std::string &s,
35572                                                bool commaNeeded = true)
35573 {
35574     PRINT_SPACE
35575     _OUT << "{" << std::endl;
35576     INDENT(4);
35577 
35578     print_VkStructureType(obj.sType, "sType", 1);
35579 
35580     if (obj.pNext)
35581     {
35582         dumpPNextChain(obj.pNext);
35583     }
35584     else
35585     {
35586         PRINT_SPACE
35587         _OUT << "\"pNext\":"
35588              << "\"NULL\""
35589              << "," << std::endl;
35590     }
35591 
35592     // CTS : required value
35593     PRINT_SPACE _OUT << "\""
35594                      << "commandBuffer"
35595                      << "\""
35596                      << " : "
35597                      << "\""
35598                      << "\"," << std::endl;
35599 
35600     print_uint32_t(obj.deviceMask, "deviceMask", 0);
35601 
35602     INDENT(-4);
35603     PRINT_SPACE
35604     if (commaNeeded)
35605         _OUT << "}," << std::endl;
35606     else
35607         _OUT << "}" << std::endl;
35608 }
print_VkCommandBufferSubmitInfoKHR(const VkCommandBufferSubmitInfoKHR * obj,const std::string & s,bool commaNeeded=true)35609 static void print_VkCommandBufferSubmitInfoKHR(const VkCommandBufferSubmitInfoKHR *obj, const std::string &s,
35610                                                bool commaNeeded = true)
35611 {
35612     PRINT_SPACE
35613     _OUT << "{" << std::endl;
35614     INDENT(4);
35615 
35616     print_VkStructureType(obj->sType, "sType", 1);
35617 
35618     if (obj->pNext)
35619     {
35620         dumpPNextChain(obj->pNext);
35621     }
35622     else
35623     {
35624         PRINT_SPACE
35625         _OUT << "\"pNext\":"
35626              << "\"NULL\""
35627              << "," << std::endl;
35628     }
35629 
35630     // CTS : required value
35631     PRINT_SPACE _OUT << "\""
35632                      << "commandBuffer"
35633                      << "\""
35634                      << " : "
35635                      << "\""
35636                      << "\"," << std::endl;
35637 
35638     print_uint32_t(obj->deviceMask, "deviceMask", 0);
35639 
35640     INDENT(-4);
35641     PRINT_SPACE
35642     if (commaNeeded)
35643         _OUT << "}," << std::endl;
35644     else
35645         _OUT << "}" << std::endl;
35646 }
35647 
print_VkSubmitInfo2KHR(VkSubmitInfo2KHR obj,const std::string & s,bool commaNeeded=true)35648 static void print_VkSubmitInfo2KHR(VkSubmitInfo2KHR obj, const std::string &s, bool commaNeeded = true)
35649 {
35650     PRINT_SPACE
35651     _OUT << "{" << std::endl;
35652     INDENT(4);
35653 
35654     print_VkStructureType(obj.sType, "sType", 1);
35655 
35656     if (obj.pNext)
35657     {
35658         dumpPNextChain(obj.pNext);
35659     }
35660     else
35661     {
35662         PRINT_SPACE
35663         _OUT << "\"pNext\":"
35664              << "\"NULL\""
35665              << "," << std::endl;
35666     }
35667 
35668     print_VkSubmitFlagsKHR(obj.flags, "flags", 1);
35669 
35670     print_uint32_t(obj.waitSemaphoreInfoCount, "waitSemaphoreInfoCount", 1);
35671 
35672     PRINT_SPACE
35673     _OUT << "\"pWaitSemaphoreInfos\": " << std::endl;
35674     if (obj.pWaitSemaphoreInfos)
35675     {
35676         PRINT_SPACE
35677         _OUT << "[" << std::endl;
35678         for (unsigned int i = 0; i < obj.waitSemaphoreInfoCount; i++)
35679         {
35680             if (i + 1 == obj.waitSemaphoreInfoCount)
35681                 print_VkSemaphoreSubmitInfoKHR(obj.pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 0);
35682             else
35683                 print_VkSemaphoreSubmitInfoKHR(obj.pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 1);
35684         }
35685         PRINT_SPACE
35686         _OUT << "]," << std::endl;
35687     }
35688     else
35689     {
35690         PRINT_SPACE _OUT << "\"NULL\""
35691                          << "," << std::endl;
35692     }
35693 
35694     print_uint32_t(obj.commandBufferInfoCount, "commandBufferInfoCount", 1);
35695 
35696     PRINT_SPACE
35697     _OUT << "\"pCommandBufferInfos\": " << std::endl;
35698     if (obj.pCommandBufferInfos)
35699     {
35700         PRINT_SPACE
35701         _OUT << "[" << std::endl;
35702         for (unsigned int i = 0; i < obj.commandBufferInfoCount; i++)
35703         {
35704             if (i + 1 == obj.commandBufferInfoCount)
35705                 print_VkCommandBufferSubmitInfoKHR(obj.pCommandBufferInfos[i], "pCommandBufferInfos", 0);
35706             else
35707                 print_VkCommandBufferSubmitInfoKHR(obj.pCommandBufferInfos[i], "pCommandBufferInfos", 1);
35708         }
35709         PRINT_SPACE
35710         _OUT << "]," << std::endl;
35711     }
35712     else
35713     {
35714         PRINT_SPACE _OUT << "\"NULL\""
35715                          << "," << std::endl;
35716     }
35717 
35718     print_uint32_t(obj.signalSemaphoreInfoCount, "signalSemaphoreInfoCount", 1);
35719 
35720     PRINT_SPACE
35721     _OUT << "\"pSignalSemaphoreInfos\": " << std::endl;
35722     if (obj.pSignalSemaphoreInfos)
35723     {
35724         PRINT_SPACE
35725         _OUT << "[" << std::endl;
35726         for (unsigned int i = 0; i < obj.signalSemaphoreInfoCount; i++)
35727         {
35728             if (i + 1 == obj.signalSemaphoreInfoCount)
35729                 print_VkSemaphoreSubmitInfoKHR(obj.pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 0);
35730             else
35731                 print_VkSemaphoreSubmitInfoKHR(obj.pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 1);
35732         }
35733         PRINT_SPACE
35734         _OUT << "]" << std::endl;
35735     }
35736     else
35737     {
35738         PRINT_SPACE _OUT << "\"NULL\""
35739                          << "" << std::endl;
35740     }
35741 
35742     INDENT(-4);
35743     PRINT_SPACE
35744     if (commaNeeded)
35745         _OUT << "}," << std::endl;
35746     else
35747         _OUT << "}" << std::endl;
35748 }
print_VkSubmitInfo2KHR(const VkSubmitInfo2KHR * obj,const std::string & s,bool commaNeeded=true)35749 static void print_VkSubmitInfo2KHR(const VkSubmitInfo2KHR *obj, const std::string &s, bool commaNeeded = true)
35750 {
35751     PRINT_SPACE
35752     _OUT << "{" << std::endl;
35753     INDENT(4);
35754 
35755     print_VkStructureType(obj->sType, "sType", 1);
35756 
35757     if (obj->pNext)
35758     {
35759         dumpPNextChain(obj->pNext);
35760     }
35761     else
35762     {
35763         PRINT_SPACE
35764         _OUT << "\"pNext\":"
35765              << "\"NULL\""
35766              << "," << std::endl;
35767     }
35768 
35769     print_VkSubmitFlagsKHR(obj->flags, "flags", 1);
35770 
35771     print_uint32_t(obj->waitSemaphoreInfoCount, "waitSemaphoreInfoCount", 1);
35772 
35773     PRINT_SPACE
35774     _OUT << "\"pWaitSemaphoreInfos\": " << std::endl;
35775     if (obj->pWaitSemaphoreInfos)
35776     {
35777         PRINT_SPACE
35778         _OUT << "[" << std::endl;
35779         for (unsigned int i = 0; i < obj->waitSemaphoreInfoCount; i++)
35780         {
35781             if (i + 1 == obj->waitSemaphoreInfoCount)
35782                 print_VkSemaphoreSubmitInfoKHR(obj->pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 0);
35783             else
35784                 print_VkSemaphoreSubmitInfoKHR(obj->pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 1);
35785         }
35786         PRINT_SPACE
35787         _OUT << "]," << std::endl;
35788     }
35789     else
35790     {
35791         PRINT_SPACE _OUT << "\"NULL\""
35792                          << "," << std::endl;
35793     }
35794 
35795     print_uint32_t(obj->commandBufferInfoCount, "commandBufferInfoCount", 1);
35796 
35797     PRINT_SPACE
35798     _OUT << "\"pCommandBufferInfos\": " << std::endl;
35799     if (obj->pCommandBufferInfos)
35800     {
35801         PRINT_SPACE
35802         _OUT << "[" << std::endl;
35803         for (unsigned int i = 0; i < obj->commandBufferInfoCount; i++)
35804         {
35805             if (i + 1 == obj->commandBufferInfoCount)
35806                 print_VkCommandBufferSubmitInfoKHR(obj->pCommandBufferInfos[i], "pCommandBufferInfos", 0);
35807             else
35808                 print_VkCommandBufferSubmitInfoKHR(obj->pCommandBufferInfos[i], "pCommandBufferInfos", 1);
35809         }
35810         PRINT_SPACE
35811         _OUT << "]," << std::endl;
35812     }
35813     else
35814     {
35815         PRINT_SPACE _OUT << "\"NULL\""
35816                          << "," << std::endl;
35817     }
35818 
35819     print_uint32_t(obj->signalSemaphoreInfoCount, "signalSemaphoreInfoCount", 1);
35820 
35821     PRINT_SPACE
35822     _OUT << "\"pSignalSemaphoreInfos\": " << std::endl;
35823     if (obj->pSignalSemaphoreInfos)
35824     {
35825         PRINT_SPACE
35826         _OUT << "[" << std::endl;
35827         for (unsigned int i = 0; i < obj->signalSemaphoreInfoCount; i++)
35828         {
35829             if (i + 1 == obj->signalSemaphoreInfoCount)
35830                 print_VkSemaphoreSubmitInfoKHR(obj->pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 0);
35831             else
35832                 print_VkSemaphoreSubmitInfoKHR(obj->pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 1);
35833         }
35834         PRINT_SPACE
35835         _OUT << "]" << std::endl;
35836     }
35837     else
35838     {
35839         PRINT_SPACE _OUT << "\"NULL\""
35840                          << "" << std::endl;
35841     }
35842 
35843     INDENT(-4);
35844     PRINT_SPACE
35845     if (commaNeeded)
35846         _OUT << "}," << std::endl;
35847     else
35848         _OUT << "}" << std::endl;
35849 }
35850 
print_VkPhysicalDeviceSynchronization2FeaturesKHR(VkPhysicalDeviceSynchronization2FeaturesKHR obj,const std::string & s,bool commaNeeded=true)35851 static void print_VkPhysicalDeviceSynchronization2FeaturesKHR(VkPhysicalDeviceSynchronization2FeaturesKHR obj,
35852                                                               const std::string &s, bool commaNeeded = true)
35853 {
35854     PRINT_SPACE
35855     _OUT << "{" << std::endl;
35856     INDENT(4);
35857 
35858     print_VkStructureType(obj.sType, "sType", 1);
35859 
35860     if (obj.pNext)
35861     {
35862         dumpPNextChain(obj.pNext);
35863     }
35864     else
35865     {
35866         PRINT_SPACE
35867         _OUT << "\"pNext\":"
35868              << "\"NULL\""
35869              << "," << std::endl;
35870     }
35871 
35872     print_VkBool32(obj.synchronization2, "synchronization2", 0);
35873 
35874     INDENT(-4);
35875     PRINT_SPACE
35876     if (commaNeeded)
35877         _OUT << "}," << std::endl;
35878     else
35879         _OUT << "}" << std::endl;
35880 }
print_VkPhysicalDeviceSynchronization2FeaturesKHR(const VkPhysicalDeviceSynchronization2FeaturesKHR * obj,const std::string & s,bool commaNeeded=true)35881 static void print_VkPhysicalDeviceSynchronization2FeaturesKHR(const VkPhysicalDeviceSynchronization2FeaturesKHR *obj,
35882                                                               const std::string &s, bool commaNeeded = true)
35883 {
35884     PRINT_SPACE
35885     _OUT << "{" << std::endl;
35886     INDENT(4);
35887 
35888     print_VkStructureType(obj->sType, "sType", 1);
35889 
35890     if (obj->pNext)
35891     {
35892         dumpPNextChain(obj->pNext);
35893     }
35894     else
35895     {
35896         PRINT_SPACE
35897         _OUT << "\"pNext\":"
35898              << "\"NULL\""
35899              << "," << std::endl;
35900     }
35901 
35902     print_VkBool32(obj->synchronization2, "synchronization2", 0);
35903 
35904     INDENT(-4);
35905     PRINT_SPACE
35906     if (commaNeeded)
35907         _OUT << "}," << std::endl;
35908     else
35909         _OUT << "}" << std::endl;
35910 }
35911 
print_VkQueueFamilyCheckpointProperties2NV(VkQueueFamilyCheckpointProperties2NV obj,const std::string & s,bool commaNeeded=true)35912 static void print_VkQueueFamilyCheckpointProperties2NV(VkQueueFamilyCheckpointProperties2NV obj, const std::string &s,
35913                                                        bool commaNeeded = true)
35914 {
35915     PRINT_SPACE
35916     _OUT << "{" << std::endl;
35917     INDENT(4);
35918 
35919     print_VkStructureType(obj.sType, "sType", 1);
35920 
35921     if (obj.pNext)
35922     {
35923         dumpPNextChain(obj.pNext);
35924     }
35925     else
35926     {
35927         PRINT_SPACE
35928         _OUT << "\"pNext\":"
35929              << "\"NULL\""
35930              << "," << std::endl;
35931     }
35932 
35933     print_VkPipelineStageFlags2KHR(obj.checkpointExecutionStageMask, "checkpointExecutionStageMask", 0);
35934 
35935     INDENT(-4);
35936     PRINT_SPACE
35937     if (commaNeeded)
35938         _OUT << "}," << std::endl;
35939     else
35940         _OUT << "}" << std::endl;
35941 }
print_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV * obj,const std::string & s,bool commaNeeded=true)35942 static void print_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV *obj,
35943                                                        const std::string &s, bool commaNeeded = true)
35944 {
35945     PRINT_SPACE
35946     _OUT << "{" << std::endl;
35947     INDENT(4);
35948 
35949     print_VkStructureType(obj->sType, "sType", 1);
35950 
35951     if (obj->pNext)
35952     {
35953         dumpPNextChain(obj->pNext);
35954     }
35955     else
35956     {
35957         PRINT_SPACE
35958         _OUT << "\"pNext\":"
35959              << "\"NULL\""
35960              << "," << std::endl;
35961     }
35962 
35963     print_VkPipelineStageFlags2KHR(obj->checkpointExecutionStageMask, "checkpointExecutionStageMask", 0);
35964 
35965     INDENT(-4);
35966     PRINT_SPACE
35967     if (commaNeeded)
35968         _OUT << "}," << std::endl;
35969     else
35970         _OUT << "}" << std::endl;
35971 }
35972 
print_VkCheckpointData2NV(VkCheckpointData2NV obj,const std::string & s,bool commaNeeded=true)35973 static void print_VkCheckpointData2NV(VkCheckpointData2NV obj, const std::string &s, bool commaNeeded = true)
35974 {
35975     PRINT_SPACE
35976     _OUT << "{" << std::endl;
35977     INDENT(4);
35978 
35979     print_VkStructureType(obj.sType, "sType", 1);
35980 
35981     if (obj.pNext)
35982     {
35983         dumpPNextChain(obj.pNext);
35984     }
35985     else
35986     {
35987         PRINT_SPACE
35988         _OUT << "\"pNext\":"
35989              << "\"NULL\""
35990              << "," << std::endl;
35991     }
35992 
35993     print_VkPipelineStageFlags2KHR(obj.stage, "stage", 1);
35994 
35995     /** Note: Ignoring void* data. **/
35996 
35997     INDENT(-4);
35998     PRINT_SPACE
35999     if (commaNeeded)
36000         _OUT << "}," << std::endl;
36001     else
36002         _OUT << "}" << std::endl;
36003 }
print_VkCheckpointData2NV(const VkCheckpointData2NV * obj,const std::string & s,bool commaNeeded=true)36004 static void print_VkCheckpointData2NV(const VkCheckpointData2NV *obj, const std::string &s, bool commaNeeded = true)
36005 {
36006     PRINT_SPACE
36007     _OUT << "{" << std::endl;
36008     INDENT(4);
36009 
36010     print_VkStructureType(obj->sType, "sType", 1);
36011 
36012     if (obj->pNext)
36013     {
36014         dumpPNextChain(obj->pNext);
36015     }
36016     else
36017     {
36018         PRINT_SPACE
36019         _OUT << "\"pNext\":"
36020              << "\"NULL\""
36021              << "," << std::endl;
36022     }
36023 
36024     print_VkPipelineStageFlags2KHR(obj->stage, "stage", 1);
36025 
36026     /** Note: Ignoring void* data. **/
36027 
36028     INDENT(-4);
36029     PRINT_SPACE
36030     if (commaNeeded)
36031         _OUT << "}," << std::endl;
36032     else
36033         _OUT << "}" << std::endl;
36034 }
36035 
print_VkBufferCopy2KHR(VkBufferCopy2KHR obj,const std::string & s,bool commaNeeded=true)36036 static void print_VkBufferCopy2KHR(VkBufferCopy2KHR obj, const std::string &s, bool commaNeeded = true)
36037 {
36038     PRINT_SPACE
36039     _OUT << "{" << std::endl;
36040     INDENT(4);
36041 
36042     print_VkStructureType(obj.sType, "sType", 1);
36043 
36044     if (obj.pNext)
36045     {
36046         dumpPNextChain(obj.pNext);
36047     }
36048     else
36049     {
36050         PRINT_SPACE
36051         _OUT << "\"pNext\":"
36052              << "\"NULL\""
36053              << "," << std::endl;
36054     }
36055 
36056     print_VkDeviceSize(obj.srcOffset, "srcOffset", 1);
36057 
36058     print_VkDeviceSize(obj.dstOffset, "dstOffset", 1);
36059 
36060     print_VkDeviceSize(obj.size, "size", 0);
36061 
36062     INDENT(-4);
36063     PRINT_SPACE
36064     if (commaNeeded)
36065         _OUT << "}," << std::endl;
36066     else
36067         _OUT << "}" << std::endl;
36068 }
print_VkBufferCopy2KHR(const VkBufferCopy2KHR * obj,const std::string & s,bool commaNeeded=true)36069 static void print_VkBufferCopy2KHR(const VkBufferCopy2KHR *obj, const std::string &s, bool commaNeeded = true)
36070 {
36071     PRINT_SPACE
36072     _OUT << "{" << std::endl;
36073     INDENT(4);
36074 
36075     print_VkStructureType(obj->sType, "sType", 1);
36076 
36077     if (obj->pNext)
36078     {
36079         dumpPNextChain(obj->pNext);
36080     }
36081     else
36082     {
36083         PRINT_SPACE
36084         _OUT << "\"pNext\":"
36085              << "\"NULL\""
36086              << "," << std::endl;
36087     }
36088 
36089     print_VkDeviceSize(obj->srcOffset, "srcOffset", 1);
36090 
36091     print_VkDeviceSize(obj->dstOffset, "dstOffset", 1);
36092 
36093     print_VkDeviceSize(obj->size, "size", 0);
36094 
36095     INDENT(-4);
36096     PRINT_SPACE
36097     if (commaNeeded)
36098         _OUT << "}," << std::endl;
36099     else
36100         _OUT << "}" << std::endl;
36101 }
36102 
print_VkCopyBufferInfo2KHR(VkCopyBufferInfo2KHR obj,const std::string & s,bool commaNeeded=true)36103 static void print_VkCopyBufferInfo2KHR(VkCopyBufferInfo2KHR obj, const std::string &s, bool commaNeeded = true)
36104 {
36105     PRINT_SPACE
36106     _OUT << "{" << std::endl;
36107     INDENT(4);
36108 
36109     print_VkStructureType(obj.sType, "sType", 1);
36110 
36111     if (obj.pNext)
36112     {
36113         dumpPNextChain(obj.pNext);
36114     }
36115     else
36116     {
36117         PRINT_SPACE
36118         _OUT << "\"pNext\":"
36119              << "\"NULL\""
36120              << "," << std::endl;
36121     }
36122 
36123     // CTS : required value
36124     PRINT_SPACE _OUT << "\""
36125                      << "srcBuffer"
36126                      << "\""
36127                      << " : "
36128                      << "\""
36129                      << "\"," << std::endl;
36130 
36131     // CTS : required value
36132     PRINT_SPACE _OUT << "\""
36133                      << "dstBuffer"
36134                      << "\""
36135                      << " : "
36136                      << "\""
36137                      << "\"," << std::endl;
36138 
36139     print_uint32_t(obj.regionCount, "regionCount", 1);
36140 
36141     PRINT_SPACE
36142     _OUT << "\"pRegions\": " << std::endl;
36143     if (obj.pRegions)
36144     {
36145         PRINT_SPACE
36146         _OUT << "[" << std::endl;
36147         for (unsigned int i = 0; i < obj.regionCount; i++)
36148         {
36149             if (i + 1 == obj.regionCount)
36150                 print_VkBufferCopy2KHR(obj.pRegions[i], "pRegions", 0);
36151             else
36152                 print_VkBufferCopy2KHR(obj.pRegions[i], "pRegions", 1);
36153         }
36154         PRINT_SPACE
36155         _OUT << "]" << std::endl;
36156     }
36157     else
36158     {
36159         PRINT_SPACE _OUT << "\"NULL\""
36160                          << "" << std::endl;
36161     }
36162 
36163     INDENT(-4);
36164     PRINT_SPACE
36165     if (commaNeeded)
36166         _OUT << "}," << std::endl;
36167     else
36168         _OUT << "}" << std::endl;
36169 }
print_VkCopyBufferInfo2KHR(const VkCopyBufferInfo2KHR * obj,const std::string & s,bool commaNeeded=true)36170 static void print_VkCopyBufferInfo2KHR(const VkCopyBufferInfo2KHR *obj, const std::string &s, bool commaNeeded = true)
36171 {
36172     PRINT_SPACE
36173     _OUT << "{" << std::endl;
36174     INDENT(4);
36175 
36176     print_VkStructureType(obj->sType, "sType", 1);
36177 
36178     if (obj->pNext)
36179     {
36180         dumpPNextChain(obj->pNext);
36181     }
36182     else
36183     {
36184         PRINT_SPACE
36185         _OUT << "\"pNext\":"
36186              << "\"NULL\""
36187              << "," << std::endl;
36188     }
36189 
36190     // CTS : required value
36191     PRINT_SPACE _OUT << "\""
36192                      << "srcBuffer"
36193                      << "\""
36194                      << " : "
36195                      << "\""
36196                      << "\"," << std::endl;
36197 
36198     // CTS : required value
36199     PRINT_SPACE _OUT << "\""
36200                      << "dstBuffer"
36201                      << "\""
36202                      << " : "
36203                      << "\""
36204                      << "\"," << std::endl;
36205 
36206     print_uint32_t(obj->regionCount, "regionCount", 1);
36207 
36208     PRINT_SPACE
36209     _OUT << "\"pRegions\": " << std::endl;
36210     if (obj->pRegions)
36211     {
36212         PRINT_SPACE
36213         _OUT << "[" << std::endl;
36214         for (unsigned int i = 0; i < obj->regionCount; i++)
36215         {
36216             if (i + 1 == obj->regionCount)
36217                 print_VkBufferCopy2KHR(obj->pRegions[i], "pRegions", 0);
36218             else
36219                 print_VkBufferCopy2KHR(obj->pRegions[i], "pRegions", 1);
36220         }
36221         PRINT_SPACE
36222         _OUT << "]" << std::endl;
36223     }
36224     else
36225     {
36226         PRINT_SPACE _OUT << "\"NULL\""
36227                          << "" << std::endl;
36228     }
36229 
36230     INDENT(-4);
36231     PRINT_SPACE
36232     if (commaNeeded)
36233         _OUT << "}," << std::endl;
36234     else
36235         _OUT << "}" << std::endl;
36236 }
36237 
print_VkImageCopy2KHR(VkImageCopy2KHR obj,const std::string & s,bool commaNeeded=true)36238 static void print_VkImageCopy2KHR(VkImageCopy2KHR obj, const std::string &s, bool commaNeeded = true)
36239 {
36240     PRINT_SPACE
36241     _OUT << "{" << std::endl;
36242     INDENT(4);
36243 
36244     print_VkStructureType(obj.sType, "sType", 1);
36245 
36246     if (obj.pNext)
36247     {
36248         dumpPNextChain(obj.pNext);
36249     }
36250     else
36251     {
36252         PRINT_SPACE
36253         _OUT << "\"pNext\":"
36254              << "\"NULL\""
36255              << "," << std::endl;
36256     }
36257 
36258     PRINT_SPACE
36259     _OUT << "\"srcSubresource\": " << std::endl;
36260     {
36261         print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1);
36262     }
36263 
36264     PRINT_SPACE
36265     _OUT << "\"srcOffset\": " << std::endl;
36266     {
36267         print_VkOffset3D(obj.srcOffset, "srcOffset", 1);
36268     }
36269 
36270     PRINT_SPACE
36271     _OUT << "\"dstSubresource\": " << std::endl;
36272     {
36273         print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1);
36274     }
36275 
36276     PRINT_SPACE
36277     _OUT << "\"dstOffset\": " << std::endl;
36278     {
36279         print_VkOffset3D(obj.dstOffset, "dstOffset", 1);
36280     }
36281 
36282     PRINT_SPACE
36283     _OUT << "\"extent\": " << std::endl;
36284     {
36285         print_VkExtent3D(obj.extent, "extent", 0);
36286     }
36287 
36288     INDENT(-4);
36289     PRINT_SPACE
36290     if (commaNeeded)
36291         _OUT << "}," << std::endl;
36292     else
36293         _OUT << "}" << std::endl;
36294 }
print_VkImageCopy2KHR(const VkImageCopy2KHR * obj,const std::string & s,bool commaNeeded=true)36295 static void print_VkImageCopy2KHR(const VkImageCopy2KHR *obj, const std::string &s, bool commaNeeded = true)
36296 {
36297     PRINT_SPACE
36298     _OUT << "{" << std::endl;
36299     INDENT(4);
36300 
36301     print_VkStructureType(obj->sType, "sType", 1);
36302 
36303     if (obj->pNext)
36304     {
36305         dumpPNextChain(obj->pNext);
36306     }
36307     else
36308     {
36309         PRINT_SPACE
36310         _OUT << "\"pNext\":"
36311              << "\"NULL\""
36312              << "," << std::endl;
36313     }
36314 
36315     PRINT_SPACE
36316     _OUT << "\"srcSubresource\": " << std::endl;
36317     {
36318         print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1);
36319     }
36320 
36321     PRINT_SPACE
36322     _OUT << "\"srcOffset\": " << std::endl;
36323     {
36324         print_VkOffset3D(obj->srcOffset, "srcOffset", 1);
36325     }
36326 
36327     PRINT_SPACE
36328     _OUT << "\"dstSubresource\": " << std::endl;
36329     {
36330         print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1);
36331     }
36332 
36333     PRINT_SPACE
36334     _OUT << "\"dstOffset\": " << std::endl;
36335     {
36336         print_VkOffset3D(obj->dstOffset, "dstOffset", 1);
36337     }
36338 
36339     PRINT_SPACE
36340     _OUT << "\"extent\": " << std::endl;
36341     {
36342         print_VkExtent3D(obj->extent, "extent", 0);
36343     }
36344 
36345     INDENT(-4);
36346     PRINT_SPACE
36347     if (commaNeeded)
36348         _OUT << "}," << std::endl;
36349     else
36350         _OUT << "}" << std::endl;
36351 }
36352 
print_VkCopyImageInfo2KHR(VkCopyImageInfo2KHR obj,const std::string & s,bool commaNeeded=true)36353 static void print_VkCopyImageInfo2KHR(VkCopyImageInfo2KHR obj, const std::string &s, bool commaNeeded = true)
36354 {
36355     PRINT_SPACE
36356     _OUT << "{" << std::endl;
36357     INDENT(4);
36358 
36359     print_VkStructureType(obj.sType, "sType", 1);
36360 
36361     if (obj.pNext)
36362     {
36363         dumpPNextChain(obj.pNext);
36364     }
36365     else
36366     {
36367         PRINT_SPACE
36368         _OUT << "\"pNext\":"
36369              << "\"NULL\""
36370              << "," << std::endl;
36371     }
36372 
36373     // CTS : required value
36374     PRINT_SPACE _OUT << "\""
36375                      << "srcImage"
36376                      << "\""
36377                      << " : "
36378                      << "\""
36379                      << "\"," << std::endl;
36380 
36381     print_VkImageLayout(obj.srcImageLayout, "srcImageLayout", 1);
36382 
36383     // CTS : required value
36384     PRINT_SPACE _OUT << "\""
36385                      << "dstImage"
36386                      << "\""
36387                      << " : "
36388                      << "\""
36389                      << "\"," << std::endl;
36390 
36391     print_VkImageLayout(obj.dstImageLayout, "dstImageLayout", 1);
36392 
36393     print_uint32_t(obj.regionCount, "regionCount", 1);
36394 
36395     PRINT_SPACE
36396     _OUT << "\"pRegions\": " << std::endl;
36397     if (obj.pRegions)
36398     {
36399         PRINT_SPACE
36400         _OUT << "[" << std::endl;
36401         for (unsigned int i = 0; i < obj.regionCount; i++)
36402         {
36403             if (i + 1 == obj.regionCount)
36404                 print_VkImageCopy2KHR(obj.pRegions[i], "pRegions", 0);
36405             else
36406                 print_VkImageCopy2KHR(obj.pRegions[i], "pRegions", 1);
36407         }
36408         PRINT_SPACE
36409         _OUT << "]" << std::endl;
36410     }
36411     else
36412     {
36413         PRINT_SPACE _OUT << "\"NULL\""
36414                          << "" << std::endl;
36415     }
36416 
36417     INDENT(-4);
36418     PRINT_SPACE
36419     if (commaNeeded)
36420         _OUT << "}," << std::endl;
36421     else
36422         _OUT << "}" << std::endl;
36423 }
print_VkCopyImageInfo2KHR(const VkCopyImageInfo2KHR * obj,const std::string & s,bool commaNeeded=true)36424 static void print_VkCopyImageInfo2KHR(const VkCopyImageInfo2KHR *obj, const std::string &s, bool commaNeeded = true)
36425 {
36426     PRINT_SPACE
36427     _OUT << "{" << std::endl;
36428     INDENT(4);
36429 
36430     print_VkStructureType(obj->sType, "sType", 1);
36431 
36432     if (obj->pNext)
36433     {
36434         dumpPNextChain(obj->pNext);
36435     }
36436     else
36437     {
36438         PRINT_SPACE
36439         _OUT << "\"pNext\":"
36440              << "\"NULL\""
36441              << "," << std::endl;
36442     }
36443 
36444     // CTS : required value
36445     PRINT_SPACE _OUT << "\""
36446                      << "srcImage"
36447                      << "\""
36448                      << " : "
36449                      << "\""
36450                      << "\"," << std::endl;
36451 
36452     print_VkImageLayout(obj->srcImageLayout, "srcImageLayout", 1);
36453 
36454     // CTS : required value
36455     PRINT_SPACE _OUT << "\""
36456                      << "dstImage"
36457                      << "\""
36458                      << " : "
36459                      << "\""
36460                      << "\"," << std::endl;
36461 
36462     print_VkImageLayout(obj->dstImageLayout, "dstImageLayout", 1);
36463 
36464     print_uint32_t(obj->regionCount, "regionCount", 1);
36465 
36466     PRINT_SPACE
36467     _OUT << "\"pRegions\": " << std::endl;
36468     if (obj->pRegions)
36469     {
36470         PRINT_SPACE
36471         _OUT << "[" << std::endl;
36472         for (unsigned int i = 0; i < obj->regionCount; i++)
36473         {
36474             if (i + 1 == obj->regionCount)
36475                 print_VkImageCopy2KHR(obj->pRegions[i], "pRegions", 0);
36476             else
36477                 print_VkImageCopy2KHR(obj->pRegions[i], "pRegions", 1);
36478         }
36479         PRINT_SPACE
36480         _OUT << "]" << std::endl;
36481     }
36482     else
36483     {
36484         PRINT_SPACE _OUT << "\"NULL\""
36485                          << "" << std::endl;
36486     }
36487 
36488     INDENT(-4);
36489     PRINT_SPACE
36490     if (commaNeeded)
36491         _OUT << "}," << std::endl;
36492     else
36493         _OUT << "}" << std::endl;
36494 }
36495 
print_VkBufferImageCopy2KHR(VkBufferImageCopy2KHR obj,const std::string & s,bool commaNeeded=true)36496 static void print_VkBufferImageCopy2KHR(VkBufferImageCopy2KHR obj, const std::string &s, bool commaNeeded = true)
36497 {
36498     PRINT_SPACE
36499     _OUT << "{" << std::endl;
36500     INDENT(4);
36501 
36502     print_VkStructureType(obj.sType, "sType", 1);
36503 
36504     if (obj.pNext)
36505     {
36506         dumpPNextChain(obj.pNext);
36507     }
36508     else
36509     {
36510         PRINT_SPACE
36511         _OUT << "\"pNext\":"
36512              << "\"NULL\""
36513              << "," << std::endl;
36514     }
36515 
36516     print_VkDeviceSize(obj.bufferOffset, "bufferOffset", 1);
36517 
36518     print_uint32_t(obj.bufferRowLength, "bufferRowLength", 1);
36519 
36520     print_uint32_t(obj.bufferImageHeight, "bufferImageHeight", 1);
36521 
36522     PRINT_SPACE
36523     _OUT << "\"imageSubresource\": " << std::endl;
36524     {
36525         print_VkImageSubresourceLayers(obj.imageSubresource, "imageSubresource", 1);
36526     }
36527 
36528     PRINT_SPACE
36529     _OUT << "\"imageOffset\": " << std::endl;
36530     {
36531         print_VkOffset3D(obj.imageOffset, "imageOffset", 1);
36532     }
36533 
36534     PRINT_SPACE
36535     _OUT << "\"imageExtent\": " << std::endl;
36536     {
36537         print_VkExtent3D(obj.imageExtent, "imageExtent", 0);
36538     }
36539 
36540     INDENT(-4);
36541     PRINT_SPACE
36542     if (commaNeeded)
36543         _OUT << "}," << std::endl;
36544     else
36545         _OUT << "}" << std::endl;
36546 }
print_VkBufferImageCopy2KHR(const VkBufferImageCopy2KHR * obj,const std::string & s,bool commaNeeded=true)36547 static void print_VkBufferImageCopy2KHR(const VkBufferImageCopy2KHR *obj, const std::string &s, bool commaNeeded = true)
36548 {
36549     PRINT_SPACE
36550     _OUT << "{" << std::endl;
36551     INDENT(4);
36552 
36553     print_VkStructureType(obj->sType, "sType", 1);
36554 
36555     if (obj->pNext)
36556     {
36557         dumpPNextChain(obj->pNext);
36558     }
36559     else
36560     {
36561         PRINT_SPACE
36562         _OUT << "\"pNext\":"
36563              << "\"NULL\""
36564              << "," << std::endl;
36565     }
36566 
36567     print_VkDeviceSize(obj->bufferOffset, "bufferOffset", 1);
36568 
36569     print_uint32_t(obj->bufferRowLength, "bufferRowLength", 1);
36570 
36571     print_uint32_t(obj->bufferImageHeight, "bufferImageHeight", 1);
36572 
36573     PRINT_SPACE
36574     _OUT << "\"imageSubresource\": " << std::endl;
36575     {
36576         print_VkImageSubresourceLayers(obj->imageSubresource, "imageSubresource", 1);
36577     }
36578 
36579     PRINT_SPACE
36580     _OUT << "\"imageOffset\": " << std::endl;
36581     {
36582         print_VkOffset3D(obj->imageOffset, "imageOffset", 1);
36583     }
36584 
36585     PRINT_SPACE
36586     _OUT << "\"imageExtent\": " << std::endl;
36587     {
36588         print_VkExtent3D(obj->imageExtent, "imageExtent", 0);
36589     }
36590 
36591     INDENT(-4);
36592     PRINT_SPACE
36593     if (commaNeeded)
36594         _OUT << "}," << std::endl;
36595     else
36596         _OUT << "}" << std::endl;
36597 }
36598 
print_VkCopyBufferToImageInfo2KHR(VkCopyBufferToImageInfo2KHR obj,const std::string & s,bool commaNeeded=true)36599 static void print_VkCopyBufferToImageInfo2KHR(VkCopyBufferToImageInfo2KHR obj, const std::string &s,
36600                                               bool commaNeeded = true)
36601 {
36602     PRINT_SPACE
36603     _OUT << "{" << std::endl;
36604     INDENT(4);
36605 
36606     print_VkStructureType(obj.sType, "sType", 1);
36607 
36608     if (obj.pNext)
36609     {
36610         dumpPNextChain(obj.pNext);
36611     }
36612     else
36613     {
36614         PRINT_SPACE
36615         _OUT << "\"pNext\":"
36616              << "\"NULL\""
36617              << "," << std::endl;
36618     }
36619 
36620     // CTS : required value
36621     PRINT_SPACE _OUT << "\""
36622                      << "srcBuffer"
36623                      << "\""
36624                      << " : "
36625                      << "\""
36626                      << "\"," << std::endl;
36627 
36628     // CTS : required value
36629     PRINT_SPACE _OUT << "\""
36630                      << "dstImage"
36631                      << "\""
36632                      << " : "
36633                      << "\""
36634                      << "\"," << std::endl;
36635 
36636     print_VkImageLayout(obj.dstImageLayout, "dstImageLayout", 1);
36637 
36638     print_uint32_t(obj.regionCount, "regionCount", 1);
36639 
36640     PRINT_SPACE
36641     _OUT << "\"pRegions\": " << std::endl;
36642     if (obj.pRegions)
36643     {
36644         PRINT_SPACE
36645         _OUT << "[" << std::endl;
36646         for (unsigned int i = 0; i < obj.regionCount; i++)
36647         {
36648             if (i + 1 == obj.regionCount)
36649                 print_VkBufferImageCopy2KHR(obj.pRegions[i], "pRegions", 0);
36650             else
36651                 print_VkBufferImageCopy2KHR(obj.pRegions[i], "pRegions", 1);
36652         }
36653         PRINT_SPACE
36654         _OUT << "]" << std::endl;
36655     }
36656     else
36657     {
36658         PRINT_SPACE _OUT << "\"NULL\""
36659                          << "" << std::endl;
36660     }
36661 
36662     INDENT(-4);
36663     PRINT_SPACE
36664     if (commaNeeded)
36665         _OUT << "}," << std::endl;
36666     else
36667         _OUT << "}" << std::endl;
36668 }
print_VkCopyBufferToImageInfo2KHR(const VkCopyBufferToImageInfo2KHR * obj,const std::string & s,bool commaNeeded=true)36669 static void print_VkCopyBufferToImageInfo2KHR(const VkCopyBufferToImageInfo2KHR *obj, const std::string &s,
36670                                               bool commaNeeded = true)
36671 {
36672     PRINT_SPACE
36673     _OUT << "{" << std::endl;
36674     INDENT(4);
36675 
36676     print_VkStructureType(obj->sType, "sType", 1);
36677 
36678     if (obj->pNext)
36679     {
36680         dumpPNextChain(obj->pNext);
36681     }
36682     else
36683     {
36684         PRINT_SPACE
36685         _OUT << "\"pNext\":"
36686              << "\"NULL\""
36687              << "," << std::endl;
36688     }
36689 
36690     // CTS : required value
36691     PRINT_SPACE _OUT << "\""
36692                      << "srcBuffer"
36693                      << "\""
36694                      << " : "
36695                      << "\""
36696                      << "\"," << std::endl;
36697 
36698     // CTS : required value
36699     PRINT_SPACE _OUT << "\""
36700                      << "dstImage"
36701                      << "\""
36702                      << " : "
36703                      << "\""
36704                      << "\"," << std::endl;
36705 
36706     print_VkImageLayout(obj->dstImageLayout, "dstImageLayout", 1);
36707 
36708     print_uint32_t(obj->regionCount, "regionCount", 1);
36709 
36710     PRINT_SPACE
36711     _OUT << "\"pRegions\": " << std::endl;
36712     if (obj->pRegions)
36713     {
36714         PRINT_SPACE
36715         _OUT << "[" << std::endl;
36716         for (unsigned int i = 0; i < obj->regionCount; i++)
36717         {
36718             if (i + 1 == obj->regionCount)
36719                 print_VkBufferImageCopy2KHR(obj->pRegions[i], "pRegions", 0);
36720             else
36721                 print_VkBufferImageCopy2KHR(obj->pRegions[i], "pRegions", 1);
36722         }
36723         PRINT_SPACE
36724         _OUT << "]" << std::endl;
36725     }
36726     else
36727     {
36728         PRINT_SPACE _OUT << "\"NULL\""
36729                          << "" << std::endl;
36730     }
36731 
36732     INDENT(-4);
36733     PRINT_SPACE
36734     if (commaNeeded)
36735         _OUT << "}," << std::endl;
36736     else
36737         _OUT << "}" << std::endl;
36738 }
36739 
print_VkCopyImageToBufferInfo2KHR(VkCopyImageToBufferInfo2KHR obj,const std::string & s,bool commaNeeded=true)36740 static void print_VkCopyImageToBufferInfo2KHR(VkCopyImageToBufferInfo2KHR obj, const std::string &s,
36741                                               bool commaNeeded = true)
36742 {
36743     PRINT_SPACE
36744     _OUT << "{" << std::endl;
36745     INDENT(4);
36746 
36747     print_VkStructureType(obj.sType, "sType", 1);
36748 
36749     if (obj.pNext)
36750     {
36751         dumpPNextChain(obj.pNext);
36752     }
36753     else
36754     {
36755         PRINT_SPACE
36756         _OUT << "\"pNext\":"
36757              << "\"NULL\""
36758              << "," << std::endl;
36759     }
36760 
36761     // CTS : required value
36762     PRINT_SPACE _OUT << "\""
36763                      << "srcImage"
36764                      << "\""
36765                      << " : "
36766                      << "\""
36767                      << "\"," << std::endl;
36768 
36769     print_VkImageLayout(obj.srcImageLayout, "srcImageLayout", 1);
36770 
36771     // CTS : required value
36772     PRINT_SPACE _OUT << "\""
36773                      << "dstBuffer"
36774                      << "\""
36775                      << " : "
36776                      << "\""
36777                      << "\"," << std::endl;
36778 
36779     print_uint32_t(obj.regionCount, "regionCount", 1);
36780 
36781     PRINT_SPACE
36782     _OUT << "\"pRegions\": " << std::endl;
36783     if (obj.pRegions)
36784     {
36785         PRINT_SPACE
36786         _OUT << "[" << std::endl;
36787         for (unsigned int i = 0; i < obj.regionCount; i++)
36788         {
36789             if (i + 1 == obj.regionCount)
36790                 print_VkBufferImageCopy2KHR(obj.pRegions[i], "pRegions", 0);
36791             else
36792                 print_VkBufferImageCopy2KHR(obj.pRegions[i], "pRegions", 1);
36793         }
36794         PRINT_SPACE
36795         _OUT << "]" << std::endl;
36796     }
36797     else
36798     {
36799         PRINT_SPACE _OUT << "\"NULL\""
36800                          << "" << std::endl;
36801     }
36802 
36803     INDENT(-4);
36804     PRINT_SPACE
36805     if (commaNeeded)
36806         _OUT << "}," << std::endl;
36807     else
36808         _OUT << "}" << std::endl;
36809 }
print_VkCopyImageToBufferInfo2KHR(const VkCopyImageToBufferInfo2KHR * obj,const std::string & s,bool commaNeeded=true)36810 static void print_VkCopyImageToBufferInfo2KHR(const VkCopyImageToBufferInfo2KHR *obj, const std::string &s,
36811                                               bool commaNeeded = true)
36812 {
36813     PRINT_SPACE
36814     _OUT << "{" << std::endl;
36815     INDENT(4);
36816 
36817     print_VkStructureType(obj->sType, "sType", 1);
36818 
36819     if (obj->pNext)
36820     {
36821         dumpPNextChain(obj->pNext);
36822     }
36823     else
36824     {
36825         PRINT_SPACE
36826         _OUT << "\"pNext\":"
36827              << "\"NULL\""
36828              << "," << std::endl;
36829     }
36830 
36831     // CTS : required value
36832     PRINT_SPACE _OUT << "\""
36833                      << "srcImage"
36834                      << "\""
36835                      << " : "
36836                      << "\""
36837                      << "\"," << std::endl;
36838 
36839     print_VkImageLayout(obj->srcImageLayout, "srcImageLayout", 1);
36840 
36841     // CTS : required value
36842     PRINT_SPACE _OUT << "\""
36843                      << "dstBuffer"
36844                      << "\""
36845                      << " : "
36846                      << "\""
36847                      << "\"," << std::endl;
36848 
36849     print_uint32_t(obj->regionCount, "regionCount", 1);
36850 
36851     PRINT_SPACE
36852     _OUT << "\"pRegions\": " << std::endl;
36853     if (obj->pRegions)
36854     {
36855         PRINT_SPACE
36856         _OUT << "[" << std::endl;
36857         for (unsigned int i = 0; i < obj->regionCount; i++)
36858         {
36859             if (i + 1 == obj->regionCount)
36860                 print_VkBufferImageCopy2KHR(obj->pRegions[i], "pRegions", 0);
36861             else
36862                 print_VkBufferImageCopy2KHR(obj->pRegions[i], "pRegions", 1);
36863         }
36864         PRINT_SPACE
36865         _OUT << "]" << std::endl;
36866     }
36867     else
36868     {
36869         PRINT_SPACE _OUT << "\"NULL\""
36870                          << "" << std::endl;
36871     }
36872 
36873     INDENT(-4);
36874     PRINT_SPACE
36875     if (commaNeeded)
36876         _OUT << "}," << std::endl;
36877     else
36878         _OUT << "}" << std::endl;
36879 }
36880 
print_VkImageBlit2KHR(VkImageBlit2KHR obj,const std::string & s,bool commaNeeded=true)36881 static void print_VkImageBlit2KHR(VkImageBlit2KHR obj, const std::string &s, bool commaNeeded = true)
36882 {
36883     PRINT_SPACE
36884     _OUT << "{" << std::endl;
36885     INDENT(4);
36886 
36887     print_VkStructureType(obj.sType, "sType", 1);
36888 
36889     if (obj.pNext)
36890     {
36891         dumpPNextChain(obj.pNext);
36892     }
36893     else
36894     {
36895         PRINT_SPACE
36896         _OUT << "\"pNext\":"
36897              << "\"NULL\""
36898              << "," << std::endl;
36899     }
36900 
36901     PRINT_SPACE
36902     _OUT << "\"srcSubresource\": " << std::endl;
36903     {
36904         print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1);
36905     }
36906 
36907     PRINT_SPACE
36908     _OUT << "\"srcOffsets\":" << std::endl;
36909     PRINT_SPACE
36910     _OUT << "[" << std::endl;
36911     for (unsigned int i = 0; i < 2; i++)
36912     {
36913         bool isCommaNeeded = (i + 1) != 2;
36914         print_VkOffset3D(obj.srcOffsets[i], "", isCommaNeeded);
36915     }
36916     PRINT_SPACE
36917     _OUT << "]"
36918          << "," << std::endl;
36919 
36920     PRINT_SPACE
36921     _OUT << "\"dstSubresource\": " << std::endl;
36922     {
36923         print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1);
36924     }
36925 
36926     PRINT_SPACE
36927     _OUT << "\"dstOffsets\":" << std::endl;
36928     PRINT_SPACE
36929     _OUT << "[" << std::endl;
36930     for (unsigned int i = 0; i < 2; i++)
36931     {
36932         bool isCommaNeeded = (i + 1) != 2;
36933         print_VkOffset3D(obj.dstOffsets[i], "", isCommaNeeded);
36934     }
36935     PRINT_SPACE
36936     _OUT << "]"
36937          << "" << std::endl;
36938 
36939     INDENT(-4);
36940     PRINT_SPACE
36941     if (commaNeeded)
36942         _OUT << "}," << std::endl;
36943     else
36944         _OUT << "}" << std::endl;
36945 }
print_VkImageBlit2KHR(const VkImageBlit2KHR * obj,const std::string & s,bool commaNeeded=true)36946 static void print_VkImageBlit2KHR(const VkImageBlit2KHR *obj, const std::string &s, bool commaNeeded = true)
36947 {
36948     PRINT_SPACE
36949     _OUT << "{" << std::endl;
36950     INDENT(4);
36951 
36952     print_VkStructureType(obj->sType, "sType", 1);
36953 
36954     if (obj->pNext)
36955     {
36956         dumpPNextChain(obj->pNext);
36957     }
36958     else
36959     {
36960         PRINT_SPACE
36961         _OUT << "\"pNext\":"
36962              << "\"NULL\""
36963              << "," << std::endl;
36964     }
36965 
36966     PRINT_SPACE
36967     _OUT << "\"srcSubresource\": " << std::endl;
36968     {
36969         print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1);
36970     }
36971 
36972     PRINT_SPACE
36973     _OUT << "\"srcOffsets\":" << std::endl;
36974     PRINT_SPACE
36975     _OUT << "[" << std::endl;
36976     for (unsigned int i = 0; i < 2; i++)
36977     {
36978         bool isCommaNeeded = (i + 1) != 2;
36979         print_VkOffset3D(obj->srcOffsets[i], "", isCommaNeeded);
36980     }
36981     PRINT_SPACE
36982     _OUT << "]"
36983          << "," << std::endl;
36984 
36985     PRINT_SPACE
36986     _OUT << "\"dstSubresource\": " << std::endl;
36987     {
36988         print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1);
36989     }
36990 
36991     PRINT_SPACE
36992     _OUT << "\"dstOffsets\":" << std::endl;
36993     PRINT_SPACE
36994     _OUT << "[" << std::endl;
36995     for (unsigned int i = 0; i < 2; i++)
36996     {
36997         bool isCommaNeeded = (i + 1) != 2;
36998         print_VkOffset3D(obj->dstOffsets[i], "", isCommaNeeded);
36999     }
37000     PRINT_SPACE
37001     _OUT << "]"
37002          << "" << std::endl;
37003 
37004     INDENT(-4);
37005     PRINT_SPACE
37006     if (commaNeeded)
37007         _OUT << "}," << std::endl;
37008     else
37009         _OUT << "}" << std::endl;
37010 }
37011 
print_VkBlitImageInfo2KHR(VkBlitImageInfo2KHR obj,const std::string & s,bool commaNeeded=true)37012 static void print_VkBlitImageInfo2KHR(VkBlitImageInfo2KHR obj, const std::string &s, bool commaNeeded = true)
37013 {
37014     PRINT_SPACE
37015     _OUT << "{" << std::endl;
37016     INDENT(4);
37017 
37018     print_VkStructureType(obj.sType, "sType", 1);
37019 
37020     if (obj.pNext)
37021     {
37022         dumpPNextChain(obj.pNext);
37023     }
37024     else
37025     {
37026         PRINT_SPACE
37027         _OUT << "\"pNext\":"
37028              << "\"NULL\""
37029              << "," << std::endl;
37030     }
37031 
37032     // CTS : required value
37033     PRINT_SPACE _OUT << "\""
37034                      << "srcImage"
37035                      << "\""
37036                      << " : "
37037                      << "\""
37038                      << "\"," << std::endl;
37039 
37040     print_VkImageLayout(obj.srcImageLayout, "srcImageLayout", 1);
37041 
37042     // CTS : required value
37043     PRINT_SPACE _OUT << "\""
37044                      << "dstImage"
37045                      << "\""
37046                      << " : "
37047                      << "\""
37048                      << "\"," << std::endl;
37049 
37050     print_VkImageLayout(obj.dstImageLayout, "dstImageLayout", 1);
37051 
37052     print_uint32_t(obj.regionCount, "regionCount", 1);
37053 
37054     PRINT_SPACE
37055     _OUT << "\"pRegions\": " << std::endl;
37056     if (obj.pRegions)
37057     {
37058         PRINT_SPACE
37059         _OUT << "[" << std::endl;
37060         for (unsigned int i = 0; i < obj.regionCount; i++)
37061         {
37062             if (i + 1 == obj.regionCount)
37063                 print_VkImageBlit2KHR(obj.pRegions[i], "pRegions", 0);
37064             else
37065                 print_VkImageBlit2KHR(obj.pRegions[i], "pRegions", 1);
37066         }
37067         PRINT_SPACE
37068         _OUT << "]," << std::endl;
37069     }
37070     else
37071     {
37072         PRINT_SPACE _OUT << "\"NULL\""
37073                          << "," << std::endl;
37074     }
37075 
37076     print_VkFilter(obj.filter, "filter", 0);
37077 
37078     INDENT(-4);
37079     PRINT_SPACE
37080     if (commaNeeded)
37081         _OUT << "}," << std::endl;
37082     else
37083         _OUT << "}" << std::endl;
37084 }
print_VkBlitImageInfo2KHR(const VkBlitImageInfo2KHR * obj,const std::string & s,bool commaNeeded=true)37085 static void print_VkBlitImageInfo2KHR(const VkBlitImageInfo2KHR *obj, const std::string &s, bool commaNeeded = true)
37086 {
37087     PRINT_SPACE
37088     _OUT << "{" << std::endl;
37089     INDENT(4);
37090 
37091     print_VkStructureType(obj->sType, "sType", 1);
37092 
37093     if (obj->pNext)
37094     {
37095         dumpPNextChain(obj->pNext);
37096     }
37097     else
37098     {
37099         PRINT_SPACE
37100         _OUT << "\"pNext\":"
37101              << "\"NULL\""
37102              << "," << std::endl;
37103     }
37104 
37105     // CTS : required value
37106     PRINT_SPACE _OUT << "\""
37107                      << "srcImage"
37108                      << "\""
37109                      << " : "
37110                      << "\""
37111                      << "\"," << std::endl;
37112 
37113     print_VkImageLayout(obj->srcImageLayout, "srcImageLayout", 1);
37114 
37115     // CTS : required value
37116     PRINT_SPACE _OUT << "\""
37117                      << "dstImage"
37118                      << "\""
37119                      << " : "
37120                      << "\""
37121                      << "\"," << std::endl;
37122 
37123     print_VkImageLayout(obj->dstImageLayout, "dstImageLayout", 1);
37124 
37125     print_uint32_t(obj->regionCount, "regionCount", 1);
37126 
37127     PRINT_SPACE
37128     _OUT << "\"pRegions\": " << std::endl;
37129     if (obj->pRegions)
37130     {
37131         PRINT_SPACE
37132         _OUT << "[" << std::endl;
37133         for (unsigned int i = 0; i < obj->regionCount; i++)
37134         {
37135             if (i + 1 == obj->regionCount)
37136                 print_VkImageBlit2KHR(obj->pRegions[i], "pRegions", 0);
37137             else
37138                 print_VkImageBlit2KHR(obj->pRegions[i], "pRegions", 1);
37139         }
37140         PRINT_SPACE
37141         _OUT << "]," << std::endl;
37142     }
37143     else
37144     {
37145         PRINT_SPACE _OUT << "\"NULL\""
37146                          << "," << std::endl;
37147     }
37148 
37149     print_VkFilter(obj->filter, "filter", 0);
37150 
37151     INDENT(-4);
37152     PRINT_SPACE
37153     if (commaNeeded)
37154         _OUT << "}," << std::endl;
37155     else
37156         _OUT << "}" << std::endl;
37157 }
37158 
print_VkImageResolve2KHR(VkImageResolve2KHR obj,const std::string & s,bool commaNeeded=true)37159 static void print_VkImageResolve2KHR(VkImageResolve2KHR obj, const std::string &s, bool commaNeeded = true)
37160 {
37161     PRINT_SPACE
37162     _OUT << "{" << std::endl;
37163     INDENT(4);
37164 
37165     print_VkStructureType(obj.sType, "sType", 1);
37166 
37167     if (obj.pNext)
37168     {
37169         dumpPNextChain(obj.pNext);
37170     }
37171     else
37172     {
37173         PRINT_SPACE
37174         _OUT << "\"pNext\":"
37175              << "\"NULL\""
37176              << "," << std::endl;
37177     }
37178 
37179     PRINT_SPACE
37180     _OUT << "\"srcSubresource\": " << std::endl;
37181     {
37182         print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1);
37183     }
37184 
37185     PRINT_SPACE
37186     _OUT << "\"srcOffset\": " << std::endl;
37187     {
37188         print_VkOffset3D(obj.srcOffset, "srcOffset", 1);
37189     }
37190 
37191     PRINT_SPACE
37192     _OUT << "\"dstSubresource\": " << std::endl;
37193     {
37194         print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1);
37195     }
37196 
37197     PRINT_SPACE
37198     _OUT << "\"dstOffset\": " << std::endl;
37199     {
37200         print_VkOffset3D(obj.dstOffset, "dstOffset", 1);
37201     }
37202 
37203     PRINT_SPACE
37204     _OUT << "\"extent\": " << std::endl;
37205     {
37206         print_VkExtent3D(obj.extent, "extent", 0);
37207     }
37208 
37209     INDENT(-4);
37210     PRINT_SPACE
37211     if (commaNeeded)
37212         _OUT << "}," << std::endl;
37213     else
37214         _OUT << "}" << std::endl;
37215 }
print_VkImageResolve2KHR(const VkImageResolve2KHR * obj,const std::string & s,bool commaNeeded=true)37216 static void print_VkImageResolve2KHR(const VkImageResolve2KHR *obj, const std::string &s, bool commaNeeded = true)
37217 {
37218     PRINT_SPACE
37219     _OUT << "{" << std::endl;
37220     INDENT(4);
37221 
37222     print_VkStructureType(obj->sType, "sType", 1);
37223 
37224     if (obj->pNext)
37225     {
37226         dumpPNextChain(obj->pNext);
37227     }
37228     else
37229     {
37230         PRINT_SPACE
37231         _OUT << "\"pNext\":"
37232              << "\"NULL\""
37233              << "," << std::endl;
37234     }
37235 
37236     PRINT_SPACE
37237     _OUT << "\"srcSubresource\": " << std::endl;
37238     {
37239         print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1);
37240     }
37241 
37242     PRINT_SPACE
37243     _OUT << "\"srcOffset\": " << std::endl;
37244     {
37245         print_VkOffset3D(obj->srcOffset, "srcOffset", 1);
37246     }
37247 
37248     PRINT_SPACE
37249     _OUT << "\"dstSubresource\": " << std::endl;
37250     {
37251         print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1);
37252     }
37253 
37254     PRINT_SPACE
37255     _OUT << "\"dstOffset\": " << std::endl;
37256     {
37257         print_VkOffset3D(obj->dstOffset, "dstOffset", 1);
37258     }
37259 
37260     PRINT_SPACE
37261     _OUT << "\"extent\": " << std::endl;
37262     {
37263         print_VkExtent3D(obj->extent, "extent", 0);
37264     }
37265 
37266     INDENT(-4);
37267     PRINT_SPACE
37268     if (commaNeeded)
37269         _OUT << "}," << std::endl;
37270     else
37271         _OUT << "}" << std::endl;
37272 }
37273 
print_VkResolveImageInfo2KHR(VkResolveImageInfo2KHR obj,const std::string & s,bool commaNeeded=true)37274 static void print_VkResolveImageInfo2KHR(VkResolveImageInfo2KHR obj, const std::string &s, bool commaNeeded = true)
37275 {
37276     PRINT_SPACE
37277     _OUT << "{" << std::endl;
37278     INDENT(4);
37279 
37280     print_VkStructureType(obj.sType, "sType", 1);
37281 
37282     if (obj.pNext)
37283     {
37284         dumpPNextChain(obj.pNext);
37285     }
37286     else
37287     {
37288         PRINT_SPACE
37289         _OUT << "\"pNext\":"
37290              << "\"NULL\""
37291              << "," << std::endl;
37292     }
37293 
37294     // CTS : required value
37295     PRINT_SPACE _OUT << "\""
37296                      << "srcImage"
37297                      << "\""
37298                      << " : "
37299                      << "\""
37300                      << "\"," << std::endl;
37301 
37302     print_VkImageLayout(obj.srcImageLayout, "srcImageLayout", 1);
37303 
37304     // CTS : required value
37305     PRINT_SPACE _OUT << "\""
37306                      << "dstImage"
37307                      << "\""
37308                      << " : "
37309                      << "\""
37310                      << "\"," << std::endl;
37311 
37312     print_VkImageLayout(obj.dstImageLayout, "dstImageLayout", 1);
37313 
37314     print_uint32_t(obj.regionCount, "regionCount", 1);
37315 
37316     PRINT_SPACE
37317     _OUT << "\"pRegions\": " << std::endl;
37318     if (obj.pRegions)
37319     {
37320         PRINT_SPACE
37321         _OUT << "[" << std::endl;
37322         for (unsigned int i = 0; i < obj.regionCount; i++)
37323         {
37324             if (i + 1 == obj.regionCount)
37325                 print_VkImageResolve2KHR(obj.pRegions[i], "pRegions", 0);
37326             else
37327                 print_VkImageResolve2KHR(obj.pRegions[i], "pRegions", 1);
37328         }
37329         PRINT_SPACE
37330         _OUT << "]" << std::endl;
37331     }
37332     else
37333     {
37334         PRINT_SPACE _OUT << "\"NULL\""
37335                          << "" << std::endl;
37336     }
37337 
37338     INDENT(-4);
37339     PRINT_SPACE
37340     if (commaNeeded)
37341         _OUT << "}," << std::endl;
37342     else
37343         _OUT << "}" << std::endl;
37344 }
print_VkResolveImageInfo2KHR(const VkResolveImageInfo2KHR * obj,const std::string & s,bool commaNeeded=true)37345 static void print_VkResolveImageInfo2KHR(const VkResolveImageInfo2KHR *obj, const std::string &s,
37346                                          bool commaNeeded = true)
37347 {
37348     PRINT_SPACE
37349     _OUT << "{" << std::endl;
37350     INDENT(4);
37351 
37352     print_VkStructureType(obj->sType, "sType", 1);
37353 
37354     if (obj->pNext)
37355     {
37356         dumpPNextChain(obj->pNext);
37357     }
37358     else
37359     {
37360         PRINT_SPACE
37361         _OUT << "\"pNext\":"
37362              << "\"NULL\""
37363              << "," << std::endl;
37364     }
37365 
37366     // CTS : required value
37367     PRINT_SPACE _OUT << "\""
37368                      << "srcImage"
37369                      << "\""
37370                      << " : "
37371                      << "\""
37372                      << "\"," << std::endl;
37373 
37374     print_VkImageLayout(obj->srcImageLayout, "srcImageLayout", 1);
37375 
37376     // CTS : required value
37377     PRINT_SPACE _OUT << "\""
37378                      << "dstImage"
37379                      << "\""
37380                      << " : "
37381                      << "\""
37382                      << "\"," << std::endl;
37383 
37384     print_VkImageLayout(obj->dstImageLayout, "dstImageLayout", 1);
37385 
37386     print_uint32_t(obj->regionCount, "regionCount", 1);
37387 
37388     PRINT_SPACE
37389     _OUT << "\"pRegions\": " << std::endl;
37390     if (obj->pRegions)
37391     {
37392         PRINT_SPACE
37393         _OUT << "[" << std::endl;
37394         for (unsigned int i = 0; i < obj->regionCount; i++)
37395         {
37396             if (i + 1 == obj->regionCount)
37397                 print_VkImageResolve2KHR(obj->pRegions[i], "pRegions", 0);
37398             else
37399                 print_VkImageResolve2KHR(obj->pRegions[i], "pRegions", 1);
37400         }
37401         PRINT_SPACE
37402         _OUT << "]" << std::endl;
37403     }
37404     else
37405     {
37406         PRINT_SPACE _OUT << "\"NULL\""
37407                          << "" << std::endl;
37408     }
37409 
37410     INDENT(-4);
37411     PRINT_SPACE
37412     if (commaNeeded)
37413         _OUT << "}," << std::endl;
37414     else
37415         _OUT << "}" << std::endl;
37416 }
37417 
print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT obj,const std::string & s,bool commaNeeded=true)37418 static void print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
37419     VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT obj, const std::string &s, bool commaNeeded = true)
37420 {
37421     PRINT_SPACE
37422     _OUT << "{" << std::endl;
37423     INDENT(4);
37424 
37425     print_VkStructureType(obj.sType, "sType", 1);
37426 
37427     if (obj.pNext)
37428     {
37429         dumpPNextChain(obj.pNext);
37430     }
37431     else
37432     {
37433         PRINT_SPACE
37434         _OUT << "\"pNext\":"
37435              << "\"NULL\""
37436              << "," << std::endl;
37437     }
37438 
37439     print_VkBool32(obj.textureCompressionASTC_HDR, "textureCompressionASTC_HDR", 0);
37440 
37441     INDENT(-4);
37442     PRINT_SPACE
37443     if (commaNeeded)
37444         _OUT << "}," << std::endl;
37445     else
37446         _OUT << "}" << std::endl;
37447 }
print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)37448 static void print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
37449     const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *obj, const std::string &s, bool commaNeeded = true)
37450 {
37451     PRINT_SPACE
37452     _OUT << "{" << std::endl;
37453     INDENT(4);
37454 
37455     print_VkStructureType(obj->sType, "sType", 1);
37456 
37457     if (obj->pNext)
37458     {
37459         dumpPNextChain(obj->pNext);
37460     }
37461     else
37462     {
37463         PRINT_SPACE
37464         _OUT << "\"pNext\":"
37465              << "\"NULL\""
37466              << "," << std::endl;
37467     }
37468 
37469     print_VkBool32(obj->textureCompressionASTC_HDR, "textureCompressionASTC_HDR", 0);
37470 
37471     INDENT(-4);
37472     PRINT_SPACE
37473     if (commaNeeded)
37474         _OUT << "}," << std::endl;
37475     else
37476         _OUT << "}" << std::endl;
37477 }
37478 
print_VkImageViewASTCDecodeModeEXT(VkImageViewASTCDecodeModeEXT obj,const std::string & s,bool commaNeeded=true)37479 static void print_VkImageViewASTCDecodeModeEXT(VkImageViewASTCDecodeModeEXT obj, const std::string &s,
37480                                                bool commaNeeded = true)
37481 {
37482     PRINT_SPACE
37483     _OUT << "{" << std::endl;
37484     INDENT(4);
37485 
37486     print_VkStructureType(obj.sType, "sType", 1);
37487 
37488     if (obj.pNext)
37489     {
37490         dumpPNextChain(obj.pNext);
37491     }
37492     else
37493     {
37494         PRINT_SPACE
37495         _OUT << "\"pNext\":"
37496              << "\"NULL\""
37497              << "," << std::endl;
37498     }
37499 
37500     print_VkFormat(obj.decodeMode, "decodeMode", 0);
37501 
37502     INDENT(-4);
37503     PRINT_SPACE
37504     if (commaNeeded)
37505         _OUT << "}," << std::endl;
37506     else
37507         _OUT << "}" << std::endl;
37508 }
print_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT * obj,const std::string & s,bool commaNeeded=true)37509 static void print_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT *obj, const std::string &s,
37510                                                bool commaNeeded = true)
37511 {
37512     PRINT_SPACE
37513     _OUT << "{" << std::endl;
37514     INDENT(4);
37515 
37516     print_VkStructureType(obj->sType, "sType", 1);
37517 
37518     if (obj->pNext)
37519     {
37520         dumpPNextChain(obj->pNext);
37521     }
37522     else
37523     {
37524         PRINT_SPACE
37525         _OUT << "\"pNext\":"
37526              << "\"NULL\""
37527              << "," << std::endl;
37528     }
37529 
37530     print_VkFormat(obj->decodeMode, "decodeMode", 0);
37531 
37532     INDENT(-4);
37533     PRINT_SPACE
37534     if (commaNeeded)
37535         _OUT << "}," << std::endl;
37536     else
37537         _OUT << "}" << std::endl;
37538 }
37539 
print_VkPhysicalDeviceASTCDecodeFeaturesEXT(VkPhysicalDeviceASTCDecodeFeaturesEXT obj,const std::string & s,bool commaNeeded=true)37540 static void print_VkPhysicalDeviceASTCDecodeFeaturesEXT(VkPhysicalDeviceASTCDecodeFeaturesEXT obj, const std::string &s,
37541                                                         bool commaNeeded = true)
37542 {
37543     PRINT_SPACE
37544     _OUT << "{" << std::endl;
37545     INDENT(4);
37546 
37547     print_VkStructureType(obj.sType, "sType", 1);
37548 
37549     if (obj.pNext)
37550     {
37551         dumpPNextChain(obj.pNext);
37552     }
37553     else
37554     {
37555         PRINT_SPACE
37556         _OUT << "\"pNext\":"
37557              << "\"NULL\""
37558              << "," << std::endl;
37559     }
37560 
37561     print_VkBool32(obj.decodeModeSharedExponent, "decodeModeSharedExponent", 0);
37562 
37563     INDENT(-4);
37564     PRINT_SPACE
37565     if (commaNeeded)
37566         _OUT << "}," << std::endl;
37567     else
37568         _OUT << "}" << std::endl;
37569 }
print_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)37570 static void print_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT *obj,
37571                                                         const std::string &s, bool commaNeeded = true)
37572 {
37573     PRINT_SPACE
37574     _OUT << "{" << std::endl;
37575     INDENT(4);
37576 
37577     print_VkStructureType(obj->sType, "sType", 1);
37578 
37579     if (obj->pNext)
37580     {
37581         dumpPNextChain(obj->pNext);
37582     }
37583     else
37584     {
37585         PRINT_SPACE
37586         _OUT << "\"pNext\":"
37587              << "\"NULL\""
37588              << "," << std::endl;
37589     }
37590 
37591     print_VkBool32(obj->decodeModeSharedExponent, "decodeModeSharedExponent", 0);
37592 
37593     INDENT(-4);
37594     PRINT_SPACE
37595     if (commaNeeded)
37596         _OUT << "}," << std::endl;
37597     else
37598         _OUT << "}" << std::endl;
37599 }
37600 
37601 static std::map<uint64_t, std::string> VkSurfaceCounterFlagBitsEXT_map = {
37602     std::make_pair(1ULL << 0, "VK_SURFACE_COUNTER_VBLANK_BIT_EXT"),
37603 };
print_VkSurfaceCounterFlagBitsEXT(VkSurfaceCounterFlagBitsEXT obj,const std::string & str,bool commaNeeded=true)37604 static void print_VkSurfaceCounterFlagBitsEXT(VkSurfaceCounterFlagBitsEXT obj, const std::string &str,
37605                                               bool commaNeeded = true)
37606 {
37607     PRINT_SPACE
37608     if (str != "")
37609         _OUT << "\"" << str << "\""
37610              << " : ";
37611     if (commaNeeded)
37612         _OUT << "\"" << VkSurfaceCounterFlagBitsEXT_map[obj] << "\"," << std::endl;
37613     else
37614         _OUT << "\"" << VkSurfaceCounterFlagBitsEXT_map[obj] << "\"" << std::endl;
37615 }
print_VkSurfaceCounterFlagBitsEXT(const VkSurfaceCounterFlagBitsEXT * obj,const std::string & str,bool commaNeeded=true)37616 static void print_VkSurfaceCounterFlagBitsEXT(const VkSurfaceCounterFlagBitsEXT *obj, const std::string &str,
37617                                               bool commaNeeded = true)
37618 {
37619     PRINT_SPACE
37620     if (str != "")
37621         _OUT << "\"" << str << "\""
37622              << " : ";
37623     if (commaNeeded)
37624         _OUT << "\"" << VkSurfaceCounterFlagBitsEXT_map[*obj] << "\"," << std::endl;
37625     else
37626         _OUT << "\"" << VkSurfaceCounterFlagBitsEXT_map[*obj] << "\"" << std::endl;
37627 }
37628 
print_VkSurfaceCounterFlagsEXT(VkSurfaceCounterFlagsEXT obj,const std::string & str,bool commaNeeded=true)37629 static void print_VkSurfaceCounterFlagsEXT(VkSurfaceCounterFlagsEXT obj, const std::string &str,
37630                                            bool commaNeeded = true)
37631 {
37632     PRINT_SPACE
37633     if (str != "")
37634         _OUT << "\"" << str << "\""
37635              << " : ";
37636     const int max_bits = 64; // We don't expect the number to be larger.
37637     std::bitset<max_bits> b(obj);
37638     _OUT << "\"";
37639     if (obj == 0)
37640         _OUT << "0";
37641     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
37642     {
37643         if (b[i] == 1)
37644         {
37645             bitCount++;
37646             if (bitCount < b.count())
37647                 _OUT << VkSurfaceCounterFlagBitsEXT_map[1ULL << i] << " | ";
37648             else
37649                 _OUT << VkSurfaceCounterFlagBitsEXT_map[1ULL << i];
37650         }
37651     }
37652     if (commaNeeded)
37653         _OUT << "\""
37654              << ",";
37655     else
37656         _OUT << "\""
37657              << "";
37658     _OUT << std::endl;
37659 }
print_VkSurfaceCounterFlagsEXT(const VkSurfaceCounterFlagsEXT * obj,const std::string & str,bool commaNeeded=true)37660 static void print_VkSurfaceCounterFlagsEXT(const VkSurfaceCounterFlagsEXT *obj, const std::string &str,
37661                                            bool commaNeeded = true)
37662 {
37663     PRINT_SPACE
37664     if (str != "")
37665         _OUT << "\"" << str << "\""
37666              << " : ";
37667     const int max_bits = 64; // We don't expect the number to be larger.
37668     std::bitset<max_bits> b(obj);
37669     _OUT << "\"";
37670     if (obj == 0)
37671         _OUT << "0";
37672     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
37673     {
37674         if (b[i] == 1)
37675         {
37676             bitCount++;
37677             if (bitCount < b.count())
37678                 _OUT << VkSurfaceCounterFlagBitsEXT_map[1ULL << i] << " | ";
37679             else
37680                 _OUT << VkSurfaceCounterFlagBitsEXT_map[1ULL << i];
37681         }
37682     }
37683     if (commaNeeded)
37684         _OUT << "\""
37685              << ",";
37686     else
37687         _OUT << "\""
37688              << "";
37689     _OUT << std::endl;
37690 }
37691 
print_VkSurfaceCapabilities2EXT(VkSurfaceCapabilities2EXT obj,const std::string & s,bool commaNeeded=true)37692 static void print_VkSurfaceCapabilities2EXT(VkSurfaceCapabilities2EXT obj, const std::string &s,
37693                                             bool commaNeeded = true)
37694 {
37695     PRINT_SPACE
37696     _OUT << "{" << std::endl;
37697     INDENT(4);
37698 
37699     print_VkStructureType(obj.sType, "sType", 1);
37700 
37701     if (obj.pNext)
37702     {
37703         dumpPNextChain(obj.pNext);
37704     }
37705     else
37706     {
37707         PRINT_SPACE
37708         _OUT << "\"pNext\":"
37709              << "\"NULL\""
37710              << "," << std::endl;
37711     }
37712 
37713     print_uint32_t(obj.minImageCount, "minImageCount", 1);
37714 
37715     print_uint32_t(obj.maxImageCount, "maxImageCount", 1);
37716 
37717     PRINT_SPACE
37718     _OUT << "\"currentExtent\": " << std::endl;
37719     {
37720         print_VkExtent2D(obj.currentExtent, "currentExtent", 1);
37721     }
37722 
37723     PRINT_SPACE
37724     _OUT << "\"minImageExtent\": " << std::endl;
37725     {
37726         print_VkExtent2D(obj.minImageExtent, "minImageExtent", 1);
37727     }
37728 
37729     PRINT_SPACE
37730     _OUT << "\"maxImageExtent\": " << std::endl;
37731     {
37732         print_VkExtent2D(obj.maxImageExtent, "maxImageExtent", 1);
37733     }
37734 
37735     print_uint32_t(obj.maxImageArrayLayers, "maxImageArrayLayers", 1);
37736 
37737     print_VkSurfaceTransformFlagsKHR(obj.supportedTransforms, "supportedTransforms", 1);
37738 
37739     print_VkSurfaceTransformFlagBitsKHR(obj.currentTransform, "currentTransform", 1);
37740 
37741     print_VkCompositeAlphaFlagsKHR(obj.supportedCompositeAlpha, "supportedCompositeAlpha", 1);
37742 
37743     print_VkImageUsageFlags(obj.supportedUsageFlags, "supportedUsageFlags", 1);
37744 
37745     print_VkSurfaceCounterFlagsEXT(obj.supportedSurfaceCounters, "supportedSurfaceCounters", 0);
37746 
37747     INDENT(-4);
37748     PRINT_SPACE
37749     if (commaNeeded)
37750         _OUT << "}," << std::endl;
37751     else
37752         _OUT << "}" << std::endl;
37753 }
print_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT * obj,const std::string & s,bool commaNeeded=true)37754 static void print_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT *obj, const std::string &s,
37755                                             bool commaNeeded = true)
37756 {
37757     PRINT_SPACE
37758     _OUT << "{" << std::endl;
37759     INDENT(4);
37760 
37761     print_VkStructureType(obj->sType, "sType", 1);
37762 
37763     if (obj->pNext)
37764     {
37765         dumpPNextChain(obj->pNext);
37766     }
37767     else
37768     {
37769         PRINT_SPACE
37770         _OUT << "\"pNext\":"
37771              << "\"NULL\""
37772              << "," << std::endl;
37773     }
37774 
37775     print_uint32_t(obj->minImageCount, "minImageCount", 1);
37776 
37777     print_uint32_t(obj->maxImageCount, "maxImageCount", 1);
37778 
37779     PRINT_SPACE
37780     _OUT << "\"currentExtent\": " << std::endl;
37781     {
37782         print_VkExtent2D(obj->currentExtent, "currentExtent", 1);
37783     }
37784 
37785     PRINT_SPACE
37786     _OUT << "\"minImageExtent\": " << std::endl;
37787     {
37788         print_VkExtent2D(obj->minImageExtent, "minImageExtent", 1);
37789     }
37790 
37791     PRINT_SPACE
37792     _OUT << "\"maxImageExtent\": " << std::endl;
37793     {
37794         print_VkExtent2D(obj->maxImageExtent, "maxImageExtent", 1);
37795     }
37796 
37797     print_uint32_t(obj->maxImageArrayLayers, "maxImageArrayLayers", 1);
37798 
37799     print_VkSurfaceTransformFlagsKHR(obj->supportedTransforms, "supportedTransforms", 1);
37800 
37801     print_VkSurfaceTransformFlagBitsKHR(obj->currentTransform, "currentTransform", 1);
37802 
37803     print_VkCompositeAlphaFlagsKHR(obj->supportedCompositeAlpha, "supportedCompositeAlpha", 1);
37804 
37805     print_VkImageUsageFlags(obj->supportedUsageFlags, "supportedUsageFlags", 1);
37806 
37807     print_VkSurfaceCounterFlagsEXT(obj->supportedSurfaceCounters, "supportedSurfaceCounters", 0);
37808 
37809     INDENT(-4);
37810     PRINT_SPACE
37811     if (commaNeeded)
37812         _OUT << "}," << std::endl;
37813     else
37814         _OUT << "}" << std::endl;
37815 }
37816 
37817 static std::map<uint64_t, std::string> VkDisplayPowerStateEXT_map = {
37818     std::make_pair(0, "VK_DISPLAY_POWER_STATE_OFF_EXT"),
37819     std::make_pair(1, "VK_DISPLAY_POWER_STATE_SUSPEND_EXT"),
37820     std::make_pair(2, "VK_DISPLAY_POWER_STATE_ON_EXT"),
37821 };
print_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT obj,const std::string & str,bool commaNeeded=true)37822 static void print_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT obj, const std::string &str, bool commaNeeded = true)
37823 {
37824     PRINT_SPACE
37825     if (str != "")
37826         _OUT << "\"" << str << "\""
37827              << " : ";
37828     if (commaNeeded)
37829         _OUT << "\"" << VkDisplayPowerStateEXT_map[obj] << "\"," << std::endl;
37830     else
37831         _OUT << "\"" << VkDisplayPowerStateEXT_map[obj] << "\"" << std::endl;
37832 }
print_VkDisplayPowerStateEXT(const VkDisplayPowerStateEXT * obj,const std::string & str,bool commaNeeded=true)37833 static void print_VkDisplayPowerStateEXT(const VkDisplayPowerStateEXT *obj, const std::string &str,
37834                                          bool commaNeeded = true)
37835 {
37836     PRINT_SPACE
37837     if (str != "")
37838         _OUT << "\"" << str << "\""
37839              << " : ";
37840     if (commaNeeded)
37841         _OUT << "\"" << VkDisplayPowerStateEXT_map[*obj] << "\"," << std::endl;
37842     else
37843         _OUT << "\"" << VkDisplayPowerStateEXT_map[*obj] << "\"" << std::endl;
37844 }
37845 
37846 static std::map<uint64_t, std::string> VkDeviceEventTypeEXT_map = {
37847     std::make_pair(0, "VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT"),
37848 };
print_VkDeviceEventTypeEXT(VkDeviceEventTypeEXT obj,const std::string & str,bool commaNeeded=true)37849 static void print_VkDeviceEventTypeEXT(VkDeviceEventTypeEXT obj, const std::string &str, bool commaNeeded = true)
37850 {
37851     PRINT_SPACE
37852     if (str != "")
37853         _OUT << "\"" << str << "\""
37854              << " : ";
37855     if (commaNeeded)
37856         _OUT << "\"" << VkDeviceEventTypeEXT_map[obj] << "\"," << std::endl;
37857     else
37858         _OUT << "\"" << VkDeviceEventTypeEXT_map[obj] << "\"" << std::endl;
37859 }
print_VkDeviceEventTypeEXT(const VkDeviceEventTypeEXT * obj,const std::string & str,bool commaNeeded=true)37860 static void print_VkDeviceEventTypeEXT(const VkDeviceEventTypeEXT *obj, const std::string &str, bool commaNeeded = true)
37861 {
37862     PRINT_SPACE
37863     if (str != "")
37864         _OUT << "\"" << str << "\""
37865              << " : ";
37866     if (commaNeeded)
37867         _OUT << "\"" << VkDeviceEventTypeEXT_map[*obj] << "\"," << std::endl;
37868     else
37869         _OUT << "\"" << VkDeviceEventTypeEXT_map[*obj] << "\"" << std::endl;
37870 }
37871 
37872 static std::map<uint64_t, std::string> VkDisplayEventTypeEXT_map = {
37873     std::make_pair(0, "VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT"),
37874 };
print_VkDisplayEventTypeEXT(VkDisplayEventTypeEXT obj,const std::string & str,bool commaNeeded=true)37875 static void print_VkDisplayEventTypeEXT(VkDisplayEventTypeEXT obj, const std::string &str, bool commaNeeded = true)
37876 {
37877     PRINT_SPACE
37878     if (str != "")
37879         _OUT << "\"" << str << "\""
37880              << " : ";
37881     if (commaNeeded)
37882         _OUT << "\"" << VkDisplayEventTypeEXT_map[obj] << "\"," << std::endl;
37883     else
37884         _OUT << "\"" << VkDisplayEventTypeEXT_map[obj] << "\"" << std::endl;
37885 }
print_VkDisplayEventTypeEXT(const VkDisplayEventTypeEXT * obj,const std::string & str,bool commaNeeded=true)37886 static void print_VkDisplayEventTypeEXT(const VkDisplayEventTypeEXT *obj, const std::string &str,
37887                                         bool commaNeeded = true)
37888 {
37889     PRINT_SPACE
37890     if (str != "")
37891         _OUT << "\"" << str << "\""
37892              << " : ";
37893     if (commaNeeded)
37894         _OUT << "\"" << VkDisplayEventTypeEXT_map[*obj] << "\"," << std::endl;
37895     else
37896         _OUT << "\"" << VkDisplayEventTypeEXT_map[*obj] << "\"" << std::endl;
37897 }
37898 
print_VkDisplayPowerInfoEXT(VkDisplayPowerInfoEXT obj,const std::string & s,bool commaNeeded=true)37899 static void print_VkDisplayPowerInfoEXT(VkDisplayPowerInfoEXT obj, const std::string &s, bool commaNeeded = true)
37900 {
37901     PRINT_SPACE
37902     _OUT << "{" << std::endl;
37903     INDENT(4);
37904 
37905     print_VkStructureType(obj.sType, "sType", 1);
37906 
37907     if (obj.pNext)
37908     {
37909         dumpPNextChain(obj.pNext);
37910     }
37911     else
37912     {
37913         PRINT_SPACE
37914         _OUT << "\"pNext\":"
37915              << "\"NULL\""
37916              << "," << std::endl;
37917     }
37918 
37919     print_VkDisplayPowerStateEXT(obj.powerState, "powerState", 0);
37920 
37921     INDENT(-4);
37922     PRINT_SPACE
37923     if (commaNeeded)
37924         _OUT << "}," << std::endl;
37925     else
37926         _OUT << "}" << std::endl;
37927 }
print_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT * obj,const std::string & s,bool commaNeeded=true)37928 static void print_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT *obj, const std::string &s, bool commaNeeded = true)
37929 {
37930     PRINT_SPACE
37931     _OUT << "{" << std::endl;
37932     INDENT(4);
37933 
37934     print_VkStructureType(obj->sType, "sType", 1);
37935 
37936     if (obj->pNext)
37937     {
37938         dumpPNextChain(obj->pNext);
37939     }
37940     else
37941     {
37942         PRINT_SPACE
37943         _OUT << "\"pNext\":"
37944              << "\"NULL\""
37945              << "," << std::endl;
37946     }
37947 
37948     print_VkDisplayPowerStateEXT(obj->powerState, "powerState", 0);
37949 
37950     INDENT(-4);
37951     PRINT_SPACE
37952     if (commaNeeded)
37953         _OUT << "}," << std::endl;
37954     else
37955         _OUT << "}" << std::endl;
37956 }
37957 
print_VkDeviceEventInfoEXT(VkDeviceEventInfoEXT obj,const std::string & s,bool commaNeeded=true)37958 static void print_VkDeviceEventInfoEXT(VkDeviceEventInfoEXT obj, const std::string &s, bool commaNeeded = true)
37959 {
37960     PRINT_SPACE
37961     _OUT << "{" << std::endl;
37962     INDENT(4);
37963 
37964     print_VkStructureType(obj.sType, "sType", 1);
37965 
37966     if (obj.pNext)
37967     {
37968         dumpPNextChain(obj.pNext);
37969     }
37970     else
37971     {
37972         PRINT_SPACE
37973         _OUT << "\"pNext\":"
37974              << "\"NULL\""
37975              << "," << std::endl;
37976     }
37977 
37978     print_VkDeviceEventTypeEXT(obj.deviceEvent, "deviceEvent", 0);
37979 
37980     INDENT(-4);
37981     PRINT_SPACE
37982     if (commaNeeded)
37983         _OUT << "}," << std::endl;
37984     else
37985         _OUT << "}" << std::endl;
37986 }
print_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT * obj,const std::string & s,bool commaNeeded=true)37987 static void print_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT *obj, const std::string &s, bool commaNeeded = true)
37988 {
37989     PRINT_SPACE
37990     _OUT << "{" << std::endl;
37991     INDENT(4);
37992 
37993     print_VkStructureType(obj->sType, "sType", 1);
37994 
37995     if (obj->pNext)
37996     {
37997         dumpPNextChain(obj->pNext);
37998     }
37999     else
38000     {
38001         PRINT_SPACE
38002         _OUT << "\"pNext\":"
38003              << "\"NULL\""
38004              << "," << std::endl;
38005     }
38006 
38007     print_VkDeviceEventTypeEXT(obj->deviceEvent, "deviceEvent", 0);
38008 
38009     INDENT(-4);
38010     PRINT_SPACE
38011     if (commaNeeded)
38012         _OUT << "}," << std::endl;
38013     else
38014         _OUT << "}" << std::endl;
38015 }
38016 
print_VkDisplayEventInfoEXT(VkDisplayEventInfoEXT obj,const std::string & s,bool commaNeeded=true)38017 static void print_VkDisplayEventInfoEXT(VkDisplayEventInfoEXT obj, const std::string &s, bool commaNeeded = true)
38018 {
38019     PRINT_SPACE
38020     _OUT << "{" << std::endl;
38021     INDENT(4);
38022 
38023     print_VkStructureType(obj.sType, "sType", 1);
38024 
38025     if (obj.pNext)
38026     {
38027         dumpPNextChain(obj.pNext);
38028     }
38029     else
38030     {
38031         PRINT_SPACE
38032         _OUT << "\"pNext\":"
38033              << "\"NULL\""
38034              << "," << std::endl;
38035     }
38036 
38037     print_VkDisplayEventTypeEXT(obj.displayEvent, "displayEvent", 0);
38038 
38039     INDENT(-4);
38040     PRINT_SPACE
38041     if (commaNeeded)
38042         _OUT << "}," << std::endl;
38043     else
38044         _OUT << "}" << std::endl;
38045 }
print_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT * obj,const std::string & s,bool commaNeeded=true)38046 static void print_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT *obj, const std::string &s, bool commaNeeded = true)
38047 {
38048     PRINT_SPACE
38049     _OUT << "{" << std::endl;
38050     INDENT(4);
38051 
38052     print_VkStructureType(obj->sType, "sType", 1);
38053 
38054     if (obj->pNext)
38055     {
38056         dumpPNextChain(obj->pNext);
38057     }
38058     else
38059     {
38060         PRINT_SPACE
38061         _OUT << "\"pNext\":"
38062              << "\"NULL\""
38063              << "," << std::endl;
38064     }
38065 
38066     print_VkDisplayEventTypeEXT(obj->displayEvent, "displayEvent", 0);
38067 
38068     INDENT(-4);
38069     PRINT_SPACE
38070     if (commaNeeded)
38071         _OUT << "}," << std::endl;
38072     else
38073         _OUT << "}" << std::endl;
38074 }
38075 
print_VkSwapchainCounterCreateInfoEXT(VkSwapchainCounterCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)38076 static void print_VkSwapchainCounterCreateInfoEXT(VkSwapchainCounterCreateInfoEXT obj, const std::string &s,
38077                                                   bool commaNeeded = true)
38078 {
38079     PRINT_SPACE
38080     _OUT << "{" << std::endl;
38081     INDENT(4);
38082 
38083     print_VkStructureType(obj.sType, "sType", 1);
38084 
38085     if (obj.pNext)
38086     {
38087         dumpPNextChain(obj.pNext);
38088     }
38089     else
38090     {
38091         PRINT_SPACE
38092         _OUT << "\"pNext\":"
38093              << "\"NULL\""
38094              << "," << std::endl;
38095     }
38096 
38097     print_VkSurfaceCounterFlagsEXT(obj.surfaceCounters, "surfaceCounters", 0);
38098 
38099     INDENT(-4);
38100     PRINT_SPACE
38101     if (commaNeeded)
38102         _OUT << "}," << std::endl;
38103     else
38104         _OUT << "}" << std::endl;
38105 }
print_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)38106 static void print_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT *obj, const std::string &s,
38107                                                   bool commaNeeded = true)
38108 {
38109     PRINT_SPACE
38110     _OUT << "{" << std::endl;
38111     INDENT(4);
38112 
38113     print_VkStructureType(obj->sType, "sType", 1);
38114 
38115     if (obj->pNext)
38116     {
38117         dumpPNextChain(obj->pNext);
38118     }
38119     else
38120     {
38121         PRINT_SPACE
38122         _OUT << "\"pNext\":"
38123              << "\"NULL\""
38124              << "," << std::endl;
38125     }
38126 
38127     print_VkSurfaceCounterFlagsEXT(obj->surfaceCounters, "surfaceCounters", 0);
38128 
38129     INDENT(-4);
38130     PRINT_SPACE
38131     if (commaNeeded)
38132         _OUT << "}," << std::endl;
38133     else
38134         _OUT << "}" << std::endl;
38135 }
38136 
38137 static std::map<uint64_t, std::string> VkDiscardRectangleModeEXT_map = {
38138     std::make_pair(0, "VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT"),
38139     std::make_pair(1, "VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT"),
38140 };
print_VkDiscardRectangleModeEXT(VkDiscardRectangleModeEXT obj,const std::string & str,bool commaNeeded=true)38141 static void print_VkDiscardRectangleModeEXT(VkDiscardRectangleModeEXT obj, const std::string &str,
38142                                             bool commaNeeded = true)
38143 {
38144     PRINT_SPACE
38145     if (str != "")
38146         _OUT << "\"" << str << "\""
38147              << " : ";
38148     if (commaNeeded)
38149         _OUT << "\"" << VkDiscardRectangleModeEXT_map[obj] << "\"," << std::endl;
38150     else
38151         _OUT << "\"" << VkDiscardRectangleModeEXT_map[obj] << "\"" << std::endl;
38152 }
print_VkDiscardRectangleModeEXT(const VkDiscardRectangleModeEXT * obj,const std::string & str,bool commaNeeded=true)38153 static void print_VkDiscardRectangleModeEXT(const VkDiscardRectangleModeEXT *obj, const std::string &str,
38154                                             bool commaNeeded = true)
38155 {
38156     PRINT_SPACE
38157     if (str != "")
38158         _OUT << "\"" << str << "\""
38159              << " : ";
38160     if (commaNeeded)
38161         _OUT << "\"" << VkDiscardRectangleModeEXT_map[*obj] << "\"," << std::endl;
38162     else
38163         _OUT << "\"" << VkDiscardRectangleModeEXT_map[*obj] << "\"" << std::endl;
38164 }
38165 
print_VkPipelineDiscardRectangleStateCreateFlagsEXT(VkPipelineDiscardRectangleStateCreateFlagsEXT obj,const std::string & str,bool commaNeeded=true)38166 static void print_VkPipelineDiscardRectangleStateCreateFlagsEXT(VkPipelineDiscardRectangleStateCreateFlagsEXT obj,
38167                                                                 const std::string &str, bool commaNeeded = true)
38168 {
38169     PRINT_SPACE
38170     if (commaNeeded)
38171         _OUT << "\"" << str << "\""
38172              << " : " << obj << "," << std::endl;
38173     else
38174         _OUT << "\"" << str << "\""
38175              << " : " << obj << std::endl;
38176 }
print_VkPipelineDiscardRectangleStateCreateFlagsEXT(const VkPipelineDiscardRectangleStateCreateFlagsEXT * obj,const std::string & str,bool commaNeeded=true)38177 static void print_VkPipelineDiscardRectangleStateCreateFlagsEXT(
38178     const VkPipelineDiscardRectangleStateCreateFlagsEXT *obj, const std::string &str, bool commaNeeded = true)
38179 {
38180     PRINT_SPACE
38181     if (commaNeeded)
38182         _OUT << "\"" << str << "\""
38183              << " : " << obj << "," << std::endl;
38184     else
38185         _OUT << "\"" << str << "\""
38186              << " : " << obj << std::endl;
38187 }
38188 
print_VkPhysicalDeviceDiscardRectanglePropertiesEXT(VkPhysicalDeviceDiscardRectanglePropertiesEXT obj,const std::string & s,bool commaNeeded=true)38189 static void print_VkPhysicalDeviceDiscardRectanglePropertiesEXT(VkPhysicalDeviceDiscardRectanglePropertiesEXT obj,
38190                                                                 const std::string &s, bool commaNeeded = true)
38191 {
38192     PRINT_SPACE
38193     _OUT << "{" << std::endl;
38194     INDENT(4);
38195 
38196     print_VkStructureType(obj.sType, "sType", 1);
38197 
38198     if (obj.pNext)
38199     {
38200         dumpPNextChain(obj.pNext);
38201     }
38202     else
38203     {
38204         PRINT_SPACE
38205         _OUT << "\"pNext\":"
38206              << "\"NULL\""
38207              << "," << std::endl;
38208     }
38209 
38210     print_uint32_t(obj.maxDiscardRectangles, "maxDiscardRectangles", 0);
38211 
38212     INDENT(-4);
38213     PRINT_SPACE
38214     if (commaNeeded)
38215         _OUT << "}," << std::endl;
38216     else
38217         _OUT << "}" << std::endl;
38218 }
print_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT * obj,const std::string & s,bool commaNeeded=true)38219 static void print_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
38220     const VkPhysicalDeviceDiscardRectanglePropertiesEXT *obj, const std::string &s, bool commaNeeded = true)
38221 {
38222     PRINT_SPACE
38223     _OUT << "{" << std::endl;
38224     INDENT(4);
38225 
38226     print_VkStructureType(obj->sType, "sType", 1);
38227 
38228     if (obj->pNext)
38229     {
38230         dumpPNextChain(obj->pNext);
38231     }
38232     else
38233     {
38234         PRINT_SPACE
38235         _OUT << "\"pNext\":"
38236              << "\"NULL\""
38237              << "," << std::endl;
38238     }
38239 
38240     print_uint32_t(obj->maxDiscardRectangles, "maxDiscardRectangles", 0);
38241 
38242     INDENT(-4);
38243     PRINT_SPACE
38244     if (commaNeeded)
38245         _OUT << "}," << std::endl;
38246     else
38247         _OUT << "}" << std::endl;
38248 }
38249 
print_VkPipelineDiscardRectangleStateCreateInfoEXT(VkPipelineDiscardRectangleStateCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)38250 static void print_VkPipelineDiscardRectangleStateCreateInfoEXT(VkPipelineDiscardRectangleStateCreateInfoEXT obj,
38251                                                                const std::string &s, bool commaNeeded = true)
38252 {
38253     PRINT_SPACE
38254     _OUT << "{" << std::endl;
38255     INDENT(4);
38256 
38257     print_VkStructureType(obj.sType, "sType", 1);
38258 
38259     if (obj.pNext)
38260     {
38261         dumpPNextChain(obj.pNext);
38262     }
38263     else
38264     {
38265         PRINT_SPACE
38266         _OUT << "\"pNext\":"
38267              << "\"NULL\""
38268              << "," << std::endl;
38269     }
38270 
38271     print_VkPipelineDiscardRectangleStateCreateFlagsEXT(obj.flags, "flags", 1);
38272 
38273     print_VkDiscardRectangleModeEXT(obj.discardRectangleMode, "discardRectangleMode", 1);
38274 
38275     print_uint32_t(obj.discardRectangleCount, "discardRectangleCount", 1);
38276 
38277     PRINT_SPACE
38278     _OUT << "\"pDiscardRectangles\": " << std::endl;
38279     if (obj.pDiscardRectangles)
38280     {
38281         PRINT_SPACE
38282         _OUT << "[" << std::endl;
38283         for (unsigned int i = 0; i < obj.discardRectangleCount; i++)
38284         {
38285             if (i + 1 == obj.discardRectangleCount)
38286                 print_VkRect2D(obj.pDiscardRectangles[i], "pDiscardRectangles", 0);
38287             else
38288                 print_VkRect2D(obj.pDiscardRectangles[i], "pDiscardRectangles", 1);
38289         }
38290         PRINT_SPACE
38291         _OUT << "]" << std::endl;
38292     }
38293     else
38294     {
38295         PRINT_SPACE _OUT << "\"NULL\""
38296                          << "" << std::endl;
38297     }
38298 
38299     INDENT(-4);
38300     PRINT_SPACE
38301     if (commaNeeded)
38302         _OUT << "}," << std::endl;
38303     else
38304         _OUT << "}" << std::endl;
38305 }
print_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)38306 static void print_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT *obj,
38307                                                                const std::string &s, bool commaNeeded = true)
38308 {
38309     PRINT_SPACE
38310     _OUT << "{" << std::endl;
38311     INDENT(4);
38312 
38313     print_VkStructureType(obj->sType, "sType", 1);
38314 
38315     if (obj->pNext)
38316     {
38317         dumpPNextChain(obj->pNext);
38318     }
38319     else
38320     {
38321         PRINT_SPACE
38322         _OUT << "\"pNext\":"
38323              << "\"NULL\""
38324              << "," << std::endl;
38325     }
38326 
38327     print_VkPipelineDiscardRectangleStateCreateFlagsEXT(obj->flags, "flags", 1);
38328 
38329     print_VkDiscardRectangleModeEXT(obj->discardRectangleMode, "discardRectangleMode", 1);
38330 
38331     print_uint32_t(obj->discardRectangleCount, "discardRectangleCount", 1);
38332 
38333     PRINT_SPACE
38334     _OUT << "\"pDiscardRectangles\": " << std::endl;
38335     if (obj->pDiscardRectangles)
38336     {
38337         PRINT_SPACE
38338         _OUT << "[" << std::endl;
38339         for (unsigned int i = 0; i < obj->discardRectangleCount; i++)
38340         {
38341             if (i + 1 == obj->discardRectangleCount)
38342                 print_VkRect2D(obj->pDiscardRectangles[i], "pDiscardRectangles", 0);
38343             else
38344                 print_VkRect2D(obj->pDiscardRectangles[i], "pDiscardRectangles", 1);
38345         }
38346         PRINT_SPACE
38347         _OUT << "]" << std::endl;
38348     }
38349     else
38350     {
38351         PRINT_SPACE _OUT << "\"NULL\""
38352                          << "" << std::endl;
38353     }
38354 
38355     INDENT(-4);
38356     PRINT_SPACE
38357     if (commaNeeded)
38358         _OUT << "}," << std::endl;
38359     else
38360         _OUT << "}" << std::endl;
38361 }
38362 
38363 static std::map<uint64_t, std::string> VkConservativeRasterizationModeEXT_map = {
38364     std::make_pair(0, "VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT"),
38365     std::make_pair(1, "VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT"),
38366     std::make_pair(2, "VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT"),
38367 };
print_VkConservativeRasterizationModeEXT(VkConservativeRasterizationModeEXT obj,const std::string & str,bool commaNeeded=true)38368 static void print_VkConservativeRasterizationModeEXT(VkConservativeRasterizationModeEXT obj, const std::string &str,
38369                                                      bool commaNeeded = true)
38370 {
38371     PRINT_SPACE
38372     if (str != "")
38373         _OUT << "\"" << str << "\""
38374              << " : ";
38375     if (commaNeeded)
38376         _OUT << "\"" << VkConservativeRasterizationModeEXT_map[obj] << "\"," << std::endl;
38377     else
38378         _OUT << "\"" << VkConservativeRasterizationModeEXT_map[obj] << "\"" << std::endl;
38379 }
print_VkConservativeRasterizationModeEXT(const VkConservativeRasterizationModeEXT * obj,const std::string & str,bool commaNeeded=true)38380 static void print_VkConservativeRasterizationModeEXT(const VkConservativeRasterizationModeEXT *obj,
38381                                                      const std::string &str, bool commaNeeded = true)
38382 {
38383     PRINT_SPACE
38384     if (str != "")
38385         _OUT << "\"" << str << "\""
38386              << " : ";
38387     if (commaNeeded)
38388         _OUT << "\"" << VkConservativeRasterizationModeEXT_map[*obj] << "\"," << std::endl;
38389     else
38390         _OUT << "\"" << VkConservativeRasterizationModeEXT_map[*obj] << "\"" << std::endl;
38391 }
38392 
print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(VkPipelineRasterizationConservativeStateCreateFlagsEXT obj,const std::string & str,bool commaNeeded=true)38393 static void print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(
38394     VkPipelineRasterizationConservativeStateCreateFlagsEXT obj, const std::string &str, bool commaNeeded = true)
38395 {
38396     PRINT_SPACE
38397     if (commaNeeded)
38398         _OUT << "\"" << str << "\""
38399              << " : " << obj << "," << std::endl;
38400     else
38401         _OUT << "\"" << str << "\""
38402              << " : " << obj << std::endl;
38403 }
print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(const VkPipelineRasterizationConservativeStateCreateFlagsEXT * obj,const std::string & str,bool commaNeeded=true)38404 static void print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(
38405     const VkPipelineRasterizationConservativeStateCreateFlagsEXT *obj, const std::string &str, bool commaNeeded = true)
38406 {
38407     PRINT_SPACE
38408     if (commaNeeded)
38409         _OUT << "\"" << str << "\""
38410              << " : " << obj << "," << std::endl;
38411     else
38412         _OUT << "\"" << str << "\""
38413              << " : " << obj << std::endl;
38414 }
38415 
print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(VkPhysicalDeviceConservativeRasterizationPropertiesEXT obj,const std::string & s,bool commaNeeded=true)38416 static void print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
38417     VkPhysicalDeviceConservativeRasterizationPropertiesEXT obj, const std::string &s, bool commaNeeded = true)
38418 {
38419     PRINT_SPACE
38420     _OUT << "{" << std::endl;
38421     INDENT(4);
38422 
38423     print_VkStructureType(obj.sType, "sType", 1);
38424 
38425     if (obj.pNext)
38426     {
38427         dumpPNextChain(obj.pNext);
38428     }
38429     else
38430     {
38431         PRINT_SPACE
38432         _OUT << "\"pNext\":"
38433              << "\"NULL\""
38434              << "," << std::endl;
38435     }
38436 
38437     print_float(obj.primitiveOverestimationSize, "primitiveOverestimationSize", 1);
38438 
38439     print_float(obj.maxExtraPrimitiveOverestimationSize, "maxExtraPrimitiveOverestimationSize", 1);
38440 
38441     print_float(obj.extraPrimitiveOverestimationSizeGranularity, "extraPrimitiveOverestimationSizeGranularity", 1);
38442 
38443     print_VkBool32(obj.primitiveUnderestimation, "primitiveUnderestimation", 1);
38444 
38445     print_VkBool32(obj.conservativePointAndLineRasterization, "conservativePointAndLineRasterization", 1);
38446 
38447     print_VkBool32(obj.degenerateTrianglesRasterized, "degenerateTrianglesRasterized", 1);
38448 
38449     print_VkBool32(obj.degenerateLinesRasterized, "degenerateLinesRasterized", 1);
38450 
38451     print_VkBool32(obj.fullyCoveredFragmentShaderInputVariable, "fullyCoveredFragmentShaderInputVariable", 1);
38452 
38453     print_VkBool32(obj.conservativeRasterizationPostDepthCoverage, "conservativeRasterizationPostDepthCoverage", 0);
38454 
38455     INDENT(-4);
38456     PRINT_SPACE
38457     if (commaNeeded)
38458         _OUT << "}," << std::endl;
38459     else
38460         _OUT << "}" << std::endl;
38461 }
print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)38462 static void print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
38463     const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *obj, const std::string &s, bool commaNeeded = true)
38464 {
38465     PRINT_SPACE
38466     _OUT << "{" << std::endl;
38467     INDENT(4);
38468 
38469     print_VkStructureType(obj->sType, "sType", 1);
38470 
38471     if (obj->pNext)
38472     {
38473         dumpPNextChain(obj->pNext);
38474     }
38475     else
38476     {
38477         PRINT_SPACE
38478         _OUT << "\"pNext\":"
38479              << "\"NULL\""
38480              << "," << std::endl;
38481     }
38482 
38483     print_float(obj->primitiveOverestimationSize, "primitiveOverestimationSize", 1);
38484 
38485     print_float(obj->maxExtraPrimitiveOverestimationSize, "maxExtraPrimitiveOverestimationSize", 1);
38486 
38487     print_float(obj->extraPrimitiveOverestimationSizeGranularity, "extraPrimitiveOverestimationSizeGranularity", 1);
38488 
38489     print_VkBool32(obj->primitiveUnderestimation, "primitiveUnderestimation", 1);
38490 
38491     print_VkBool32(obj->conservativePointAndLineRasterization, "conservativePointAndLineRasterization", 1);
38492 
38493     print_VkBool32(obj->degenerateTrianglesRasterized, "degenerateTrianglesRasterized", 1);
38494 
38495     print_VkBool32(obj->degenerateLinesRasterized, "degenerateLinesRasterized", 1);
38496 
38497     print_VkBool32(obj->fullyCoveredFragmentShaderInputVariable, "fullyCoveredFragmentShaderInputVariable", 1);
38498 
38499     print_VkBool32(obj->conservativeRasterizationPostDepthCoverage, "conservativeRasterizationPostDepthCoverage", 0);
38500 
38501     INDENT(-4);
38502     PRINT_SPACE
38503     if (commaNeeded)
38504         _OUT << "}," << std::endl;
38505     else
38506         _OUT << "}" << std::endl;
38507 }
38508 
print_VkPipelineRasterizationConservativeStateCreateInfoEXT(VkPipelineRasterizationConservativeStateCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)38509 static void print_VkPipelineRasterizationConservativeStateCreateInfoEXT(
38510     VkPipelineRasterizationConservativeStateCreateInfoEXT obj, const std::string &s, bool commaNeeded = true)
38511 {
38512     PRINT_SPACE
38513     _OUT << "{" << std::endl;
38514     INDENT(4);
38515 
38516     print_VkStructureType(obj.sType, "sType", 1);
38517 
38518     if (obj.pNext)
38519     {
38520         dumpPNextChain(obj.pNext);
38521     }
38522     else
38523     {
38524         PRINT_SPACE
38525         _OUT << "\"pNext\":"
38526              << "\"NULL\""
38527              << "," << std::endl;
38528     }
38529 
38530     print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(obj.flags, "flags", 1);
38531 
38532     print_VkConservativeRasterizationModeEXT(obj.conservativeRasterizationMode, "conservativeRasterizationMode", 1);
38533 
38534     print_float(obj.extraPrimitiveOverestimationSize, "extraPrimitiveOverestimationSize", 0);
38535 
38536     INDENT(-4);
38537     PRINT_SPACE
38538     if (commaNeeded)
38539         _OUT << "}," << std::endl;
38540     else
38541         _OUT << "}" << std::endl;
38542 }
print_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)38543 static void print_VkPipelineRasterizationConservativeStateCreateInfoEXT(
38544     const VkPipelineRasterizationConservativeStateCreateInfoEXT *obj, const std::string &s, bool commaNeeded = true)
38545 {
38546     PRINT_SPACE
38547     _OUT << "{" << std::endl;
38548     INDENT(4);
38549 
38550     print_VkStructureType(obj->sType, "sType", 1);
38551 
38552     if (obj->pNext)
38553     {
38554         dumpPNextChain(obj->pNext);
38555     }
38556     else
38557     {
38558         PRINT_SPACE
38559         _OUT << "\"pNext\":"
38560              << "\"NULL\""
38561              << "," << std::endl;
38562     }
38563 
38564     print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(obj->flags, "flags", 1);
38565 
38566     print_VkConservativeRasterizationModeEXT(obj->conservativeRasterizationMode, "conservativeRasterizationMode", 1);
38567 
38568     print_float(obj->extraPrimitiveOverestimationSize, "extraPrimitiveOverestimationSize", 0);
38569 
38570     INDENT(-4);
38571     PRINT_SPACE
38572     if (commaNeeded)
38573         _OUT << "}," << std::endl;
38574     else
38575         _OUT << "}" << std::endl;
38576 }
38577 
print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(VkPipelineRasterizationDepthClipStateCreateFlagsEXT obj,const std::string & str,bool commaNeeded=true)38578 static void print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(
38579     VkPipelineRasterizationDepthClipStateCreateFlagsEXT obj, const std::string &str, bool commaNeeded = true)
38580 {
38581     PRINT_SPACE
38582     if (commaNeeded)
38583         _OUT << "\"" << str << "\""
38584              << " : " << obj << "," << std::endl;
38585     else
38586         _OUT << "\"" << str << "\""
38587              << " : " << obj << std::endl;
38588 }
print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(const VkPipelineRasterizationDepthClipStateCreateFlagsEXT * obj,const std::string & str,bool commaNeeded=true)38589 static void print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(
38590     const VkPipelineRasterizationDepthClipStateCreateFlagsEXT *obj, const std::string &str, bool commaNeeded = true)
38591 {
38592     PRINT_SPACE
38593     if (commaNeeded)
38594         _OUT << "\"" << str << "\""
38595              << " : " << obj << "," << std::endl;
38596     else
38597         _OUT << "\"" << str << "\""
38598              << " : " << obj << std::endl;
38599 }
38600 
print_VkPhysicalDeviceDepthClipEnableFeaturesEXT(VkPhysicalDeviceDepthClipEnableFeaturesEXT obj,const std::string & s,bool commaNeeded=true)38601 static void print_VkPhysicalDeviceDepthClipEnableFeaturesEXT(VkPhysicalDeviceDepthClipEnableFeaturesEXT obj,
38602                                                              const std::string &s, bool commaNeeded = true)
38603 {
38604     PRINT_SPACE
38605     _OUT << "{" << std::endl;
38606     INDENT(4);
38607 
38608     print_VkStructureType(obj.sType, "sType", 1);
38609 
38610     if (obj.pNext)
38611     {
38612         dumpPNextChain(obj.pNext);
38613     }
38614     else
38615     {
38616         PRINT_SPACE
38617         _OUT << "\"pNext\":"
38618              << "\"NULL\""
38619              << "," << std::endl;
38620     }
38621 
38622     print_VkBool32(obj.depthClipEnable, "depthClipEnable", 0);
38623 
38624     INDENT(-4);
38625     PRINT_SPACE
38626     if (commaNeeded)
38627         _OUT << "}," << std::endl;
38628     else
38629         _OUT << "}" << std::endl;
38630 }
print_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)38631 static void print_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT *obj,
38632                                                              const std::string &s, bool commaNeeded = true)
38633 {
38634     PRINT_SPACE
38635     _OUT << "{" << std::endl;
38636     INDENT(4);
38637 
38638     print_VkStructureType(obj->sType, "sType", 1);
38639 
38640     if (obj->pNext)
38641     {
38642         dumpPNextChain(obj->pNext);
38643     }
38644     else
38645     {
38646         PRINT_SPACE
38647         _OUT << "\"pNext\":"
38648              << "\"NULL\""
38649              << "," << std::endl;
38650     }
38651 
38652     print_VkBool32(obj->depthClipEnable, "depthClipEnable", 0);
38653 
38654     INDENT(-4);
38655     PRINT_SPACE
38656     if (commaNeeded)
38657         _OUT << "}," << std::endl;
38658     else
38659         _OUT << "}" << std::endl;
38660 }
38661 
print_VkPipelineRasterizationDepthClipStateCreateInfoEXT(VkPipelineRasterizationDepthClipStateCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)38662 static void print_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
38663     VkPipelineRasterizationDepthClipStateCreateInfoEXT obj, const std::string &s, bool commaNeeded = true)
38664 {
38665     PRINT_SPACE
38666     _OUT << "{" << std::endl;
38667     INDENT(4);
38668 
38669     print_VkStructureType(obj.sType, "sType", 1);
38670 
38671     if (obj.pNext)
38672     {
38673         dumpPNextChain(obj.pNext);
38674     }
38675     else
38676     {
38677         PRINT_SPACE
38678         _OUT << "\"pNext\":"
38679              << "\"NULL\""
38680              << "," << std::endl;
38681     }
38682 
38683     print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(obj.flags, "flags", 1);
38684 
38685     print_VkBool32(obj.depthClipEnable, "depthClipEnable", 0);
38686 
38687     INDENT(-4);
38688     PRINT_SPACE
38689     if (commaNeeded)
38690         _OUT << "}," << std::endl;
38691     else
38692         _OUT << "}" << std::endl;
38693 }
print_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)38694 static void print_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
38695     const VkPipelineRasterizationDepthClipStateCreateInfoEXT *obj, const std::string &s, bool commaNeeded = true)
38696 {
38697     PRINT_SPACE
38698     _OUT << "{" << std::endl;
38699     INDENT(4);
38700 
38701     print_VkStructureType(obj->sType, "sType", 1);
38702 
38703     if (obj->pNext)
38704     {
38705         dumpPNextChain(obj->pNext);
38706     }
38707     else
38708     {
38709         PRINT_SPACE
38710         _OUT << "\"pNext\":"
38711              << "\"NULL\""
38712              << "," << std::endl;
38713     }
38714 
38715     print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(obj->flags, "flags", 1);
38716 
38717     print_VkBool32(obj->depthClipEnable, "depthClipEnable", 0);
38718 
38719     INDENT(-4);
38720     PRINT_SPACE
38721     if (commaNeeded)
38722         _OUT << "}," << std::endl;
38723     else
38724         _OUT << "}" << std::endl;
38725 }
38726 
print_VkXYColorEXT(VkXYColorEXT obj,const std::string & s,bool commaNeeded=true)38727 static void print_VkXYColorEXT(VkXYColorEXT obj, const std::string &s, bool commaNeeded = true)
38728 {
38729     PRINT_SPACE
38730     _OUT << "{" << std::endl;
38731     INDENT(4);
38732 
38733     print_float(obj.x, "x", 1);
38734 
38735     print_float(obj.y, "y", 0);
38736 
38737     INDENT(-4);
38738     PRINT_SPACE
38739     if (commaNeeded)
38740         _OUT << "}," << std::endl;
38741     else
38742         _OUT << "}" << std::endl;
38743 }
print_VkXYColorEXT(const VkXYColorEXT * obj,const std::string & s,bool commaNeeded=true)38744 static void print_VkXYColorEXT(const VkXYColorEXT *obj, const std::string &s, bool commaNeeded = true)
38745 {
38746     PRINT_SPACE
38747     _OUT << "{" << std::endl;
38748     INDENT(4);
38749 
38750     print_float(obj->x, "x", 1);
38751 
38752     print_float(obj->y, "y", 0);
38753 
38754     INDENT(-4);
38755     PRINT_SPACE
38756     if (commaNeeded)
38757         _OUT << "}," << std::endl;
38758     else
38759         _OUT << "}" << std::endl;
38760 }
38761 
print_VkHdrMetadataEXT(VkHdrMetadataEXT obj,const std::string & s,bool commaNeeded=true)38762 static void print_VkHdrMetadataEXT(VkHdrMetadataEXT obj, const std::string &s, bool commaNeeded = true)
38763 {
38764     PRINT_SPACE
38765     _OUT << "{" << std::endl;
38766     INDENT(4);
38767 
38768     print_VkStructureType(obj.sType, "sType", 1);
38769 
38770     if (obj.pNext)
38771     {
38772         dumpPNextChain(obj.pNext);
38773     }
38774     else
38775     {
38776         PRINT_SPACE
38777         _OUT << "\"pNext\":"
38778              << "\"NULL\""
38779              << "," << std::endl;
38780     }
38781 
38782     PRINT_SPACE
38783     _OUT << "\"displayPrimaryRed\": " << std::endl;
38784     {
38785         print_VkXYColorEXT(obj.displayPrimaryRed, "displayPrimaryRed", 1);
38786     }
38787 
38788     PRINT_SPACE
38789     _OUT << "\"displayPrimaryGreen\": " << std::endl;
38790     {
38791         print_VkXYColorEXT(obj.displayPrimaryGreen, "displayPrimaryGreen", 1);
38792     }
38793 
38794     PRINT_SPACE
38795     _OUT << "\"displayPrimaryBlue\": " << std::endl;
38796     {
38797         print_VkXYColorEXT(obj.displayPrimaryBlue, "displayPrimaryBlue", 1);
38798     }
38799 
38800     PRINT_SPACE
38801     _OUT << "\"whitePoint\": " << std::endl;
38802     {
38803         print_VkXYColorEXT(obj.whitePoint, "whitePoint", 1);
38804     }
38805 
38806     print_float(obj.maxLuminance, "maxLuminance", 1);
38807 
38808     print_float(obj.minLuminance, "minLuminance", 1);
38809 
38810     print_float(obj.maxContentLightLevel, "maxContentLightLevel", 1);
38811 
38812     print_float(obj.maxFrameAverageLightLevel, "maxFrameAverageLightLevel", 0);
38813 
38814     INDENT(-4);
38815     PRINT_SPACE
38816     if (commaNeeded)
38817         _OUT << "}," << std::endl;
38818     else
38819         _OUT << "}" << std::endl;
38820 }
print_VkHdrMetadataEXT(const VkHdrMetadataEXT * obj,const std::string & s,bool commaNeeded=true)38821 static void print_VkHdrMetadataEXT(const VkHdrMetadataEXT *obj, const std::string &s, bool commaNeeded = true)
38822 {
38823     PRINT_SPACE
38824     _OUT << "{" << std::endl;
38825     INDENT(4);
38826 
38827     print_VkStructureType(obj->sType, "sType", 1);
38828 
38829     if (obj->pNext)
38830     {
38831         dumpPNextChain(obj->pNext);
38832     }
38833     else
38834     {
38835         PRINT_SPACE
38836         _OUT << "\"pNext\":"
38837              << "\"NULL\""
38838              << "," << std::endl;
38839     }
38840 
38841     PRINT_SPACE
38842     _OUT << "\"displayPrimaryRed\": " << std::endl;
38843     {
38844         print_VkXYColorEXT(obj->displayPrimaryRed, "displayPrimaryRed", 1);
38845     }
38846 
38847     PRINT_SPACE
38848     _OUT << "\"displayPrimaryGreen\": " << std::endl;
38849     {
38850         print_VkXYColorEXT(obj->displayPrimaryGreen, "displayPrimaryGreen", 1);
38851     }
38852 
38853     PRINT_SPACE
38854     _OUT << "\"displayPrimaryBlue\": " << std::endl;
38855     {
38856         print_VkXYColorEXT(obj->displayPrimaryBlue, "displayPrimaryBlue", 1);
38857     }
38858 
38859     PRINT_SPACE
38860     _OUT << "\"whitePoint\": " << std::endl;
38861     {
38862         print_VkXYColorEXT(obj->whitePoint, "whitePoint", 1);
38863     }
38864 
38865     print_float(obj->maxLuminance, "maxLuminance", 1);
38866 
38867     print_float(obj->minLuminance, "minLuminance", 1);
38868 
38869     print_float(obj->maxContentLightLevel, "maxContentLightLevel", 1);
38870 
38871     print_float(obj->maxFrameAverageLightLevel, "maxFrameAverageLightLevel", 0);
38872 
38873     INDENT(-4);
38874     PRINT_SPACE
38875     if (commaNeeded)
38876         _OUT << "}," << std::endl;
38877     else
38878         _OUT << "}" << std::endl;
38879 }
38880 
print_VkDebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT obj,const std::string & str,bool commaNeeded=true)38881 static void print_VkDebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT obj, const std::string &str,
38882                                            bool commaNeeded = true)
38883 {
38884     PRINT_SPACE
38885     if (commaNeeded)
38886         _OUT << "\"" << str << "\""
38887              << "," << std::endl;
38888     else
38889         _OUT << "\"" << str << "\"" << std::endl;
38890 }
print_VkDebugUtilsMessengerEXT(const VkDebugUtilsMessengerEXT * obj,const std::string & str,bool commaNeeded=true)38891 static void print_VkDebugUtilsMessengerEXT(const VkDebugUtilsMessengerEXT *obj, const std::string &str,
38892                                            bool commaNeeded = true)
38893 {
38894     PRINT_SPACE
38895     if (commaNeeded)
38896         _OUT << "\"" << str << "\""
38897              << "," << std::endl;
38898     else
38899         _OUT << "\"" << str << "\"" << std::endl;
38900 }
38901 
38902 static std::map<uint64_t, std::string> VkDebugUtilsMessageSeverityFlagBitsEXT_map = {
38903     std::make_pair(1ULL << 0, "VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT"),
38904     std::make_pair(1ULL << 4, "VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT"),
38905     std::make_pair(1ULL << 8, "VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT"),
38906     std::make_pair(1ULL << 12, "VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT"),
38907 };
print_VkDebugUtilsMessageSeverityFlagBitsEXT(VkDebugUtilsMessageSeverityFlagBitsEXT obj,const std::string & str,bool commaNeeded=true)38908 static void print_VkDebugUtilsMessageSeverityFlagBitsEXT(VkDebugUtilsMessageSeverityFlagBitsEXT obj,
38909                                                          const std::string &str, bool commaNeeded = true)
38910 {
38911     PRINT_SPACE
38912     if (str != "")
38913         _OUT << "\"" << str << "\""
38914              << " : ";
38915     if (commaNeeded)
38916         _OUT << "\"" << VkDebugUtilsMessageSeverityFlagBitsEXT_map[obj] << "\"," << std::endl;
38917     else
38918         _OUT << "\"" << VkDebugUtilsMessageSeverityFlagBitsEXT_map[obj] << "\"" << std::endl;
38919 }
print_VkDebugUtilsMessageSeverityFlagBitsEXT(const VkDebugUtilsMessageSeverityFlagBitsEXT * obj,const std::string & str,bool commaNeeded=true)38920 static void print_VkDebugUtilsMessageSeverityFlagBitsEXT(const VkDebugUtilsMessageSeverityFlagBitsEXT *obj,
38921                                                          const std::string &str, bool commaNeeded = true)
38922 {
38923     PRINT_SPACE
38924     if (str != "")
38925         _OUT << "\"" << str << "\""
38926              << " : ";
38927     if (commaNeeded)
38928         _OUT << "\"" << VkDebugUtilsMessageSeverityFlagBitsEXT_map[*obj] << "\"," << std::endl;
38929     else
38930         _OUT << "\"" << VkDebugUtilsMessageSeverityFlagBitsEXT_map[*obj] << "\"" << std::endl;
38931 }
38932 
38933 static std::map<uint64_t, std::string> VkDebugUtilsMessageTypeFlagBitsEXT_map = {
38934     std::make_pair(1ULL << 0, "VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT"),
38935     std::make_pair(1ULL << 1, "VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT"),
38936     std::make_pair(1ULL << 2, "VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT"),
38937 };
print_VkDebugUtilsMessageTypeFlagBitsEXT(VkDebugUtilsMessageTypeFlagBitsEXT obj,const std::string & str,bool commaNeeded=true)38938 static void print_VkDebugUtilsMessageTypeFlagBitsEXT(VkDebugUtilsMessageTypeFlagBitsEXT obj, const std::string &str,
38939                                                      bool commaNeeded = true)
38940 {
38941     PRINT_SPACE
38942     if (str != "")
38943         _OUT << "\"" << str << "\""
38944              << " : ";
38945     if (commaNeeded)
38946         _OUT << "\"" << VkDebugUtilsMessageTypeFlagBitsEXT_map[obj] << "\"," << std::endl;
38947     else
38948         _OUT << "\"" << VkDebugUtilsMessageTypeFlagBitsEXT_map[obj] << "\"" << std::endl;
38949 }
print_VkDebugUtilsMessageTypeFlagBitsEXT(const VkDebugUtilsMessageTypeFlagBitsEXT * obj,const std::string & str,bool commaNeeded=true)38950 static void print_VkDebugUtilsMessageTypeFlagBitsEXT(const VkDebugUtilsMessageTypeFlagBitsEXT *obj,
38951                                                      const std::string &str, bool commaNeeded = true)
38952 {
38953     PRINT_SPACE
38954     if (str != "")
38955         _OUT << "\"" << str << "\""
38956              << " : ";
38957     if (commaNeeded)
38958         _OUT << "\"" << VkDebugUtilsMessageTypeFlagBitsEXT_map[*obj] << "\"," << std::endl;
38959     else
38960         _OUT << "\"" << VkDebugUtilsMessageTypeFlagBitsEXT_map[*obj] << "\"" << std::endl;
38961 }
38962 
print_VkDebugUtilsMessengerCallbackDataFlagsEXT(VkDebugUtilsMessengerCallbackDataFlagsEXT obj,const std::string & str,bool commaNeeded=true)38963 static void print_VkDebugUtilsMessengerCallbackDataFlagsEXT(VkDebugUtilsMessengerCallbackDataFlagsEXT obj,
38964                                                             const std::string &str, bool commaNeeded = true)
38965 {
38966     PRINT_SPACE
38967     if (commaNeeded)
38968         _OUT << "\"" << str << "\""
38969              << " : " << obj << "," << std::endl;
38970     else
38971         _OUT << "\"" << str << "\""
38972              << " : " << obj << std::endl;
38973 }
print_VkDebugUtilsMessengerCallbackDataFlagsEXT(const VkDebugUtilsMessengerCallbackDataFlagsEXT * obj,const std::string & str,bool commaNeeded=true)38974 static void print_VkDebugUtilsMessengerCallbackDataFlagsEXT(const VkDebugUtilsMessengerCallbackDataFlagsEXT *obj,
38975                                                             const std::string &str, bool commaNeeded = true)
38976 {
38977     PRINT_SPACE
38978     if (commaNeeded)
38979         _OUT << "\"" << str << "\""
38980              << " : " << obj << "," << std::endl;
38981     else
38982         _OUT << "\"" << str << "\""
38983              << " : " << obj << std::endl;
38984 }
38985 
print_VkDebugUtilsMessageTypeFlagsEXT(VkDebugUtilsMessageTypeFlagsEXT obj,const std::string & str,bool commaNeeded=true)38986 static void print_VkDebugUtilsMessageTypeFlagsEXT(VkDebugUtilsMessageTypeFlagsEXT obj, const std::string &str,
38987                                                   bool commaNeeded = true)
38988 {
38989     PRINT_SPACE
38990     if (str != "")
38991         _OUT << "\"" << str << "\""
38992              << " : ";
38993     const int max_bits = 64; // We don't expect the number to be larger.
38994     std::bitset<max_bits> b(obj);
38995     _OUT << "\"";
38996     if (obj == 0)
38997         _OUT << "0";
38998     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
38999     {
39000         if (b[i] == 1)
39001         {
39002             bitCount++;
39003             if (bitCount < b.count())
39004                 _OUT << VkDebugUtilsMessageTypeFlagBitsEXT_map[1ULL << i] << " | ";
39005             else
39006                 _OUT << VkDebugUtilsMessageTypeFlagBitsEXT_map[1ULL << i];
39007         }
39008     }
39009     if (commaNeeded)
39010         _OUT << "\""
39011              << ",";
39012     else
39013         _OUT << "\""
39014              << "";
39015     _OUT << std::endl;
39016 }
print_VkDebugUtilsMessageTypeFlagsEXT(const VkDebugUtilsMessageTypeFlagsEXT * obj,const std::string & str,bool commaNeeded=true)39017 static void print_VkDebugUtilsMessageTypeFlagsEXT(const VkDebugUtilsMessageTypeFlagsEXT *obj, const std::string &str,
39018                                                   bool commaNeeded = true)
39019 {
39020     PRINT_SPACE
39021     if (str != "")
39022         _OUT << "\"" << str << "\""
39023              << " : ";
39024     const int max_bits = 64; // We don't expect the number to be larger.
39025     std::bitset<max_bits> b(obj);
39026     _OUT << "\"";
39027     if (obj == 0)
39028         _OUT << "0";
39029     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
39030     {
39031         if (b[i] == 1)
39032         {
39033             bitCount++;
39034             if (bitCount < b.count())
39035                 _OUT << VkDebugUtilsMessageTypeFlagBitsEXT_map[1ULL << i] << " | ";
39036             else
39037                 _OUT << VkDebugUtilsMessageTypeFlagBitsEXT_map[1ULL << i];
39038         }
39039     }
39040     if (commaNeeded)
39041         _OUT << "\""
39042              << ",";
39043     else
39044         _OUT << "\""
39045              << "";
39046     _OUT << std::endl;
39047 }
39048 
print_VkDebugUtilsMessageSeverityFlagsEXT(VkDebugUtilsMessageSeverityFlagsEXT obj,const std::string & str,bool commaNeeded=true)39049 static void print_VkDebugUtilsMessageSeverityFlagsEXT(VkDebugUtilsMessageSeverityFlagsEXT obj, const std::string &str,
39050                                                       bool commaNeeded = true)
39051 {
39052     PRINT_SPACE
39053     if (str != "")
39054         _OUT << "\"" << str << "\""
39055              << " : ";
39056     const int max_bits = 64; // We don't expect the number to be larger.
39057     std::bitset<max_bits> b(obj);
39058     _OUT << "\"";
39059     if (obj == 0)
39060         _OUT << "0";
39061     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
39062     {
39063         if (b[i] == 1)
39064         {
39065             bitCount++;
39066             if (bitCount < b.count())
39067                 _OUT << VkDebugUtilsMessageSeverityFlagBitsEXT_map[1ULL << i] << " | ";
39068             else
39069                 _OUT << VkDebugUtilsMessageSeverityFlagBitsEXT_map[1ULL << i];
39070         }
39071     }
39072     if (commaNeeded)
39073         _OUT << "\""
39074              << ",";
39075     else
39076         _OUT << "\""
39077              << "";
39078     _OUT << std::endl;
39079 }
print_VkDebugUtilsMessageSeverityFlagsEXT(const VkDebugUtilsMessageSeverityFlagsEXT * obj,const std::string & str,bool commaNeeded=true)39080 static void print_VkDebugUtilsMessageSeverityFlagsEXT(const VkDebugUtilsMessageSeverityFlagsEXT *obj,
39081                                                       const std::string &str, bool commaNeeded = true)
39082 {
39083     PRINT_SPACE
39084     if (str != "")
39085         _OUT << "\"" << str << "\""
39086              << " : ";
39087     const int max_bits = 64; // We don't expect the number to be larger.
39088     std::bitset<max_bits> b(obj);
39089     _OUT << "\"";
39090     if (obj == 0)
39091         _OUT << "0";
39092     for (unsigned int i = 0, bitCount = 0; i < b.size(); i++)
39093     {
39094         if (b[i] == 1)
39095         {
39096             bitCount++;
39097             if (bitCount < b.count())
39098                 _OUT << VkDebugUtilsMessageSeverityFlagBitsEXT_map[1ULL << i] << " | ";
39099             else
39100                 _OUT << VkDebugUtilsMessageSeverityFlagBitsEXT_map[1ULL << i];
39101         }
39102     }
39103     if (commaNeeded)
39104         _OUT << "\""
39105              << ",";
39106     else
39107         _OUT << "\""
39108              << "";
39109     _OUT << std::endl;
39110 }
39111 
print_VkDebugUtilsMessengerCreateFlagsEXT(VkDebugUtilsMessengerCreateFlagsEXT obj,const std::string & str,bool commaNeeded=true)39112 static void print_VkDebugUtilsMessengerCreateFlagsEXT(VkDebugUtilsMessengerCreateFlagsEXT obj, const std::string &str,
39113                                                       bool commaNeeded = true)
39114 {
39115     PRINT_SPACE
39116     if (commaNeeded)
39117         _OUT << "\"" << str << "\""
39118              << " : " << obj << "," << std::endl;
39119     else
39120         _OUT << "\"" << str << "\""
39121              << " : " << obj << std::endl;
39122 }
print_VkDebugUtilsMessengerCreateFlagsEXT(const VkDebugUtilsMessengerCreateFlagsEXT * obj,const std::string & str,bool commaNeeded=true)39123 static void print_VkDebugUtilsMessengerCreateFlagsEXT(const VkDebugUtilsMessengerCreateFlagsEXT *obj,
39124                                                       const std::string &str, bool commaNeeded = true)
39125 {
39126     PRINT_SPACE
39127     if (commaNeeded)
39128         _OUT << "\"" << str << "\""
39129              << " : " << obj << "," << std::endl;
39130     else
39131         _OUT << "\"" << str << "\""
39132              << " : " << obj << std::endl;
39133 }
39134 
print_VkDebugUtilsLabelEXT(VkDebugUtilsLabelEXT obj,const std::string & s,bool commaNeeded=true)39135 static void print_VkDebugUtilsLabelEXT(VkDebugUtilsLabelEXT obj, const std::string &s, bool commaNeeded = true)
39136 {
39137     PRINT_SPACE
39138     _OUT << "{" << std::endl;
39139     INDENT(4);
39140 
39141     print_VkStructureType(obj.sType, "sType", 1);
39142 
39143     if (obj.pNext)
39144     {
39145         dumpPNextChain(obj.pNext);
39146     }
39147     else
39148     {
39149         PRINT_SPACE
39150         _OUT << "\"pNext\":"
39151              << "\"NULL\""
39152              << "," << std::endl;
39153     }
39154 
39155     print_char(obj.pLabelName, "pLabelName", 1);
39156 
39157     PRINT_SPACE
39158     _OUT << "\"color\":" << std::endl;
39159     PRINT_SPACE
39160     _OUT << "[" << std::endl;
39161     for (unsigned int i = 0; i < 4; i++)
39162     {
39163         bool isCommaNeeded = (i + 1) != 4;
39164         print_float(obj.color[i], "", isCommaNeeded);
39165     }
39166     PRINT_SPACE
39167     _OUT << "]"
39168          << "" << std::endl;
39169 
39170     INDENT(-4);
39171     PRINT_SPACE
39172     if (commaNeeded)
39173         _OUT << "}," << std::endl;
39174     else
39175         _OUT << "}" << std::endl;
39176 }
print_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT * obj,const std::string & s,bool commaNeeded=true)39177 static void print_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT *obj, const std::string &s, bool commaNeeded = true)
39178 {
39179     PRINT_SPACE
39180     _OUT << "{" << std::endl;
39181     INDENT(4);
39182 
39183     print_VkStructureType(obj->sType, "sType", 1);
39184 
39185     if (obj->pNext)
39186     {
39187         dumpPNextChain(obj->pNext);
39188     }
39189     else
39190     {
39191         PRINT_SPACE
39192         _OUT << "\"pNext\":"
39193              << "\"NULL\""
39194              << "," << std::endl;
39195     }
39196 
39197     print_char(obj->pLabelName, "pLabelName", 1);
39198 
39199     PRINT_SPACE
39200     _OUT << "\"color\":" << std::endl;
39201     PRINT_SPACE
39202     _OUT << "[" << std::endl;
39203     for (unsigned int i = 0; i < 4; i++)
39204     {
39205         bool isCommaNeeded = (i + 1) != 4;
39206         print_float(obj->color[i], "", isCommaNeeded);
39207     }
39208     PRINT_SPACE
39209     _OUT << "]"
39210          << "" << std::endl;
39211 
39212     INDENT(-4);
39213     PRINT_SPACE
39214     if (commaNeeded)
39215         _OUT << "}," << std::endl;
39216     else
39217         _OUT << "}" << std::endl;
39218 }
39219 
print_VkDebugUtilsObjectNameInfoEXT(VkDebugUtilsObjectNameInfoEXT obj,const std::string & s,bool commaNeeded=true)39220 static void print_VkDebugUtilsObjectNameInfoEXT(VkDebugUtilsObjectNameInfoEXT obj, const std::string &s,
39221                                                 bool commaNeeded = true)
39222 {
39223     PRINT_SPACE
39224     _OUT << "{" << std::endl;
39225     INDENT(4);
39226 
39227     print_VkStructureType(obj.sType, "sType", 1);
39228 
39229     if (obj.pNext)
39230     {
39231         dumpPNextChain(obj.pNext);
39232     }
39233     else
39234     {
39235         PRINT_SPACE
39236         _OUT << "\"pNext\":"
39237              << "\"NULL\""
39238              << "," << std::endl;
39239     }
39240 
39241     print_VkObjectType(obj.objectType, "objectType", 1);
39242 
39243     print_uint64_t(obj.objectHandle, "objectHandle", 1);
39244 
39245     print_char(obj.pObjectName, "pObjectName", 0);
39246 
39247     INDENT(-4);
39248     PRINT_SPACE
39249     if (commaNeeded)
39250         _OUT << "}," << std::endl;
39251     else
39252         _OUT << "}" << std::endl;
39253 }
print_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT * obj,const std::string & s,bool commaNeeded=true)39254 static void print_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT *obj, const std::string &s,
39255                                                 bool commaNeeded = true)
39256 {
39257     PRINT_SPACE
39258     _OUT << "{" << std::endl;
39259     INDENT(4);
39260 
39261     print_VkStructureType(obj->sType, "sType", 1);
39262 
39263     if (obj->pNext)
39264     {
39265         dumpPNextChain(obj->pNext);
39266     }
39267     else
39268     {
39269         PRINT_SPACE
39270         _OUT << "\"pNext\":"
39271              << "\"NULL\""
39272              << "," << std::endl;
39273     }
39274 
39275     print_VkObjectType(obj->objectType, "objectType", 1);
39276 
39277     print_uint64_t(obj->objectHandle, "objectHandle", 1);
39278 
39279     print_char(obj->pObjectName, "pObjectName", 0);
39280 
39281     INDENT(-4);
39282     PRINT_SPACE
39283     if (commaNeeded)
39284         _OUT << "}," << std::endl;
39285     else
39286         _OUT << "}" << std::endl;
39287 }
39288 
print_VkDebugUtilsMessengerCallbackDataEXT(VkDebugUtilsMessengerCallbackDataEXT obj,const std::string & s,bool commaNeeded=true)39289 static void print_VkDebugUtilsMessengerCallbackDataEXT(VkDebugUtilsMessengerCallbackDataEXT obj, const std::string &s,
39290                                                        bool commaNeeded = true)
39291 {
39292     PRINT_SPACE
39293     _OUT << "{" << std::endl;
39294     INDENT(4);
39295 
39296     print_VkStructureType(obj.sType, "sType", 1);
39297 
39298     if (obj.pNext)
39299     {
39300         dumpPNextChain(obj.pNext);
39301     }
39302     else
39303     {
39304         PRINT_SPACE
39305         _OUT << "\"pNext\":"
39306              << "\"NULL\""
39307              << "," << std::endl;
39308     }
39309 
39310     print_VkDebugUtilsMessengerCallbackDataFlagsEXT(obj.flags, "flags", 1);
39311 
39312     print_char(obj.pMessageIdName, "pMessageIdName", 1);
39313 
39314     print_int32_t(obj.messageIdNumber, "messageIdNumber", 1);
39315 
39316     print_char(obj.pMessage, "pMessage", 1);
39317 
39318     print_uint32_t(obj.queueLabelCount, "queueLabelCount", 1);
39319 
39320     PRINT_SPACE
39321     _OUT << "\"pQueueLabels\": " << std::endl;
39322     if (obj.pQueueLabels)
39323     {
39324         PRINT_SPACE
39325         _OUT << "[" << std::endl;
39326         for (unsigned int i = 0; i < obj.queueLabelCount; i++)
39327         {
39328             if (i + 1 == obj.queueLabelCount)
39329                 print_VkDebugUtilsLabelEXT(obj.pQueueLabels[i], "pQueueLabels", 0);
39330             else
39331                 print_VkDebugUtilsLabelEXT(obj.pQueueLabels[i], "pQueueLabels", 1);
39332         }
39333         PRINT_SPACE
39334         _OUT << "]," << std::endl;
39335     }
39336     else
39337     {
39338         PRINT_SPACE _OUT << "\"NULL\""
39339                          << "," << std::endl;
39340     }
39341 
39342     print_uint32_t(obj.cmdBufLabelCount, "cmdBufLabelCount", 1);
39343 
39344     PRINT_SPACE
39345     _OUT << "\"pCmdBufLabels\": " << std::endl;
39346     if (obj.pCmdBufLabels)
39347     {
39348         PRINT_SPACE
39349         _OUT << "[" << std::endl;
39350         for (unsigned int i = 0; i < obj.cmdBufLabelCount; i++)
39351         {
39352             if (i + 1 == obj.cmdBufLabelCount)
39353                 print_VkDebugUtilsLabelEXT(obj.pCmdBufLabels[i], "pCmdBufLabels", 0);
39354             else
39355                 print_VkDebugUtilsLabelEXT(obj.pCmdBufLabels[i], "pCmdBufLabels", 1);
39356         }
39357         PRINT_SPACE
39358         _OUT << "]," << std::endl;
39359     }
39360     else
39361     {
39362         PRINT_SPACE _OUT << "\"NULL\""
39363                          << "," << std::endl;
39364     }
39365 
39366     print_uint32_t(obj.objectCount, "objectCount", 1);
39367 
39368     PRINT_SPACE
39369     _OUT << "\"pObjects\": " << std::endl;
39370     if (obj.pObjects)
39371     {
39372         PRINT_SPACE
39373         _OUT << "[" << std::endl;
39374         for (unsigned int i = 0; i < obj.objectCount; i++)
39375         {
39376             if (i + 1 == obj.objectCount)
39377                 print_VkDebugUtilsObjectNameInfoEXT(obj.pObjects[i], "pObjects", 0);
39378             else
39379                 print_VkDebugUtilsObjectNameInfoEXT(obj.pObjects[i], "pObjects", 1);
39380         }
39381         PRINT_SPACE
39382         _OUT << "]" << std::endl;
39383     }
39384     else
39385     {
39386         PRINT_SPACE _OUT << "\"NULL\""
39387                          << "" << std::endl;
39388     }
39389 
39390     INDENT(-4);
39391     PRINT_SPACE
39392     if (commaNeeded)
39393         _OUT << "}," << std::endl;
39394     else
39395         _OUT << "}" << std::endl;
39396 }
print_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT * obj,const std::string & s,bool commaNeeded=true)39397 static void print_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT *obj,
39398                                                        const std::string &s, bool commaNeeded = true)
39399 {
39400     PRINT_SPACE
39401     _OUT << "{" << std::endl;
39402     INDENT(4);
39403 
39404     print_VkStructureType(obj->sType, "sType", 1);
39405 
39406     if (obj->pNext)
39407     {
39408         dumpPNextChain(obj->pNext);
39409     }
39410     else
39411     {
39412         PRINT_SPACE
39413         _OUT << "\"pNext\":"
39414              << "\"NULL\""
39415              << "," << std::endl;
39416     }
39417 
39418     print_VkDebugUtilsMessengerCallbackDataFlagsEXT(obj->flags, "flags", 1);
39419 
39420     print_char(obj->pMessageIdName, "pMessageIdName", 1);
39421 
39422     print_int32_t(obj->messageIdNumber, "messageIdNumber", 1);
39423 
39424     print_char(obj->pMessage, "pMessage", 1);
39425 
39426     print_uint32_t(obj->queueLabelCount, "queueLabelCount", 1);
39427 
39428     PRINT_SPACE
39429     _OUT << "\"pQueueLabels\": " << std::endl;
39430     if (obj->pQueueLabels)
39431     {
39432         PRINT_SPACE
39433         _OUT << "[" << std::endl;
39434         for (unsigned int i = 0; i < obj->queueLabelCount; i++)
39435         {
39436             if (i + 1 == obj->queueLabelCount)
39437                 print_VkDebugUtilsLabelEXT(obj->pQueueLabels[i], "pQueueLabels", 0);
39438             else
39439                 print_VkDebugUtilsLabelEXT(obj->pQueueLabels[i], "pQueueLabels", 1);
39440         }
39441         PRINT_SPACE
39442         _OUT << "]," << std::endl;
39443     }
39444     else
39445     {
39446         PRINT_SPACE _OUT << "\"NULL\""
39447                          << "," << std::endl;
39448     }
39449 
39450     print_uint32_t(obj->cmdBufLabelCount, "cmdBufLabelCount", 1);
39451 
39452     PRINT_SPACE
39453     _OUT << "\"pCmdBufLabels\": " << std::endl;
39454     if (obj->pCmdBufLabels)
39455     {
39456         PRINT_SPACE
39457         _OUT << "[" << std::endl;
39458         for (unsigned int i = 0; i < obj->cmdBufLabelCount; i++)
39459         {
39460             if (i + 1 == obj->cmdBufLabelCount)
39461                 print_VkDebugUtilsLabelEXT(obj->pCmdBufLabels[i], "pCmdBufLabels", 0);
39462             else
39463                 print_VkDebugUtilsLabelEXT(obj->pCmdBufLabels[i], "pCmdBufLabels", 1);
39464         }
39465         PRINT_SPACE
39466         _OUT << "]," << std::endl;
39467     }
39468     else
39469     {
39470         PRINT_SPACE _OUT << "\"NULL\""
39471                          << "," << std::endl;
39472     }
39473 
39474     print_uint32_t(obj->objectCount, "objectCount", 1);
39475 
39476     PRINT_SPACE
39477     _OUT << "\"pObjects\": " << std::endl;
39478     if (obj->pObjects)
39479     {
39480         PRINT_SPACE
39481         _OUT << "[" << std::endl;
39482         for (unsigned int i = 0; i < obj->objectCount; i++)
39483         {
39484             if (i + 1 == obj->objectCount)
39485                 print_VkDebugUtilsObjectNameInfoEXT(obj->pObjects[i], "pObjects", 0);
39486             else
39487                 print_VkDebugUtilsObjectNameInfoEXT(obj->pObjects[i], "pObjects", 1);
39488         }
39489         PRINT_SPACE
39490         _OUT << "]" << std::endl;
39491     }
39492     else
39493     {
39494         PRINT_SPACE _OUT << "\"NULL\""
39495                          << "" << std::endl;
39496     }
39497 
39498     INDENT(-4);
39499     PRINT_SPACE
39500     if (commaNeeded)
39501         _OUT << "}," << std::endl;
39502     else
39503         _OUT << "}" << std::endl;
39504 }
39505 
print_VkDebugUtilsMessengerCreateInfoEXT(VkDebugUtilsMessengerCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)39506 static void print_VkDebugUtilsMessengerCreateInfoEXT(VkDebugUtilsMessengerCreateInfoEXT obj, const std::string &s,
39507                                                      bool commaNeeded = true)
39508 {
39509     PRINT_SPACE
39510     _OUT << "{" << std::endl;
39511     INDENT(4);
39512 
39513     print_VkStructureType(obj.sType, "sType", 1);
39514 
39515     if (obj.pNext)
39516     {
39517         dumpPNextChain(obj.pNext);
39518     }
39519     else
39520     {
39521         PRINT_SPACE
39522         _OUT << "\"pNext\":"
39523              << "\"NULL\""
39524              << "," << std::endl;
39525     }
39526 
39527     print_VkDebugUtilsMessengerCreateFlagsEXT(obj.flags, "flags", 1);
39528 
39529     print_VkDebugUtilsMessageSeverityFlagsEXT(obj.messageSeverity, "messageSeverity", 1);
39530 
39531     print_VkDebugUtilsMessageTypeFlagsEXT(obj.messageType, "messageType", 1);
39532 
39533     /** Note: Ignoring function pointer (PFN_vkDebugUtilsMessengerCallbackEXT). **/
39534 
39535     /** Note: Ignoring void* data. **/
39536 
39537     INDENT(-4);
39538     PRINT_SPACE
39539     if (commaNeeded)
39540         _OUT << "}," << std::endl;
39541     else
39542         _OUT << "}" << std::endl;
39543 }
print_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)39544 static void print_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT *obj,
39545                                                      const std::string &s, bool commaNeeded = true)
39546 {
39547     PRINT_SPACE
39548     _OUT << "{" << std::endl;
39549     INDENT(4);
39550 
39551     print_VkStructureType(obj->sType, "sType", 1);
39552 
39553     if (obj->pNext)
39554     {
39555         dumpPNextChain(obj->pNext);
39556     }
39557     else
39558     {
39559         PRINT_SPACE
39560         _OUT << "\"pNext\":"
39561              << "\"NULL\""
39562              << "," << std::endl;
39563     }
39564 
39565     print_VkDebugUtilsMessengerCreateFlagsEXT(obj->flags, "flags", 1);
39566 
39567     print_VkDebugUtilsMessageSeverityFlagsEXT(obj->messageSeverity, "messageSeverity", 1);
39568 
39569     print_VkDebugUtilsMessageTypeFlagsEXT(obj->messageType, "messageType", 1);
39570 
39571     /** Note: Ignoring function pointer (PFN_vkDebugUtilsMessengerCallbackEXT). **/
39572 
39573     /** Note: Ignoring void* data. **/
39574 
39575     INDENT(-4);
39576     PRINT_SPACE
39577     if (commaNeeded)
39578         _OUT << "}," << std::endl;
39579     else
39580         _OUT << "}" << std::endl;
39581 }
39582 
print_VkDebugUtilsObjectTagInfoEXT(VkDebugUtilsObjectTagInfoEXT obj,const std::string & s,bool commaNeeded=true)39583 static void print_VkDebugUtilsObjectTagInfoEXT(VkDebugUtilsObjectTagInfoEXT obj, const std::string &s,
39584                                                bool commaNeeded = true)
39585 {
39586     PRINT_SPACE
39587     _OUT << "{" << std::endl;
39588     INDENT(4);
39589 
39590     print_VkStructureType(obj.sType, "sType", 1);
39591 
39592     if (obj.pNext)
39593     {
39594         dumpPNextChain(obj.pNext);
39595     }
39596     else
39597     {
39598         PRINT_SPACE
39599         _OUT << "\"pNext\":"
39600              << "\"NULL\""
39601              << "," << std::endl;
39602     }
39603 
39604     print_VkObjectType(obj.objectType, "objectType", 1);
39605 
39606     print_uint64_t(obj.objectHandle, "objectHandle", 1);
39607 
39608     print_uint64_t(obj.tagName, "tagName", 1);
39609 
39610     print_size_t(obj.tagSize, "tagSize", 1);
39611 
39612     /** Note: Ignoring void* data. **/
39613 
39614     INDENT(-4);
39615     PRINT_SPACE
39616     if (commaNeeded)
39617         _OUT << "}," << std::endl;
39618     else
39619         _OUT << "}" << std::endl;
39620 }
print_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT * obj,const std::string & s,bool commaNeeded=true)39621 static void print_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT *obj, const std::string &s,
39622                                                bool commaNeeded = true)
39623 {
39624     PRINT_SPACE
39625     _OUT << "{" << std::endl;
39626     INDENT(4);
39627 
39628     print_VkStructureType(obj->sType, "sType", 1);
39629 
39630     if (obj->pNext)
39631     {
39632         dumpPNextChain(obj->pNext);
39633     }
39634     else
39635     {
39636         PRINT_SPACE
39637         _OUT << "\"pNext\":"
39638              << "\"NULL\""
39639              << "," << std::endl;
39640     }
39641 
39642     print_VkObjectType(obj->objectType, "objectType", 1);
39643 
39644     print_uint64_t(obj->objectHandle, "objectHandle", 1);
39645 
39646     print_uint64_t(obj->tagName, "tagName", 1);
39647 
39648     print_size_t(obj->tagSize, "tagSize", 1);
39649 
39650     /** Note: Ignoring void* data. **/
39651 
39652     INDENT(-4);
39653     PRINT_SPACE
39654     if (commaNeeded)
39655         _OUT << "}," << std::endl;
39656     else
39657         _OUT << "}" << std::endl;
39658 }
39659 
print_VkSampleLocationEXT(VkSampleLocationEXT obj,const std::string & s,bool commaNeeded=true)39660 static void print_VkSampleLocationEXT(VkSampleLocationEXT obj, const std::string &s, bool commaNeeded = true)
39661 {
39662     PRINT_SPACE
39663     _OUT << "{" << std::endl;
39664     INDENT(4);
39665 
39666     print_float(obj.x, "x", 1);
39667 
39668     print_float(obj.y, "y", 0);
39669 
39670     INDENT(-4);
39671     PRINT_SPACE
39672     if (commaNeeded)
39673         _OUT << "}," << std::endl;
39674     else
39675         _OUT << "}" << std::endl;
39676 }
print_VkSampleLocationEXT(const VkSampleLocationEXT * obj,const std::string & s,bool commaNeeded=true)39677 static void print_VkSampleLocationEXT(const VkSampleLocationEXT *obj, const std::string &s, bool commaNeeded = true)
39678 {
39679     PRINT_SPACE
39680     _OUT << "{" << std::endl;
39681     INDENT(4);
39682 
39683     print_float(obj->x, "x", 1);
39684 
39685     print_float(obj->y, "y", 0);
39686 
39687     INDENT(-4);
39688     PRINT_SPACE
39689     if (commaNeeded)
39690         _OUT << "}," << std::endl;
39691     else
39692         _OUT << "}" << std::endl;
39693 }
39694 
print_VkSampleLocationsInfoEXT(VkSampleLocationsInfoEXT obj,const std::string & s,bool commaNeeded=true)39695 static void print_VkSampleLocationsInfoEXT(VkSampleLocationsInfoEXT obj, const std::string &s, bool commaNeeded = true)
39696 {
39697     PRINT_SPACE
39698     _OUT << "{" << std::endl;
39699     INDENT(4);
39700 
39701     print_VkStructureType(obj.sType, "sType", 1);
39702 
39703     if (obj.pNext)
39704     {
39705         dumpPNextChain(obj.pNext);
39706     }
39707     else
39708     {
39709         PRINT_SPACE
39710         _OUT << "\"pNext\":"
39711              << "\"NULL\""
39712              << "," << std::endl;
39713     }
39714 
39715     print_VkSampleCountFlagBits(obj.sampleLocationsPerPixel, "sampleLocationsPerPixel", 1);
39716 
39717     PRINT_SPACE
39718     _OUT << "\"sampleLocationGridSize\": " << std::endl;
39719     {
39720         print_VkExtent2D(obj.sampleLocationGridSize, "sampleLocationGridSize", 1);
39721     }
39722 
39723     print_uint32_t(obj.sampleLocationsCount, "sampleLocationsCount", 1);
39724 
39725     PRINT_SPACE
39726     _OUT << "\"pSampleLocations\": " << std::endl;
39727     if (obj.pSampleLocations)
39728     {
39729         PRINT_SPACE
39730         _OUT << "[" << std::endl;
39731         for (unsigned int i = 0; i < obj.sampleLocationsCount; i++)
39732         {
39733             if (i + 1 == obj.sampleLocationsCount)
39734                 print_VkSampleLocationEXT(obj.pSampleLocations[i], "pSampleLocations", 0);
39735             else
39736                 print_VkSampleLocationEXT(obj.pSampleLocations[i], "pSampleLocations", 1);
39737         }
39738         PRINT_SPACE
39739         _OUT << "]" << std::endl;
39740     }
39741     else
39742     {
39743         PRINT_SPACE _OUT << "\"NULL\""
39744                          << "" << std::endl;
39745     }
39746 
39747     INDENT(-4);
39748     PRINT_SPACE
39749     if (commaNeeded)
39750         _OUT << "}," << std::endl;
39751     else
39752         _OUT << "}" << std::endl;
39753 }
print_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT * obj,const std::string & s,bool commaNeeded=true)39754 static void print_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT *obj, const std::string &s,
39755                                            bool commaNeeded = true)
39756 {
39757     PRINT_SPACE
39758     _OUT << "{" << std::endl;
39759     INDENT(4);
39760 
39761     print_VkStructureType(obj->sType, "sType", 1);
39762 
39763     if (obj->pNext)
39764     {
39765         dumpPNextChain(obj->pNext);
39766     }
39767     else
39768     {
39769         PRINT_SPACE
39770         _OUT << "\"pNext\":"
39771              << "\"NULL\""
39772              << "," << std::endl;
39773     }
39774 
39775     print_VkSampleCountFlagBits(obj->sampleLocationsPerPixel, "sampleLocationsPerPixel", 1);
39776 
39777     PRINT_SPACE
39778     _OUT << "\"sampleLocationGridSize\": " << std::endl;
39779     {
39780         print_VkExtent2D(obj->sampleLocationGridSize, "sampleLocationGridSize", 1);
39781     }
39782 
39783     print_uint32_t(obj->sampleLocationsCount, "sampleLocationsCount", 1);
39784 
39785     PRINT_SPACE
39786     _OUT << "\"pSampleLocations\": " << std::endl;
39787     if (obj->pSampleLocations)
39788     {
39789         PRINT_SPACE
39790         _OUT << "[" << std::endl;
39791         for (unsigned int i = 0; i < obj->sampleLocationsCount; i++)
39792         {
39793             if (i + 1 == obj->sampleLocationsCount)
39794                 print_VkSampleLocationEXT(obj->pSampleLocations[i], "pSampleLocations", 0);
39795             else
39796                 print_VkSampleLocationEXT(obj->pSampleLocations[i], "pSampleLocations", 1);
39797         }
39798         PRINT_SPACE
39799         _OUT << "]" << std::endl;
39800     }
39801     else
39802     {
39803         PRINT_SPACE _OUT << "\"NULL\""
39804                          << "" << std::endl;
39805     }
39806 
39807     INDENT(-4);
39808     PRINT_SPACE
39809     if (commaNeeded)
39810         _OUT << "}," << std::endl;
39811     else
39812         _OUT << "}" << std::endl;
39813 }
39814 
print_VkAttachmentSampleLocationsEXT(VkAttachmentSampleLocationsEXT obj,const std::string & s,bool commaNeeded=true)39815 static void print_VkAttachmentSampleLocationsEXT(VkAttachmentSampleLocationsEXT obj, const std::string &s,
39816                                                  bool commaNeeded = true)
39817 {
39818     PRINT_SPACE
39819     _OUT << "{" << std::endl;
39820     INDENT(4);
39821 
39822     print_uint32_t(obj.attachmentIndex, "attachmentIndex", 1);
39823 
39824     PRINT_SPACE
39825     _OUT << "\"sampleLocationsInfo\": " << std::endl;
39826     {
39827         print_VkSampleLocationsInfoEXT(obj.sampleLocationsInfo, "sampleLocationsInfo", 0);
39828     }
39829 
39830     INDENT(-4);
39831     PRINT_SPACE
39832     if (commaNeeded)
39833         _OUT << "}," << std::endl;
39834     else
39835         _OUT << "}" << std::endl;
39836 }
print_VkAttachmentSampleLocationsEXT(const VkAttachmentSampleLocationsEXT * obj,const std::string & s,bool commaNeeded=true)39837 static void print_VkAttachmentSampleLocationsEXT(const VkAttachmentSampleLocationsEXT *obj, const std::string &s,
39838                                                  bool commaNeeded = true)
39839 {
39840     PRINT_SPACE
39841     _OUT << "{" << std::endl;
39842     INDENT(4);
39843 
39844     print_uint32_t(obj->attachmentIndex, "attachmentIndex", 1);
39845 
39846     PRINT_SPACE
39847     _OUT << "\"sampleLocationsInfo\": " << std::endl;
39848     {
39849         print_VkSampleLocationsInfoEXT(obj->sampleLocationsInfo, "sampleLocationsInfo", 0);
39850     }
39851 
39852     INDENT(-4);
39853     PRINT_SPACE
39854     if (commaNeeded)
39855         _OUT << "}," << std::endl;
39856     else
39857         _OUT << "}" << std::endl;
39858 }
39859 
print_VkSubpassSampleLocationsEXT(VkSubpassSampleLocationsEXT obj,const std::string & s,bool commaNeeded=true)39860 static void print_VkSubpassSampleLocationsEXT(VkSubpassSampleLocationsEXT obj, const std::string &s,
39861                                               bool commaNeeded = true)
39862 {
39863     PRINT_SPACE
39864     _OUT << "{" << std::endl;
39865     INDENT(4);
39866 
39867     print_uint32_t(obj.subpassIndex, "subpassIndex", 1);
39868 
39869     PRINT_SPACE
39870     _OUT << "\"sampleLocationsInfo\": " << std::endl;
39871     {
39872         print_VkSampleLocationsInfoEXT(obj.sampleLocationsInfo, "sampleLocationsInfo", 0);
39873     }
39874 
39875     INDENT(-4);
39876     PRINT_SPACE
39877     if (commaNeeded)
39878         _OUT << "}," << std::endl;
39879     else
39880         _OUT << "}" << std::endl;
39881 }
print_VkSubpassSampleLocationsEXT(const VkSubpassSampleLocationsEXT * obj,const std::string & s,bool commaNeeded=true)39882 static void print_VkSubpassSampleLocationsEXT(const VkSubpassSampleLocationsEXT *obj, const std::string &s,
39883                                               bool commaNeeded = true)
39884 {
39885     PRINT_SPACE
39886     _OUT << "{" << std::endl;
39887     INDENT(4);
39888 
39889     print_uint32_t(obj->subpassIndex, "subpassIndex", 1);
39890 
39891     PRINT_SPACE
39892     _OUT << "\"sampleLocationsInfo\": " << std::endl;
39893     {
39894         print_VkSampleLocationsInfoEXT(obj->sampleLocationsInfo, "sampleLocationsInfo", 0);
39895     }
39896 
39897     INDENT(-4);
39898     PRINT_SPACE
39899     if (commaNeeded)
39900         _OUT << "}," << std::endl;
39901     else
39902         _OUT << "}" << std::endl;
39903 }
39904 
print_VkRenderPassSampleLocationsBeginInfoEXT(VkRenderPassSampleLocationsBeginInfoEXT obj,const std::string & s,bool commaNeeded=true)39905 static void print_VkRenderPassSampleLocationsBeginInfoEXT(VkRenderPassSampleLocationsBeginInfoEXT obj,
39906                                                           const std::string &s, bool commaNeeded = true)
39907 {
39908     PRINT_SPACE
39909     _OUT << "{" << std::endl;
39910     INDENT(4);
39911 
39912     print_VkStructureType(obj.sType, "sType", 1);
39913 
39914     if (obj.pNext)
39915     {
39916         dumpPNextChain(obj.pNext);
39917     }
39918     else
39919     {
39920         PRINT_SPACE
39921         _OUT << "\"pNext\":"
39922              << "\"NULL\""
39923              << "," << std::endl;
39924     }
39925 
39926     print_uint32_t(obj.attachmentInitialSampleLocationsCount, "attachmentInitialSampleLocationsCount", 1);
39927 
39928     PRINT_SPACE
39929     _OUT << "\"pAttachmentInitialSampleLocations\": " << std::endl;
39930     if (obj.pAttachmentInitialSampleLocations)
39931     {
39932         PRINT_SPACE
39933         _OUT << "[" << std::endl;
39934         for (unsigned int i = 0; i < obj.attachmentInitialSampleLocationsCount; i++)
39935         {
39936             if (i + 1 == obj.attachmentInitialSampleLocationsCount)
39937                 print_VkAttachmentSampleLocationsEXT(obj.pAttachmentInitialSampleLocations[i],
39938                                                      "pAttachmentInitialSampleLocations", 0);
39939             else
39940                 print_VkAttachmentSampleLocationsEXT(obj.pAttachmentInitialSampleLocations[i],
39941                                                      "pAttachmentInitialSampleLocations", 1);
39942         }
39943         PRINT_SPACE
39944         _OUT << "]," << std::endl;
39945     }
39946     else
39947     {
39948         PRINT_SPACE _OUT << "\"NULL\""
39949                          << "," << std::endl;
39950     }
39951 
39952     print_uint32_t(obj.postSubpassSampleLocationsCount, "postSubpassSampleLocationsCount", 1);
39953 
39954     PRINT_SPACE
39955     _OUT << "\"pPostSubpassSampleLocations\": " << std::endl;
39956     if (obj.pPostSubpassSampleLocations)
39957     {
39958         PRINT_SPACE
39959         _OUT << "[" << std::endl;
39960         for (unsigned int i = 0; i < obj.postSubpassSampleLocationsCount; i++)
39961         {
39962             if (i + 1 == obj.postSubpassSampleLocationsCount)
39963                 print_VkSubpassSampleLocationsEXT(obj.pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations", 0);
39964             else
39965                 print_VkSubpassSampleLocationsEXT(obj.pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations", 1);
39966         }
39967         PRINT_SPACE
39968         _OUT << "]" << std::endl;
39969     }
39970     else
39971     {
39972         PRINT_SPACE _OUT << "\"NULL\""
39973                          << "" << std::endl;
39974     }
39975 
39976     INDENT(-4);
39977     PRINT_SPACE
39978     if (commaNeeded)
39979         _OUT << "}," << std::endl;
39980     else
39981         _OUT << "}" << std::endl;
39982 }
print_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT * obj,const std::string & s,bool commaNeeded=true)39983 static void print_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT *obj,
39984                                                           const std::string &s, bool commaNeeded = true)
39985 {
39986     PRINT_SPACE
39987     _OUT << "{" << std::endl;
39988     INDENT(4);
39989 
39990     print_VkStructureType(obj->sType, "sType", 1);
39991 
39992     if (obj->pNext)
39993     {
39994         dumpPNextChain(obj->pNext);
39995     }
39996     else
39997     {
39998         PRINT_SPACE
39999         _OUT << "\"pNext\":"
40000              << "\"NULL\""
40001              << "," << std::endl;
40002     }
40003 
40004     print_uint32_t(obj->attachmentInitialSampleLocationsCount, "attachmentInitialSampleLocationsCount", 1);
40005 
40006     PRINT_SPACE
40007     _OUT << "\"pAttachmentInitialSampleLocations\": " << std::endl;
40008     if (obj->pAttachmentInitialSampleLocations)
40009     {
40010         PRINT_SPACE
40011         _OUT << "[" << std::endl;
40012         for (unsigned int i = 0; i < obj->attachmentInitialSampleLocationsCount; i++)
40013         {
40014             if (i + 1 == obj->attachmentInitialSampleLocationsCount)
40015                 print_VkAttachmentSampleLocationsEXT(obj->pAttachmentInitialSampleLocations[i],
40016                                                      "pAttachmentInitialSampleLocations", 0);
40017             else
40018                 print_VkAttachmentSampleLocationsEXT(obj->pAttachmentInitialSampleLocations[i],
40019                                                      "pAttachmentInitialSampleLocations", 1);
40020         }
40021         PRINT_SPACE
40022         _OUT << "]," << std::endl;
40023     }
40024     else
40025     {
40026         PRINT_SPACE _OUT << "\"NULL\""
40027                          << "," << std::endl;
40028     }
40029 
40030     print_uint32_t(obj->postSubpassSampleLocationsCount, "postSubpassSampleLocationsCount", 1);
40031 
40032     PRINT_SPACE
40033     _OUT << "\"pPostSubpassSampleLocations\": " << std::endl;
40034     if (obj->pPostSubpassSampleLocations)
40035     {
40036         PRINT_SPACE
40037         _OUT << "[" << std::endl;
40038         for (unsigned int i = 0; i < obj->postSubpassSampleLocationsCount; i++)
40039         {
40040             if (i + 1 == obj->postSubpassSampleLocationsCount)
40041                 print_VkSubpassSampleLocationsEXT(obj->pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations",
40042                                                   0);
40043             else
40044                 print_VkSubpassSampleLocationsEXT(obj->pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations",
40045                                                   1);
40046         }
40047         PRINT_SPACE
40048         _OUT << "]" << std::endl;
40049     }
40050     else
40051     {
40052         PRINT_SPACE _OUT << "\"NULL\""
40053                          << "" << std::endl;
40054     }
40055 
40056     INDENT(-4);
40057     PRINT_SPACE
40058     if (commaNeeded)
40059         _OUT << "}," << std::endl;
40060     else
40061         _OUT << "}" << std::endl;
40062 }
40063 
print_VkPipelineSampleLocationsStateCreateInfoEXT(VkPipelineSampleLocationsStateCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)40064 static void print_VkPipelineSampleLocationsStateCreateInfoEXT(VkPipelineSampleLocationsStateCreateInfoEXT obj,
40065                                                               const std::string &s, bool commaNeeded = true)
40066 {
40067     PRINT_SPACE
40068     _OUT << "{" << std::endl;
40069     INDENT(4);
40070 
40071     print_VkStructureType(obj.sType, "sType", 1);
40072 
40073     if (obj.pNext)
40074     {
40075         dumpPNextChain(obj.pNext);
40076     }
40077     else
40078     {
40079         PRINT_SPACE
40080         _OUT << "\"pNext\":"
40081              << "\"NULL\""
40082              << "," << std::endl;
40083     }
40084 
40085     print_VkBool32(obj.sampleLocationsEnable, "sampleLocationsEnable", 1);
40086 
40087     PRINT_SPACE
40088     _OUT << "\"sampleLocationsInfo\": " << std::endl;
40089     {
40090         print_VkSampleLocationsInfoEXT(obj.sampleLocationsInfo, "sampleLocationsInfo", 0);
40091     }
40092 
40093     INDENT(-4);
40094     PRINT_SPACE
40095     if (commaNeeded)
40096         _OUT << "}," << std::endl;
40097     else
40098         _OUT << "}" << std::endl;
40099 }
print_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)40100 static void print_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT *obj,
40101                                                               const std::string &s, bool commaNeeded = true)
40102 {
40103     PRINT_SPACE
40104     _OUT << "{" << std::endl;
40105     INDENT(4);
40106 
40107     print_VkStructureType(obj->sType, "sType", 1);
40108 
40109     if (obj->pNext)
40110     {
40111         dumpPNextChain(obj->pNext);
40112     }
40113     else
40114     {
40115         PRINT_SPACE
40116         _OUT << "\"pNext\":"
40117              << "\"NULL\""
40118              << "," << std::endl;
40119     }
40120 
40121     print_VkBool32(obj->sampleLocationsEnable, "sampleLocationsEnable", 1);
40122 
40123     PRINT_SPACE
40124     _OUT << "\"sampleLocationsInfo\": " << std::endl;
40125     {
40126         print_VkSampleLocationsInfoEXT(obj->sampleLocationsInfo, "sampleLocationsInfo", 0);
40127     }
40128 
40129     INDENT(-4);
40130     PRINT_SPACE
40131     if (commaNeeded)
40132         _OUT << "}," << std::endl;
40133     else
40134         _OUT << "}" << std::endl;
40135 }
40136 
print_VkPhysicalDeviceSampleLocationsPropertiesEXT(VkPhysicalDeviceSampleLocationsPropertiesEXT obj,const std::string & s,bool commaNeeded=true)40137 static void print_VkPhysicalDeviceSampleLocationsPropertiesEXT(VkPhysicalDeviceSampleLocationsPropertiesEXT obj,
40138                                                                const std::string &s, bool commaNeeded = true)
40139 {
40140     PRINT_SPACE
40141     _OUT << "{" << std::endl;
40142     INDENT(4);
40143 
40144     print_VkStructureType(obj.sType, "sType", 1);
40145 
40146     if (obj.pNext)
40147     {
40148         dumpPNextChain(obj.pNext);
40149     }
40150     else
40151     {
40152         PRINT_SPACE
40153         _OUT << "\"pNext\":"
40154              << "\"NULL\""
40155              << "," << std::endl;
40156     }
40157 
40158     print_VkSampleCountFlags(obj.sampleLocationSampleCounts, "sampleLocationSampleCounts", 1);
40159 
40160     PRINT_SPACE
40161     _OUT << "\"maxSampleLocationGridSize\": " << std::endl;
40162     {
40163         print_VkExtent2D(obj.maxSampleLocationGridSize, "maxSampleLocationGridSize", 1);
40164     }
40165 
40166     PRINT_SPACE
40167     _OUT << "\"sampleLocationCoordinateRange\":" << std::endl;
40168     PRINT_SPACE
40169     _OUT << "[" << std::endl;
40170     for (unsigned int i = 0; i < 2; i++)
40171     {
40172         bool isCommaNeeded = (i + 1) != 2;
40173         print_float(obj.sampleLocationCoordinateRange[i], "", isCommaNeeded);
40174     }
40175     PRINT_SPACE
40176     _OUT << "]"
40177          << "," << std::endl;
40178 
40179     print_uint32_t(obj.sampleLocationSubPixelBits, "sampleLocationSubPixelBits", 1);
40180 
40181     print_VkBool32(obj.variableSampleLocations, "variableSampleLocations", 0);
40182 
40183     INDENT(-4);
40184     PRINT_SPACE
40185     if (commaNeeded)
40186         _OUT << "}," << std::endl;
40187     else
40188         _OUT << "}" << std::endl;
40189 }
print_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)40190 static void print_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT *obj,
40191                                                                const std::string &s, bool commaNeeded = true)
40192 {
40193     PRINT_SPACE
40194     _OUT << "{" << std::endl;
40195     INDENT(4);
40196 
40197     print_VkStructureType(obj->sType, "sType", 1);
40198 
40199     if (obj->pNext)
40200     {
40201         dumpPNextChain(obj->pNext);
40202     }
40203     else
40204     {
40205         PRINT_SPACE
40206         _OUT << "\"pNext\":"
40207              << "\"NULL\""
40208              << "," << std::endl;
40209     }
40210 
40211     print_VkSampleCountFlags(obj->sampleLocationSampleCounts, "sampleLocationSampleCounts", 1);
40212 
40213     PRINT_SPACE
40214     _OUT << "\"maxSampleLocationGridSize\": " << std::endl;
40215     {
40216         print_VkExtent2D(obj->maxSampleLocationGridSize, "maxSampleLocationGridSize", 1);
40217     }
40218 
40219     PRINT_SPACE
40220     _OUT << "\"sampleLocationCoordinateRange\":" << std::endl;
40221     PRINT_SPACE
40222     _OUT << "[" << std::endl;
40223     for (unsigned int i = 0; i < 2; i++)
40224     {
40225         bool isCommaNeeded = (i + 1) != 2;
40226         print_float(obj->sampleLocationCoordinateRange[i], "", isCommaNeeded);
40227     }
40228     PRINT_SPACE
40229     _OUT << "]"
40230          << "," << std::endl;
40231 
40232     print_uint32_t(obj->sampleLocationSubPixelBits, "sampleLocationSubPixelBits", 1);
40233 
40234     print_VkBool32(obj->variableSampleLocations, "variableSampleLocations", 0);
40235 
40236     INDENT(-4);
40237     PRINT_SPACE
40238     if (commaNeeded)
40239         _OUT << "}," << std::endl;
40240     else
40241         _OUT << "}" << std::endl;
40242 }
40243 
print_VkMultisamplePropertiesEXT(VkMultisamplePropertiesEXT obj,const std::string & s,bool commaNeeded=true)40244 static void print_VkMultisamplePropertiesEXT(VkMultisamplePropertiesEXT obj, const std::string &s,
40245                                              bool commaNeeded = true)
40246 {
40247     PRINT_SPACE
40248     _OUT << "{" << std::endl;
40249     INDENT(4);
40250 
40251     print_VkStructureType(obj.sType, "sType", 1);
40252 
40253     if (obj.pNext)
40254     {
40255         dumpPNextChain(obj.pNext);
40256     }
40257     else
40258     {
40259         PRINT_SPACE
40260         _OUT << "\"pNext\":"
40261              << "\"NULL\""
40262              << "," << std::endl;
40263     }
40264 
40265     PRINT_SPACE
40266     _OUT << "\"maxSampleLocationGridSize\": " << std::endl;
40267     {
40268         print_VkExtent2D(obj.maxSampleLocationGridSize, "maxSampleLocationGridSize", 0);
40269     }
40270 
40271     INDENT(-4);
40272     PRINT_SPACE
40273     if (commaNeeded)
40274         _OUT << "}," << std::endl;
40275     else
40276         _OUT << "}" << std::endl;
40277 }
print_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT * obj,const std::string & s,bool commaNeeded=true)40278 static void print_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT *obj, const std::string &s,
40279                                              bool commaNeeded = true)
40280 {
40281     PRINT_SPACE
40282     _OUT << "{" << std::endl;
40283     INDENT(4);
40284 
40285     print_VkStructureType(obj->sType, "sType", 1);
40286 
40287     if (obj->pNext)
40288     {
40289         dumpPNextChain(obj->pNext);
40290     }
40291     else
40292     {
40293         PRINT_SPACE
40294         _OUT << "\"pNext\":"
40295              << "\"NULL\""
40296              << "," << std::endl;
40297     }
40298 
40299     PRINT_SPACE
40300     _OUT << "\"maxSampleLocationGridSize\": " << std::endl;
40301     {
40302         print_VkExtent2D(obj->maxSampleLocationGridSize, "maxSampleLocationGridSize", 0);
40303     }
40304 
40305     INDENT(-4);
40306     PRINT_SPACE
40307     if (commaNeeded)
40308         _OUT << "}," << std::endl;
40309     else
40310         _OUT << "}" << std::endl;
40311 }
40312 
40313 static std::map<uint64_t, std::string> VkBlendOverlapEXT_map = {
40314     std::make_pair(0, "VK_BLEND_OVERLAP_UNCORRELATED_EXT"),
40315     std::make_pair(1, "VK_BLEND_OVERLAP_DISJOINT_EXT"),
40316     std::make_pair(2, "VK_BLEND_OVERLAP_CONJOINT_EXT"),
40317 };
print_VkBlendOverlapEXT(VkBlendOverlapEXT obj,const std::string & str,bool commaNeeded=true)40318 static void print_VkBlendOverlapEXT(VkBlendOverlapEXT obj, const std::string &str, bool commaNeeded = true)
40319 {
40320     PRINT_SPACE
40321     if (str != "")
40322         _OUT << "\"" << str << "\""
40323              << " : ";
40324     if (commaNeeded)
40325         _OUT << "\"" << VkBlendOverlapEXT_map[obj] << "\"," << std::endl;
40326     else
40327         _OUT << "\"" << VkBlendOverlapEXT_map[obj] << "\"" << std::endl;
40328 }
print_VkBlendOverlapEXT(const VkBlendOverlapEXT * obj,const std::string & str,bool commaNeeded=true)40329 static void print_VkBlendOverlapEXT(const VkBlendOverlapEXT *obj, const std::string &str, bool commaNeeded = true)
40330 {
40331     PRINT_SPACE
40332     if (str != "")
40333         _OUT << "\"" << str << "\""
40334              << " : ";
40335     if (commaNeeded)
40336         _OUT << "\"" << VkBlendOverlapEXT_map[*obj] << "\"," << std::endl;
40337     else
40338         _OUT << "\"" << VkBlendOverlapEXT_map[*obj] << "\"" << std::endl;
40339 }
40340 
print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT obj,const std::string & s,bool commaNeeded=true)40341 static void print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
40342     VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT obj, const std::string &s, bool commaNeeded = true)
40343 {
40344     PRINT_SPACE
40345     _OUT << "{" << std::endl;
40346     INDENT(4);
40347 
40348     print_VkStructureType(obj.sType, "sType", 1);
40349 
40350     if (obj.pNext)
40351     {
40352         dumpPNextChain(obj.pNext);
40353     }
40354     else
40355     {
40356         PRINT_SPACE
40357         _OUT << "\"pNext\":"
40358              << "\"NULL\""
40359              << "," << std::endl;
40360     }
40361 
40362     print_VkBool32(obj.advancedBlendCoherentOperations, "advancedBlendCoherentOperations", 0);
40363 
40364     INDENT(-4);
40365     PRINT_SPACE
40366     if (commaNeeded)
40367         _OUT << "}," << std::endl;
40368     else
40369         _OUT << "}" << std::endl;
40370 }
print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)40371 static void print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
40372     const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *obj, const std::string &s, bool commaNeeded = true)
40373 {
40374     PRINT_SPACE
40375     _OUT << "{" << std::endl;
40376     INDENT(4);
40377 
40378     print_VkStructureType(obj->sType, "sType", 1);
40379 
40380     if (obj->pNext)
40381     {
40382         dumpPNextChain(obj->pNext);
40383     }
40384     else
40385     {
40386         PRINT_SPACE
40387         _OUT << "\"pNext\":"
40388              << "\"NULL\""
40389              << "," << std::endl;
40390     }
40391 
40392     print_VkBool32(obj->advancedBlendCoherentOperations, "advancedBlendCoherentOperations", 0);
40393 
40394     INDENT(-4);
40395     PRINT_SPACE
40396     if (commaNeeded)
40397         _OUT << "}," << std::endl;
40398     else
40399         _OUT << "}" << std::endl;
40400 }
40401 
print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT obj,const std::string & s,bool commaNeeded=true)40402 static void print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
40403     VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT obj, const std::string &s, bool commaNeeded = true)
40404 {
40405     PRINT_SPACE
40406     _OUT << "{" << std::endl;
40407     INDENT(4);
40408 
40409     print_VkStructureType(obj.sType, "sType", 1);
40410 
40411     if (obj.pNext)
40412     {
40413         dumpPNextChain(obj.pNext);
40414     }
40415     else
40416     {
40417         PRINT_SPACE
40418         _OUT << "\"pNext\":"
40419              << "\"NULL\""
40420              << "," << std::endl;
40421     }
40422 
40423     print_uint32_t(obj.advancedBlendMaxColorAttachments, "advancedBlendMaxColorAttachments", 1);
40424 
40425     print_VkBool32(obj.advancedBlendIndependentBlend, "advancedBlendIndependentBlend", 1);
40426 
40427     print_VkBool32(obj.advancedBlendNonPremultipliedSrcColor, "advancedBlendNonPremultipliedSrcColor", 1);
40428 
40429     print_VkBool32(obj.advancedBlendNonPremultipliedDstColor, "advancedBlendNonPremultipliedDstColor", 1);
40430 
40431     print_VkBool32(obj.advancedBlendCorrelatedOverlap, "advancedBlendCorrelatedOverlap", 1);
40432 
40433     print_VkBool32(obj.advancedBlendAllOperations, "advancedBlendAllOperations", 0);
40434 
40435     INDENT(-4);
40436     PRINT_SPACE
40437     if (commaNeeded)
40438         _OUT << "}," << std::endl;
40439     else
40440         _OUT << "}" << std::endl;
40441 }
print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)40442 static void print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
40443     const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *obj, const std::string &s, bool commaNeeded = true)
40444 {
40445     PRINT_SPACE
40446     _OUT << "{" << std::endl;
40447     INDENT(4);
40448 
40449     print_VkStructureType(obj->sType, "sType", 1);
40450 
40451     if (obj->pNext)
40452     {
40453         dumpPNextChain(obj->pNext);
40454     }
40455     else
40456     {
40457         PRINT_SPACE
40458         _OUT << "\"pNext\":"
40459              << "\"NULL\""
40460              << "," << std::endl;
40461     }
40462 
40463     print_uint32_t(obj->advancedBlendMaxColorAttachments, "advancedBlendMaxColorAttachments", 1);
40464 
40465     print_VkBool32(obj->advancedBlendIndependentBlend, "advancedBlendIndependentBlend", 1);
40466 
40467     print_VkBool32(obj->advancedBlendNonPremultipliedSrcColor, "advancedBlendNonPremultipliedSrcColor", 1);
40468 
40469     print_VkBool32(obj->advancedBlendNonPremultipliedDstColor, "advancedBlendNonPremultipliedDstColor", 1);
40470 
40471     print_VkBool32(obj->advancedBlendCorrelatedOverlap, "advancedBlendCorrelatedOverlap", 1);
40472 
40473     print_VkBool32(obj->advancedBlendAllOperations, "advancedBlendAllOperations", 0);
40474 
40475     INDENT(-4);
40476     PRINT_SPACE
40477     if (commaNeeded)
40478         _OUT << "}," << std::endl;
40479     else
40480         _OUT << "}" << std::endl;
40481 }
40482 
print_VkPipelineColorBlendAdvancedStateCreateInfoEXT(VkPipelineColorBlendAdvancedStateCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)40483 static void print_VkPipelineColorBlendAdvancedStateCreateInfoEXT(VkPipelineColorBlendAdvancedStateCreateInfoEXT obj,
40484                                                                  const std::string &s, bool commaNeeded = true)
40485 {
40486     PRINT_SPACE
40487     _OUT << "{" << std::endl;
40488     INDENT(4);
40489 
40490     print_VkStructureType(obj.sType, "sType", 1);
40491 
40492     if (obj.pNext)
40493     {
40494         dumpPNextChain(obj.pNext);
40495     }
40496     else
40497     {
40498         PRINT_SPACE
40499         _OUT << "\"pNext\":"
40500              << "\"NULL\""
40501              << "," << std::endl;
40502     }
40503 
40504     print_VkBool32(obj.srcPremultiplied, "srcPremultiplied", 1);
40505 
40506     print_VkBool32(obj.dstPremultiplied, "dstPremultiplied", 1);
40507 
40508     print_VkBlendOverlapEXT(obj.blendOverlap, "blendOverlap", 0);
40509 
40510     INDENT(-4);
40511     PRINT_SPACE
40512     if (commaNeeded)
40513         _OUT << "}," << std::endl;
40514     else
40515         _OUT << "}" << std::endl;
40516 }
print_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)40517 static void print_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
40518     const VkPipelineColorBlendAdvancedStateCreateInfoEXT *obj, const std::string &s, bool commaNeeded = true)
40519 {
40520     PRINT_SPACE
40521     _OUT << "{" << std::endl;
40522     INDENT(4);
40523 
40524     print_VkStructureType(obj->sType, "sType", 1);
40525 
40526     if (obj->pNext)
40527     {
40528         dumpPNextChain(obj->pNext);
40529     }
40530     else
40531     {
40532         PRINT_SPACE
40533         _OUT << "\"pNext\":"
40534              << "\"NULL\""
40535              << "," << std::endl;
40536     }
40537 
40538     print_VkBool32(obj->srcPremultiplied, "srcPremultiplied", 1);
40539 
40540     print_VkBool32(obj->dstPremultiplied, "dstPremultiplied", 1);
40541 
40542     print_VkBlendOverlapEXT(obj->blendOverlap, "blendOverlap", 0);
40543 
40544     INDENT(-4);
40545     PRINT_SPACE
40546     if (commaNeeded)
40547         _OUT << "}," << std::endl;
40548     else
40549         _OUT << "}" << std::endl;
40550 }
40551 
40552 static std::map<uint64_t, std::string> VkFormatFeatureFlagBits2KHR_map = {
40553     std::make_pair(1ULL << 0, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR"),
40554     std::make_pair(1ULL << 1, "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR"),
40555     std::make_pair(1ULL << 2, "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR"),
40556     std::make_pair(1ULL << 3, "VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR"),
40557     std::make_pair(1ULL << 4, "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR"),
40558     std::make_pair(1ULL << 5, "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR"),
40559     std::make_pair(1ULL << 6, "VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR"),
40560     std::make_pair(1ULL << 7, "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR"),
40561     std::make_pair(1ULL << 8, "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR"),
40562     std::make_pair(1ULL << 9, "VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR"),
40563     std::make_pair(1ULL << 10, "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR"),
40564     std::make_pair(1ULL << 11, "VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR"),
40565     std::make_pair(1ULL << 12, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR"),
40566     std::make_pair(1ULL << 13, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT"),
40567     std::make_pair(1ULL << 14, "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR"),
40568     std::make_pair(1ULL << 15, "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR"),
40569     std::make_pair(1ULL << 16, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR"),
40570     std::make_pair(1ULL << 17, "VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR"),
40571     std::make_pair(1ULL << 18, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR"),
40572     std::make_pair(1ULL << 19,
40573                    "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR"),
40574     std::make_pair(1ULL << 20,
40575                    "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR"),
40576     std::make_pair(
40577         1ULL << 21,
40578         "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR"),
40579     std::make_pair(1ULL << 22, "VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR"),
40580     std::make_pair(1ULL << 23, "VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR"),
40581     std::make_pair(1ULL << 31, "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR"),
40582     std::make_pair(1ULL << 32, "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR"),
40583     std::make_pair(1ULL << 33, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR"),
40584     std::make_pair(1ULL << 25, "VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR"),
40585     std::make_pair(1ULL << 26, "VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR"),
40586     std::make_pair(1ULL << 29, "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"),
40587     std::make_pair(1ULL << 24, "VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT"),
40588     std::make_pair(1ULL << 30, "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"),
40589     std::make_pair(1ULL << 27, "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR"),
40590     std::make_pair(1ULL << 28, "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR"),
40591 };
print_VkFormatFeatureFlagBits2KHR(VkFormatFeatureFlagBits2KHR obj,const std::string & str,bool commaNeeded=true)40592 static void print_VkFormatFeatureFlagBits2KHR(VkFormatFeatureFlagBits2KHR obj, const std::string &str,
40593                                               bool commaNeeded = true)
40594 {
40595     PRINT_SPACE
40596     if (str != "")
40597         _OUT << "\"" << str << "\""
40598              << " : ";
40599     if (commaNeeded)
40600         _OUT << "\"" << VkFormatFeatureFlagBits2KHR_map[obj] << "\"," << std::endl;
40601     else
40602         _OUT << "\"" << VkFormatFeatureFlagBits2KHR_map[obj] << "\"" << std::endl;
40603 }
print_VkFormatFeatureFlagBits2KHR(const VkFormatFeatureFlagBits2KHR * obj,const std::string & str,bool commaNeeded=true)40604 static void print_VkFormatFeatureFlagBits2KHR(const VkFormatFeatureFlagBits2KHR *obj, const std::string &str,
40605                                               bool commaNeeded = true)
40606 {
40607     PRINT_SPACE
40608     if (str != "")
40609         _OUT << "\"" << str << "\""
40610              << " : ";
40611     if (commaNeeded)
40612         _OUT << "\"" << VkFormatFeatureFlagBits2KHR_map[*obj] << "\"," << std::endl;
40613     else
40614         _OUT << "\"" << VkFormatFeatureFlagBits2KHR_map[*obj] << "\"" << std::endl;
40615 }
40616 
print_VkFormatFeatureFlags2KHR(VkFormatFeatureFlags2KHR obj,const std::string & str,bool commaNeeded=true)40617 static void print_VkFormatFeatureFlags2KHR(VkFormatFeatureFlags2KHR obj, const std::string &str,
40618                                            bool commaNeeded = true)
40619 {
40620     PRINT_SPACE
40621     if (commaNeeded)
40622         _OUT << "\"" << str << "\""
40623              << " : " << obj << "," << std::endl;
40624     else
40625         _OUT << "\"" << str << "\""
40626              << " : " << obj << std::endl;
40627 }
print_VkFormatFeatureFlags2KHR(const VkFormatFeatureFlags2KHR * obj,const std::string & str,bool commaNeeded=true)40628 static void print_VkFormatFeatureFlags2KHR(const VkFormatFeatureFlags2KHR *obj, const std::string &str,
40629                                            bool commaNeeded = true)
40630 {
40631     PRINT_SPACE
40632     if (commaNeeded)
40633         _OUT << "\"" << str << "\""
40634              << " : " << obj << "," << std::endl;
40635     else
40636         _OUT << "\"" << str << "\""
40637              << " : " << obj << std::endl;
40638 }
40639 
print_VkDrmFormatModifierPropertiesEXT(VkDrmFormatModifierPropertiesEXT obj,const std::string & s,bool commaNeeded=true)40640 static void print_VkDrmFormatModifierPropertiesEXT(VkDrmFormatModifierPropertiesEXT obj, const std::string &s,
40641                                                    bool commaNeeded = true)
40642 {
40643     PRINT_SPACE
40644     _OUT << "{" << std::endl;
40645     INDENT(4);
40646 
40647     print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 1);
40648 
40649     print_uint32_t(obj.drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1);
40650 
40651     print_VkFormatFeatureFlags(obj.drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0);
40652 
40653     INDENT(-4);
40654     PRINT_SPACE
40655     if (commaNeeded)
40656         _OUT << "}," << std::endl;
40657     else
40658         _OUT << "}" << std::endl;
40659 }
print_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)40660 static void print_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT *obj, const std::string &s,
40661                                                    bool commaNeeded = true)
40662 {
40663     PRINT_SPACE
40664     _OUT << "{" << std::endl;
40665     INDENT(4);
40666 
40667     print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 1);
40668 
40669     print_uint32_t(obj->drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1);
40670 
40671     print_VkFormatFeatureFlags(obj->drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0);
40672 
40673     INDENT(-4);
40674     PRINT_SPACE
40675     if (commaNeeded)
40676         _OUT << "}," << std::endl;
40677     else
40678         _OUT << "}" << std::endl;
40679 }
40680 
print_VkDrmFormatModifierPropertiesListEXT(VkDrmFormatModifierPropertiesListEXT obj,const std::string & s,bool commaNeeded=true)40681 static void print_VkDrmFormatModifierPropertiesListEXT(VkDrmFormatModifierPropertiesListEXT obj, const std::string &s,
40682                                                        bool commaNeeded = true)
40683 {
40684     PRINT_SPACE
40685     _OUT << "{" << std::endl;
40686     INDENT(4);
40687 
40688     print_VkStructureType(obj.sType, "sType", 1);
40689 
40690     if (obj.pNext)
40691     {
40692         dumpPNextChain(obj.pNext);
40693     }
40694     else
40695     {
40696         PRINT_SPACE
40697         _OUT << "\"pNext\":"
40698              << "\"NULL\""
40699              << "," << std::endl;
40700     }
40701 
40702     print_uint32_t(obj.drmFormatModifierCount, "drmFormatModifierCount", 1);
40703 
40704     PRINT_SPACE
40705     _OUT << "\"pDrmFormatModifierProperties\": " << std::endl;
40706     if (obj.pDrmFormatModifierProperties)
40707     {
40708         PRINT_SPACE
40709         _OUT << "[" << std::endl;
40710         for (unsigned int i = 0; i < obj.drmFormatModifierCount; i++)
40711         {
40712             if (i + 1 == obj.drmFormatModifierCount)
40713                 print_VkDrmFormatModifierPropertiesEXT(obj.pDrmFormatModifierProperties[i],
40714                                                        "pDrmFormatModifierProperties", 0);
40715             else
40716                 print_VkDrmFormatModifierPropertiesEXT(obj.pDrmFormatModifierProperties[i],
40717                                                        "pDrmFormatModifierProperties", 1);
40718         }
40719         PRINT_SPACE
40720         _OUT << "]" << std::endl;
40721     }
40722     else
40723     {
40724         PRINT_SPACE _OUT << "\"NULL\""
40725                          << "" << std::endl;
40726     }
40727 
40728     INDENT(-4);
40729     PRINT_SPACE
40730     if (commaNeeded)
40731         _OUT << "}," << std::endl;
40732     else
40733         _OUT << "}" << std::endl;
40734 }
print_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT * obj,const std::string & s,bool commaNeeded=true)40735 static void print_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT *obj,
40736                                                        const std::string &s, bool commaNeeded = true)
40737 {
40738     PRINT_SPACE
40739     _OUT << "{" << std::endl;
40740     INDENT(4);
40741 
40742     print_VkStructureType(obj->sType, "sType", 1);
40743 
40744     if (obj->pNext)
40745     {
40746         dumpPNextChain(obj->pNext);
40747     }
40748     else
40749     {
40750         PRINT_SPACE
40751         _OUT << "\"pNext\":"
40752              << "\"NULL\""
40753              << "," << std::endl;
40754     }
40755 
40756     print_uint32_t(obj->drmFormatModifierCount, "drmFormatModifierCount", 1);
40757 
40758     PRINT_SPACE
40759     _OUT << "\"pDrmFormatModifierProperties\": " << std::endl;
40760     if (obj->pDrmFormatModifierProperties)
40761     {
40762         PRINT_SPACE
40763         _OUT << "[" << std::endl;
40764         for (unsigned int i = 0; i < obj->drmFormatModifierCount; i++)
40765         {
40766             if (i + 1 == obj->drmFormatModifierCount)
40767                 print_VkDrmFormatModifierPropertiesEXT(obj->pDrmFormatModifierProperties[i],
40768                                                        "pDrmFormatModifierProperties", 0);
40769             else
40770                 print_VkDrmFormatModifierPropertiesEXT(obj->pDrmFormatModifierProperties[i],
40771                                                        "pDrmFormatModifierProperties", 1);
40772         }
40773         PRINT_SPACE
40774         _OUT << "]" << std::endl;
40775     }
40776     else
40777     {
40778         PRINT_SPACE _OUT << "\"NULL\""
40779                          << "" << std::endl;
40780     }
40781 
40782     INDENT(-4);
40783     PRINT_SPACE
40784     if (commaNeeded)
40785         _OUT << "}," << std::endl;
40786     else
40787         _OUT << "}" << std::endl;
40788 }
40789 
print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(VkPhysicalDeviceImageDrmFormatModifierInfoEXT obj,const std::string & s,bool commaNeeded=true)40790 static void print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(VkPhysicalDeviceImageDrmFormatModifierInfoEXT obj,
40791                                                                 const std::string &s, bool commaNeeded = true)
40792 {
40793     PRINT_SPACE
40794     _OUT << "{" << std::endl;
40795     INDENT(4);
40796 
40797     print_VkStructureType(obj.sType, "sType", 1);
40798 
40799     if (obj.pNext)
40800     {
40801         dumpPNextChain(obj.pNext);
40802     }
40803     else
40804     {
40805         PRINT_SPACE
40806         _OUT << "\"pNext\":"
40807              << "\"NULL\""
40808              << "," << std::endl;
40809     }
40810 
40811     print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 1);
40812 
40813     print_VkSharingMode(obj.sharingMode, "sharingMode", 1);
40814 
40815     print_uint32_t(obj.queueFamilyIndexCount, "queueFamilyIndexCount", 1);
40816 
40817     PRINT_SPACE
40818     _OUT << "\"pQueueFamilyIndices\":" << std::endl;
40819     PRINT_SPACE
40820     if (obj.pQueueFamilyIndices)
40821     {
40822         _OUT << "[" << std::endl;
40823         for (unsigned int i = 0; i < obj.queueFamilyIndexCount; i++)
40824         {
40825             bool isCommaNeeded = (i + 1) != obj.queueFamilyIndexCount;
40826             print_uint32_t(obj.pQueueFamilyIndices[i], "", isCommaNeeded);
40827         }
40828         PRINT_SPACE
40829         _OUT << "]"
40830              << "" << std::endl;
40831     }
40832     else
40833     {
40834         _OUT << "\"NULL\""
40835              << "" << std::endl;
40836     }
40837 
40838     INDENT(-4);
40839     PRINT_SPACE
40840     if (commaNeeded)
40841         _OUT << "}," << std::endl;
40842     else
40843         _OUT << "}" << std::endl;
40844 }
print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * obj,const std::string & s,bool commaNeeded=true)40845 static void print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
40846     const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *obj, const std::string &s, bool commaNeeded = true)
40847 {
40848     PRINT_SPACE
40849     _OUT << "{" << std::endl;
40850     INDENT(4);
40851 
40852     print_VkStructureType(obj->sType, "sType", 1);
40853 
40854     if (obj->pNext)
40855     {
40856         dumpPNextChain(obj->pNext);
40857     }
40858     else
40859     {
40860         PRINT_SPACE
40861         _OUT << "\"pNext\":"
40862              << "\"NULL\""
40863              << "," << std::endl;
40864     }
40865 
40866     print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 1);
40867 
40868     print_VkSharingMode(obj->sharingMode, "sharingMode", 1);
40869 
40870     print_uint32_t(obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1);
40871 
40872     PRINT_SPACE
40873     _OUT << "\"pQueueFamilyIndices\":" << std::endl;
40874     PRINT_SPACE
40875     if (obj->pQueueFamilyIndices)
40876     {
40877         _OUT << "[" << std::endl;
40878         for (unsigned int i = 0; i < obj->queueFamilyIndexCount; i++)
40879         {
40880             bool isCommaNeeded = (i + 1) != obj->queueFamilyIndexCount;
40881             print_uint32_t(obj->pQueueFamilyIndices[i], "", isCommaNeeded);
40882         }
40883         PRINT_SPACE
40884         _OUT << "]"
40885              << "" << std::endl;
40886     }
40887     else
40888     {
40889         _OUT << "\"NULL\""
40890              << "" << std::endl;
40891     }
40892 
40893     INDENT(-4);
40894     PRINT_SPACE
40895     if (commaNeeded)
40896         _OUT << "}," << std::endl;
40897     else
40898         _OUT << "}" << std::endl;
40899 }
40900 
print_VkImageDrmFormatModifierListCreateInfoEXT(VkImageDrmFormatModifierListCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)40901 static void print_VkImageDrmFormatModifierListCreateInfoEXT(VkImageDrmFormatModifierListCreateInfoEXT obj,
40902                                                             const std::string &s, bool commaNeeded = true)
40903 {
40904     PRINT_SPACE
40905     _OUT << "{" << std::endl;
40906     INDENT(4);
40907 
40908     print_VkStructureType(obj.sType, "sType", 1);
40909 
40910     if (obj.pNext)
40911     {
40912         dumpPNextChain(obj.pNext);
40913     }
40914     else
40915     {
40916         PRINT_SPACE
40917         _OUT << "\"pNext\":"
40918              << "\"NULL\""
40919              << "," << std::endl;
40920     }
40921 
40922     print_uint32_t(obj.drmFormatModifierCount, "drmFormatModifierCount", 1);
40923 
40924     PRINT_SPACE
40925     _OUT << "\"pDrmFormatModifiers\":" << std::endl;
40926     PRINT_SPACE
40927     if (obj.pDrmFormatModifiers)
40928     {
40929         _OUT << "[" << std::endl;
40930         for (unsigned int i = 0; i < obj.drmFormatModifierCount; i++)
40931         {
40932             bool isCommaNeeded = (i + 1) != obj.drmFormatModifierCount;
40933             print_uint64_t(obj.pDrmFormatModifiers[i], "", isCommaNeeded);
40934         }
40935         PRINT_SPACE
40936         _OUT << "]"
40937              << "" << std::endl;
40938     }
40939     else
40940     {
40941         _OUT << "\"NULL\""
40942              << "" << std::endl;
40943     }
40944 
40945     INDENT(-4);
40946     PRINT_SPACE
40947     if (commaNeeded)
40948         _OUT << "}," << std::endl;
40949     else
40950         _OUT << "}" << std::endl;
40951 }
print_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)40952 static void print_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT *obj,
40953                                                             const std::string &s, bool commaNeeded = true)
40954 {
40955     PRINT_SPACE
40956     _OUT << "{" << std::endl;
40957     INDENT(4);
40958 
40959     print_VkStructureType(obj->sType, "sType", 1);
40960 
40961     if (obj->pNext)
40962     {
40963         dumpPNextChain(obj->pNext);
40964     }
40965     else
40966     {
40967         PRINT_SPACE
40968         _OUT << "\"pNext\":"
40969              << "\"NULL\""
40970              << "," << std::endl;
40971     }
40972 
40973     print_uint32_t(obj->drmFormatModifierCount, "drmFormatModifierCount", 1);
40974 
40975     PRINT_SPACE
40976     _OUT << "\"pDrmFormatModifiers\":" << std::endl;
40977     PRINT_SPACE
40978     if (obj->pDrmFormatModifiers)
40979     {
40980         _OUT << "[" << std::endl;
40981         for (unsigned int i = 0; i < obj->drmFormatModifierCount; i++)
40982         {
40983             bool isCommaNeeded = (i + 1) != obj->drmFormatModifierCount;
40984             print_uint64_t(obj->pDrmFormatModifiers[i], "", isCommaNeeded);
40985         }
40986         PRINT_SPACE
40987         _OUT << "]"
40988              << "" << std::endl;
40989     }
40990     else
40991     {
40992         _OUT << "\"NULL\""
40993              << "" << std::endl;
40994     }
40995 
40996     INDENT(-4);
40997     PRINT_SPACE
40998     if (commaNeeded)
40999         _OUT << "}," << std::endl;
41000     else
41001         _OUT << "}" << std::endl;
41002 }
41003 
print_VkImageDrmFormatModifierExplicitCreateInfoEXT(VkImageDrmFormatModifierExplicitCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)41004 static void print_VkImageDrmFormatModifierExplicitCreateInfoEXT(VkImageDrmFormatModifierExplicitCreateInfoEXT obj,
41005                                                                 const std::string &s, bool commaNeeded = true)
41006 {
41007     PRINT_SPACE
41008     _OUT << "{" << std::endl;
41009     INDENT(4);
41010 
41011     print_VkStructureType(obj.sType, "sType", 1);
41012 
41013     if (obj.pNext)
41014     {
41015         dumpPNextChain(obj.pNext);
41016     }
41017     else
41018     {
41019         PRINT_SPACE
41020         _OUT << "\"pNext\":"
41021              << "\"NULL\""
41022              << "," << std::endl;
41023     }
41024 
41025     print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 1);
41026 
41027     print_uint32_t(obj.drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1);
41028 
41029     PRINT_SPACE
41030     _OUT << "\"pPlaneLayouts\": " << std::endl;
41031     if (obj.pPlaneLayouts)
41032     {
41033         PRINT_SPACE
41034         _OUT << "[" << std::endl;
41035         for (unsigned int i = 0; i < obj.drmFormatModifierPlaneCount; i++)
41036         {
41037             if (i + 1 == obj.drmFormatModifierPlaneCount)
41038                 print_VkSubresourceLayout(obj.pPlaneLayouts[i], "pPlaneLayouts", 0);
41039             else
41040                 print_VkSubresourceLayout(obj.pPlaneLayouts[i], "pPlaneLayouts", 1);
41041         }
41042         PRINT_SPACE
41043         _OUT << "]" << std::endl;
41044     }
41045     else
41046     {
41047         PRINT_SPACE _OUT << "\"NULL\""
41048                          << "" << std::endl;
41049     }
41050 
41051     INDENT(-4);
41052     PRINT_SPACE
41053     if (commaNeeded)
41054         _OUT << "}," << std::endl;
41055     else
41056         _OUT << "}" << std::endl;
41057 }
print_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)41058 static void print_VkImageDrmFormatModifierExplicitCreateInfoEXT(
41059     const VkImageDrmFormatModifierExplicitCreateInfoEXT *obj, const std::string &s, bool commaNeeded = true)
41060 {
41061     PRINT_SPACE
41062     _OUT << "{" << std::endl;
41063     INDENT(4);
41064 
41065     print_VkStructureType(obj->sType, "sType", 1);
41066 
41067     if (obj->pNext)
41068     {
41069         dumpPNextChain(obj->pNext);
41070     }
41071     else
41072     {
41073         PRINT_SPACE
41074         _OUT << "\"pNext\":"
41075              << "\"NULL\""
41076              << "," << std::endl;
41077     }
41078 
41079     print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 1);
41080 
41081     print_uint32_t(obj->drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1);
41082 
41083     PRINT_SPACE
41084     _OUT << "\"pPlaneLayouts\": " << std::endl;
41085     if (obj->pPlaneLayouts)
41086     {
41087         PRINT_SPACE
41088         _OUT << "[" << std::endl;
41089         for (unsigned int i = 0; i < obj->drmFormatModifierPlaneCount; i++)
41090         {
41091             if (i + 1 == obj->drmFormatModifierPlaneCount)
41092                 print_VkSubresourceLayout(obj->pPlaneLayouts[i], "pPlaneLayouts", 0);
41093             else
41094                 print_VkSubresourceLayout(obj->pPlaneLayouts[i], "pPlaneLayouts", 1);
41095         }
41096         PRINT_SPACE
41097         _OUT << "]" << std::endl;
41098     }
41099     else
41100     {
41101         PRINT_SPACE _OUT << "\"NULL\""
41102                          << "" << std::endl;
41103     }
41104 
41105     INDENT(-4);
41106     PRINT_SPACE
41107     if (commaNeeded)
41108         _OUT << "}," << std::endl;
41109     else
41110         _OUT << "}" << std::endl;
41111 }
41112 
print_VkImageDrmFormatModifierPropertiesEXT(VkImageDrmFormatModifierPropertiesEXT obj,const std::string & s,bool commaNeeded=true)41113 static void print_VkImageDrmFormatModifierPropertiesEXT(VkImageDrmFormatModifierPropertiesEXT obj, const std::string &s,
41114                                                         bool commaNeeded = true)
41115 {
41116     PRINT_SPACE
41117     _OUT << "{" << std::endl;
41118     INDENT(4);
41119 
41120     print_VkStructureType(obj.sType, "sType", 1);
41121 
41122     if (obj.pNext)
41123     {
41124         dumpPNextChain(obj.pNext);
41125     }
41126     else
41127     {
41128         PRINT_SPACE
41129         _OUT << "\"pNext\":"
41130              << "\"NULL\""
41131              << "," << std::endl;
41132     }
41133 
41134     print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 0);
41135 
41136     INDENT(-4);
41137     PRINT_SPACE
41138     if (commaNeeded)
41139         _OUT << "}," << std::endl;
41140     else
41141         _OUT << "}" << std::endl;
41142 }
print_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)41143 static void print_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT *obj,
41144                                                         const std::string &s, bool commaNeeded = true)
41145 {
41146     PRINT_SPACE
41147     _OUT << "{" << std::endl;
41148     INDENT(4);
41149 
41150     print_VkStructureType(obj->sType, "sType", 1);
41151 
41152     if (obj->pNext)
41153     {
41154         dumpPNextChain(obj->pNext);
41155     }
41156     else
41157     {
41158         PRINT_SPACE
41159         _OUT << "\"pNext\":"
41160              << "\"NULL\""
41161              << "," << std::endl;
41162     }
41163 
41164     print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 0);
41165 
41166     INDENT(-4);
41167     PRINT_SPACE
41168     if (commaNeeded)
41169         _OUT << "}," << std::endl;
41170     else
41171         _OUT << "}" << std::endl;
41172 }
41173 
print_VkDrmFormatModifierProperties2EXT(VkDrmFormatModifierProperties2EXT obj,const std::string & s,bool commaNeeded=true)41174 static void print_VkDrmFormatModifierProperties2EXT(VkDrmFormatModifierProperties2EXT obj, const std::string &s,
41175                                                     bool commaNeeded = true)
41176 {
41177     PRINT_SPACE
41178     _OUT << "{" << std::endl;
41179     INDENT(4);
41180 
41181     print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 1);
41182 
41183     print_uint32_t(obj.drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1);
41184 
41185     print_VkFormatFeatureFlags2KHR(obj.drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0);
41186 
41187     INDENT(-4);
41188     PRINT_SPACE
41189     if (commaNeeded)
41190         _OUT << "}," << std::endl;
41191     else
41192         _OUT << "}" << std::endl;
41193 }
print_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT * obj,const std::string & s,bool commaNeeded=true)41194 static void print_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT *obj, const std::string &s,
41195                                                     bool commaNeeded = true)
41196 {
41197     PRINT_SPACE
41198     _OUT << "{" << std::endl;
41199     INDENT(4);
41200 
41201     print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 1);
41202 
41203     print_uint32_t(obj->drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1);
41204 
41205     print_VkFormatFeatureFlags2KHR(obj->drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0);
41206 
41207     INDENT(-4);
41208     PRINT_SPACE
41209     if (commaNeeded)
41210         _OUT << "}," << std::endl;
41211     else
41212         _OUT << "}" << std::endl;
41213 }
41214 
print_VkDrmFormatModifierPropertiesList2EXT(VkDrmFormatModifierPropertiesList2EXT obj,const std::string & s,bool commaNeeded=true)41215 static void print_VkDrmFormatModifierPropertiesList2EXT(VkDrmFormatModifierPropertiesList2EXT obj, const std::string &s,
41216                                                         bool commaNeeded = true)
41217 {
41218     PRINT_SPACE
41219     _OUT << "{" << std::endl;
41220     INDENT(4);
41221 
41222     print_VkStructureType(obj.sType, "sType", 1);
41223 
41224     if (obj.pNext)
41225     {
41226         dumpPNextChain(obj.pNext);
41227     }
41228     else
41229     {
41230         PRINT_SPACE
41231         _OUT << "\"pNext\":"
41232              << "\"NULL\""
41233              << "," << std::endl;
41234     }
41235 
41236     print_uint32_t(obj.drmFormatModifierCount, "drmFormatModifierCount", 1);
41237 
41238     PRINT_SPACE
41239     _OUT << "\"pDrmFormatModifierProperties\": " << std::endl;
41240     if (obj.pDrmFormatModifierProperties)
41241     {
41242         PRINT_SPACE
41243         _OUT << "[" << std::endl;
41244         for (unsigned int i = 0; i < obj.drmFormatModifierCount; i++)
41245         {
41246             if (i + 1 == obj.drmFormatModifierCount)
41247                 print_VkDrmFormatModifierProperties2EXT(obj.pDrmFormatModifierProperties[i],
41248                                                         "pDrmFormatModifierProperties", 0);
41249             else
41250                 print_VkDrmFormatModifierProperties2EXT(obj.pDrmFormatModifierProperties[i],
41251                                                         "pDrmFormatModifierProperties", 1);
41252         }
41253         PRINT_SPACE
41254         _OUT << "]" << std::endl;
41255     }
41256     else
41257     {
41258         PRINT_SPACE _OUT << "\"NULL\""
41259                          << "" << std::endl;
41260     }
41261 
41262     INDENT(-4);
41263     PRINT_SPACE
41264     if (commaNeeded)
41265         _OUT << "}," << std::endl;
41266     else
41267         _OUT << "}" << std::endl;
41268 }
print_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT * obj,const std::string & s,bool commaNeeded=true)41269 static void print_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT *obj,
41270                                                         const std::string &s, bool commaNeeded = true)
41271 {
41272     PRINT_SPACE
41273     _OUT << "{" << std::endl;
41274     INDENT(4);
41275 
41276     print_VkStructureType(obj->sType, "sType", 1);
41277 
41278     if (obj->pNext)
41279     {
41280         dumpPNextChain(obj->pNext);
41281     }
41282     else
41283     {
41284         PRINT_SPACE
41285         _OUT << "\"pNext\":"
41286              << "\"NULL\""
41287              << "," << std::endl;
41288     }
41289 
41290     print_uint32_t(obj->drmFormatModifierCount, "drmFormatModifierCount", 1);
41291 
41292     PRINT_SPACE
41293     _OUT << "\"pDrmFormatModifierProperties\": " << std::endl;
41294     if (obj->pDrmFormatModifierProperties)
41295     {
41296         PRINT_SPACE
41297         _OUT << "[" << std::endl;
41298         for (unsigned int i = 0; i < obj->drmFormatModifierCount; i++)
41299         {
41300             if (i + 1 == obj->drmFormatModifierCount)
41301                 print_VkDrmFormatModifierProperties2EXT(obj->pDrmFormatModifierProperties[i],
41302                                                         "pDrmFormatModifierProperties", 0);
41303             else
41304                 print_VkDrmFormatModifierProperties2EXT(obj->pDrmFormatModifierProperties[i],
41305                                                         "pDrmFormatModifierProperties", 1);
41306         }
41307         PRINT_SPACE
41308         _OUT << "]" << std::endl;
41309     }
41310     else
41311     {
41312         PRINT_SPACE _OUT << "\"NULL\""
41313                          << "" << std::endl;
41314     }
41315 
41316     INDENT(-4);
41317     PRINT_SPACE
41318     if (commaNeeded)
41319         _OUT << "}," << std::endl;
41320     else
41321         _OUT << "}" << std::endl;
41322 }
41323 
print_VkPhysicalDeviceImageViewImageFormatInfoEXT(VkPhysicalDeviceImageViewImageFormatInfoEXT obj,const std::string & s,bool commaNeeded=true)41324 static void print_VkPhysicalDeviceImageViewImageFormatInfoEXT(VkPhysicalDeviceImageViewImageFormatInfoEXT obj,
41325                                                               const std::string &s, bool commaNeeded = true)
41326 {
41327     PRINT_SPACE
41328     _OUT << "{" << std::endl;
41329     INDENT(4);
41330 
41331     print_VkStructureType(obj.sType, "sType", 1);
41332 
41333     if (obj.pNext)
41334     {
41335         dumpPNextChain(obj.pNext);
41336     }
41337     else
41338     {
41339         PRINT_SPACE
41340         _OUT << "\"pNext\":"
41341              << "\"NULL\""
41342              << "," << std::endl;
41343     }
41344 
41345     print_VkImageViewType(obj.imageViewType, "imageViewType", 0);
41346 
41347     INDENT(-4);
41348     PRINT_SPACE
41349     if (commaNeeded)
41350         _OUT << "}," << std::endl;
41351     else
41352         _OUT << "}" << std::endl;
41353 }
print_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT * obj,const std::string & s,bool commaNeeded=true)41354 static void print_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT *obj,
41355                                                               const std::string &s, bool commaNeeded = true)
41356 {
41357     PRINT_SPACE
41358     _OUT << "{" << std::endl;
41359     INDENT(4);
41360 
41361     print_VkStructureType(obj->sType, "sType", 1);
41362 
41363     if (obj->pNext)
41364     {
41365         dumpPNextChain(obj->pNext);
41366     }
41367     else
41368     {
41369         PRINT_SPACE
41370         _OUT << "\"pNext\":"
41371              << "\"NULL\""
41372              << "," << std::endl;
41373     }
41374 
41375     print_VkImageViewType(obj->imageViewType, "imageViewType", 0);
41376 
41377     INDENT(-4);
41378     PRINT_SPACE
41379     if (commaNeeded)
41380         _OUT << "}," << std::endl;
41381     else
41382         _OUT << "}" << std::endl;
41383 }
41384 
print_VkFilterCubicImageViewImageFormatPropertiesEXT(VkFilterCubicImageViewImageFormatPropertiesEXT obj,const std::string & s,bool commaNeeded=true)41385 static void print_VkFilterCubicImageViewImageFormatPropertiesEXT(VkFilterCubicImageViewImageFormatPropertiesEXT obj,
41386                                                                  const std::string &s, bool commaNeeded = true)
41387 {
41388     PRINT_SPACE
41389     _OUT << "{" << std::endl;
41390     INDENT(4);
41391 
41392     print_VkStructureType(obj.sType, "sType", 1);
41393 
41394     if (obj.pNext)
41395     {
41396         dumpPNextChain(obj.pNext);
41397     }
41398     else
41399     {
41400         PRINT_SPACE
41401         _OUT << "\"pNext\":"
41402              << "\"NULL\""
41403              << "," << std::endl;
41404     }
41405 
41406     print_VkBool32(obj.filterCubic, "filterCubic", 1);
41407 
41408     print_VkBool32(obj.filterCubicMinmax, "filterCubicMinmax", 0);
41409 
41410     INDENT(-4);
41411     PRINT_SPACE
41412     if (commaNeeded)
41413         _OUT << "}," << std::endl;
41414     else
41415         _OUT << "}" << std::endl;
41416 }
print_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)41417 static void print_VkFilterCubicImageViewImageFormatPropertiesEXT(
41418     const VkFilterCubicImageViewImageFormatPropertiesEXT *obj, const std::string &s, bool commaNeeded = true)
41419 {
41420     PRINT_SPACE
41421     _OUT << "{" << std::endl;
41422     INDENT(4);
41423 
41424     print_VkStructureType(obj->sType, "sType", 1);
41425 
41426     if (obj->pNext)
41427     {
41428         dumpPNextChain(obj->pNext);
41429     }
41430     else
41431     {
41432         PRINT_SPACE
41433         _OUT << "\"pNext\":"
41434              << "\"NULL\""
41435              << "," << std::endl;
41436     }
41437 
41438     print_VkBool32(obj->filterCubic, "filterCubic", 1);
41439 
41440     print_VkBool32(obj->filterCubicMinmax, "filterCubicMinmax", 0);
41441 
41442     INDENT(-4);
41443     PRINT_SPACE
41444     if (commaNeeded)
41445         _OUT << "}," << std::endl;
41446     else
41447         _OUT << "}" << std::endl;
41448 }
41449 
41450 static std::map<uint64_t, std::string> VkQueueGlobalPriorityEXT_map = {
41451     std::make_pair(128, "VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT"),
41452     std::make_pair(256, "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT"),
41453     std::make_pair(512, "VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT"),
41454     std::make_pair(1024, "VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT"),
41455 };
print_VkQueueGlobalPriorityEXT(VkQueueGlobalPriorityEXT obj,const std::string & str,bool commaNeeded=true)41456 static void print_VkQueueGlobalPriorityEXT(VkQueueGlobalPriorityEXT obj, const std::string &str,
41457                                            bool commaNeeded = true)
41458 {
41459     PRINT_SPACE
41460     if (str != "")
41461         _OUT << "\"" << str << "\""
41462              << " : ";
41463     if (commaNeeded)
41464         _OUT << "\"" << VkQueueGlobalPriorityEXT_map[obj] << "\"," << std::endl;
41465     else
41466         _OUT << "\"" << VkQueueGlobalPriorityEXT_map[obj] << "\"" << std::endl;
41467 }
print_VkQueueGlobalPriorityEXT(const VkQueueGlobalPriorityEXT * obj,const std::string & str,bool commaNeeded=true)41468 static void print_VkQueueGlobalPriorityEXT(const VkQueueGlobalPriorityEXT *obj, const std::string &str,
41469                                            bool commaNeeded = true)
41470 {
41471     PRINT_SPACE
41472     if (str != "")
41473         _OUT << "\"" << str << "\""
41474              << " : ";
41475     if (commaNeeded)
41476         _OUT << "\"" << VkQueueGlobalPriorityEXT_map[*obj] << "\"," << std::endl;
41477     else
41478         _OUT << "\"" << VkQueueGlobalPriorityEXT_map[*obj] << "\"" << std::endl;
41479 }
41480 
print_VkDeviceQueueGlobalPriorityCreateInfoEXT(VkDeviceQueueGlobalPriorityCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)41481 static void print_VkDeviceQueueGlobalPriorityCreateInfoEXT(VkDeviceQueueGlobalPriorityCreateInfoEXT obj,
41482                                                            const std::string &s, bool commaNeeded = true)
41483 {
41484     PRINT_SPACE
41485     _OUT << "{" << std::endl;
41486     INDENT(4);
41487 
41488     print_VkStructureType(obj.sType, "sType", 1);
41489 
41490     if (obj.pNext)
41491     {
41492         dumpPNextChain(obj.pNext);
41493     }
41494     else
41495     {
41496         PRINT_SPACE
41497         _OUT << "\"pNext\":"
41498              << "\"NULL\""
41499              << "," << std::endl;
41500     }
41501 
41502     print_VkQueueGlobalPriorityEXT(obj.globalPriority, "globalPriority", 0);
41503 
41504     INDENT(-4);
41505     PRINT_SPACE
41506     if (commaNeeded)
41507         _OUT << "}," << std::endl;
41508     else
41509         _OUT << "}" << std::endl;
41510 }
print_VkDeviceQueueGlobalPriorityCreateInfoEXT(const VkDeviceQueueGlobalPriorityCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)41511 static void print_VkDeviceQueueGlobalPriorityCreateInfoEXT(const VkDeviceQueueGlobalPriorityCreateInfoEXT *obj,
41512                                                            const std::string &s, bool commaNeeded = true)
41513 {
41514     PRINT_SPACE
41515     _OUT << "{" << std::endl;
41516     INDENT(4);
41517 
41518     print_VkStructureType(obj->sType, "sType", 1);
41519 
41520     if (obj->pNext)
41521     {
41522         dumpPNextChain(obj->pNext);
41523     }
41524     else
41525     {
41526         PRINT_SPACE
41527         _OUT << "\"pNext\":"
41528              << "\"NULL\""
41529              << "," << std::endl;
41530     }
41531 
41532     print_VkQueueGlobalPriorityEXT(obj->globalPriority, "globalPriority", 0);
41533 
41534     INDENT(-4);
41535     PRINT_SPACE
41536     if (commaNeeded)
41537         _OUT << "}," << std::endl;
41538     else
41539         _OUT << "}" << std::endl;
41540 }
41541 
print_VkImportMemoryHostPointerInfoEXT(VkImportMemoryHostPointerInfoEXT obj,const std::string & s,bool commaNeeded=true)41542 static void print_VkImportMemoryHostPointerInfoEXT(VkImportMemoryHostPointerInfoEXT obj, const std::string &s,
41543                                                    bool commaNeeded = true)
41544 {
41545     PRINT_SPACE
41546     _OUT << "{" << std::endl;
41547     INDENT(4);
41548 
41549     print_VkStructureType(obj.sType, "sType", 1);
41550 
41551     if (obj.pNext)
41552     {
41553         dumpPNextChain(obj.pNext);
41554     }
41555     else
41556     {
41557         PRINT_SPACE
41558         _OUT << "\"pNext\":"
41559              << "\"NULL\""
41560              << "," << std::endl;
41561     }
41562 
41563     print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 1);
41564 
41565     /** Note: Ignoring void* data. **/
41566 
41567     INDENT(-4);
41568     PRINT_SPACE
41569     if (commaNeeded)
41570         _OUT << "}," << std::endl;
41571     else
41572         _OUT << "}" << std::endl;
41573 }
print_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT * obj,const std::string & s,bool commaNeeded=true)41574 static void print_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT *obj, const std::string &s,
41575                                                    bool commaNeeded = true)
41576 {
41577     PRINT_SPACE
41578     _OUT << "{" << std::endl;
41579     INDENT(4);
41580 
41581     print_VkStructureType(obj->sType, "sType", 1);
41582 
41583     if (obj->pNext)
41584     {
41585         dumpPNextChain(obj->pNext);
41586     }
41587     else
41588     {
41589         PRINT_SPACE
41590         _OUT << "\"pNext\":"
41591              << "\"NULL\""
41592              << "," << std::endl;
41593     }
41594 
41595     print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 1);
41596 
41597     /** Note: Ignoring void* data. **/
41598 
41599     INDENT(-4);
41600     PRINT_SPACE
41601     if (commaNeeded)
41602         _OUT << "}," << std::endl;
41603     else
41604         _OUT << "}" << std::endl;
41605 }
41606 
print_VkMemoryHostPointerPropertiesEXT(VkMemoryHostPointerPropertiesEXT obj,const std::string & s,bool commaNeeded=true)41607 static void print_VkMemoryHostPointerPropertiesEXT(VkMemoryHostPointerPropertiesEXT obj, const std::string &s,
41608                                                    bool commaNeeded = true)
41609 {
41610     PRINT_SPACE
41611     _OUT << "{" << std::endl;
41612     INDENT(4);
41613 
41614     print_VkStructureType(obj.sType, "sType", 1);
41615 
41616     if (obj.pNext)
41617     {
41618         dumpPNextChain(obj.pNext);
41619     }
41620     else
41621     {
41622         PRINT_SPACE
41623         _OUT << "\"pNext\":"
41624              << "\"NULL\""
41625              << "," << std::endl;
41626     }
41627 
41628     print_uint32_t(obj.memoryTypeBits, "memoryTypeBits", 0);
41629 
41630     INDENT(-4);
41631     PRINT_SPACE
41632     if (commaNeeded)
41633         _OUT << "}," << std::endl;
41634     else
41635         _OUT << "}" << std::endl;
41636 }
print_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)41637 static void print_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT *obj, const std::string &s,
41638                                                    bool commaNeeded = true)
41639 {
41640     PRINT_SPACE
41641     _OUT << "{" << std::endl;
41642     INDENT(4);
41643 
41644     print_VkStructureType(obj->sType, "sType", 1);
41645 
41646     if (obj->pNext)
41647     {
41648         dumpPNextChain(obj->pNext);
41649     }
41650     else
41651     {
41652         PRINT_SPACE
41653         _OUT << "\"pNext\":"
41654              << "\"NULL\""
41655              << "," << std::endl;
41656     }
41657 
41658     print_uint32_t(obj->memoryTypeBits, "memoryTypeBits", 0);
41659 
41660     INDENT(-4);
41661     PRINT_SPACE
41662     if (commaNeeded)
41663         _OUT << "}," << std::endl;
41664     else
41665         _OUT << "}" << std::endl;
41666 }
41667 
print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(VkPhysicalDeviceExternalMemoryHostPropertiesEXT obj,const std::string & s,bool commaNeeded=true)41668 static void print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(VkPhysicalDeviceExternalMemoryHostPropertiesEXT obj,
41669                                                                   const std::string &s, bool commaNeeded = true)
41670 {
41671     PRINT_SPACE
41672     _OUT << "{" << std::endl;
41673     INDENT(4);
41674 
41675     print_VkStructureType(obj.sType, "sType", 1);
41676 
41677     if (obj.pNext)
41678     {
41679         dumpPNextChain(obj.pNext);
41680     }
41681     else
41682     {
41683         PRINT_SPACE
41684         _OUT << "\"pNext\":"
41685              << "\"NULL\""
41686              << "," << std::endl;
41687     }
41688 
41689     print_VkDeviceSize(obj.minImportedHostPointerAlignment, "minImportedHostPointerAlignment", 0);
41690 
41691     INDENT(-4);
41692     PRINT_SPACE
41693     if (commaNeeded)
41694         _OUT << "}," << std::endl;
41695     else
41696         _OUT << "}" << std::endl;
41697 }
print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)41698 static void print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
41699     const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *obj, const std::string &s, bool commaNeeded = true)
41700 {
41701     PRINT_SPACE
41702     _OUT << "{" << std::endl;
41703     INDENT(4);
41704 
41705     print_VkStructureType(obj->sType, "sType", 1);
41706 
41707     if (obj->pNext)
41708     {
41709         dumpPNextChain(obj->pNext);
41710     }
41711     else
41712     {
41713         PRINT_SPACE
41714         _OUT << "\"pNext\":"
41715              << "\"NULL\""
41716              << "," << std::endl;
41717     }
41718 
41719     print_VkDeviceSize(obj->minImportedHostPointerAlignment, "minImportedHostPointerAlignment", 0);
41720 
41721     INDENT(-4);
41722     PRINT_SPACE
41723     if (commaNeeded)
41724         _OUT << "}," << std::endl;
41725     else
41726         _OUT << "}" << std::endl;
41727 }
41728 
41729 static std::map<uint64_t, std::string> VkTimeDomainEXT_map = {
41730     std::make_pair(0, "VK_TIME_DOMAIN_DEVICE_EXT"),
41731     std::make_pair(1, "VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT"),
41732     std::make_pair(2, "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT"),
41733     std::make_pair(3, "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT"),
41734 };
print_VkTimeDomainEXT(VkTimeDomainEXT obj,const std::string & str,bool commaNeeded=true)41735 static void print_VkTimeDomainEXT(VkTimeDomainEXT obj, const std::string &str, bool commaNeeded = true)
41736 {
41737     PRINT_SPACE
41738     if (str != "")
41739         _OUT << "\"" << str << "\""
41740              << " : ";
41741     if (commaNeeded)
41742         _OUT << "\"" << VkTimeDomainEXT_map[obj] << "\"," << std::endl;
41743     else
41744         _OUT << "\"" << VkTimeDomainEXT_map[obj] << "\"" << std::endl;
41745 }
print_VkTimeDomainEXT(const VkTimeDomainEXT * obj,const std::string & str,bool commaNeeded=true)41746 static void print_VkTimeDomainEXT(const VkTimeDomainEXT *obj, const std::string &str, bool commaNeeded = true)
41747 {
41748     PRINT_SPACE
41749     if (str != "")
41750         _OUT << "\"" << str << "\""
41751              << " : ";
41752     if (commaNeeded)
41753         _OUT << "\"" << VkTimeDomainEXT_map[*obj] << "\"," << std::endl;
41754     else
41755         _OUT << "\"" << VkTimeDomainEXT_map[*obj] << "\"" << std::endl;
41756 }
41757 
print_VkCalibratedTimestampInfoEXT(VkCalibratedTimestampInfoEXT obj,const std::string & s,bool commaNeeded=true)41758 static void print_VkCalibratedTimestampInfoEXT(VkCalibratedTimestampInfoEXT obj, const std::string &s,
41759                                                bool commaNeeded = true)
41760 {
41761     PRINT_SPACE
41762     _OUT << "{" << std::endl;
41763     INDENT(4);
41764 
41765     print_VkStructureType(obj.sType, "sType", 1);
41766 
41767     if (obj.pNext)
41768     {
41769         dumpPNextChain(obj.pNext);
41770     }
41771     else
41772     {
41773         PRINT_SPACE
41774         _OUT << "\"pNext\":"
41775              << "\"NULL\""
41776              << "," << std::endl;
41777     }
41778 
41779     print_VkTimeDomainEXT(obj.timeDomain, "timeDomain", 0);
41780 
41781     INDENT(-4);
41782     PRINT_SPACE
41783     if (commaNeeded)
41784         _OUT << "}," << std::endl;
41785     else
41786         _OUT << "}" << std::endl;
41787 }
print_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT * obj,const std::string & s,bool commaNeeded=true)41788 static void print_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT *obj, const std::string &s,
41789                                                bool commaNeeded = true)
41790 {
41791     PRINT_SPACE
41792     _OUT << "{" << std::endl;
41793     INDENT(4);
41794 
41795     print_VkStructureType(obj->sType, "sType", 1);
41796 
41797     if (obj->pNext)
41798     {
41799         dumpPNextChain(obj->pNext);
41800     }
41801     else
41802     {
41803         PRINT_SPACE
41804         _OUT << "\"pNext\":"
41805              << "\"NULL\""
41806              << "," << std::endl;
41807     }
41808 
41809     print_VkTimeDomainEXT(obj->timeDomain, "timeDomain", 0);
41810 
41811     INDENT(-4);
41812     PRINT_SPACE
41813     if (commaNeeded)
41814         _OUT << "}," << std::endl;
41815     else
41816         _OUT << "}" << std::endl;
41817 }
41818 
print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT obj,const std::string & s,bool commaNeeded=true)41819 static void print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
41820     VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT obj, const std::string &s, bool commaNeeded = true)
41821 {
41822     PRINT_SPACE
41823     _OUT << "{" << std::endl;
41824     INDENT(4);
41825 
41826     print_VkStructureType(obj.sType, "sType", 1);
41827 
41828     if (obj.pNext)
41829     {
41830         dumpPNextChain(obj.pNext);
41831     }
41832     else
41833     {
41834         PRINT_SPACE
41835         _OUT << "\"pNext\":"
41836              << "\"NULL\""
41837              << "," << std::endl;
41838     }
41839 
41840     print_uint32_t(obj.maxVertexAttribDivisor, "maxVertexAttribDivisor", 0);
41841 
41842     INDENT(-4);
41843     PRINT_SPACE
41844     if (commaNeeded)
41845         _OUT << "}," << std::endl;
41846     else
41847         _OUT << "}" << std::endl;
41848 }
print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)41849 static void print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
41850     const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *obj, const std::string &s, bool commaNeeded = true)
41851 {
41852     PRINT_SPACE
41853     _OUT << "{" << std::endl;
41854     INDENT(4);
41855 
41856     print_VkStructureType(obj->sType, "sType", 1);
41857 
41858     if (obj->pNext)
41859     {
41860         dumpPNextChain(obj->pNext);
41861     }
41862     else
41863     {
41864         PRINT_SPACE
41865         _OUT << "\"pNext\":"
41866              << "\"NULL\""
41867              << "," << std::endl;
41868     }
41869 
41870     print_uint32_t(obj->maxVertexAttribDivisor, "maxVertexAttribDivisor", 0);
41871 
41872     INDENT(-4);
41873     PRINT_SPACE
41874     if (commaNeeded)
41875         _OUT << "}," << std::endl;
41876     else
41877         _OUT << "}" << std::endl;
41878 }
41879 
print_VkVertexInputBindingDivisorDescriptionEXT(VkVertexInputBindingDivisorDescriptionEXT obj,const std::string & s,bool commaNeeded=true)41880 static void print_VkVertexInputBindingDivisorDescriptionEXT(VkVertexInputBindingDivisorDescriptionEXT obj,
41881                                                             const std::string &s, bool commaNeeded = true)
41882 {
41883     PRINT_SPACE
41884     _OUT << "{" << std::endl;
41885     INDENT(4);
41886 
41887     print_uint32_t(obj.binding, "binding", 1);
41888 
41889     print_uint32_t(obj.divisor, "divisor", 0);
41890 
41891     INDENT(-4);
41892     PRINT_SPACE
41893     if (commaNeeded)
41894         _OUT << "}," << std::endl;
41895     else
41896         _OUT << "}" << std::endl;
41897 }
print_VkVertexInputBindingDivisorDescriptionEXT(const VkVertexInputBindingDivisorDescriptionEXT * obj,const std::string & s,bool commaNeeded=true)41898 static void print_VkVertexInputBindingDivisorDescriptionEXT(const VkVertexInputBindingDivisorDescriptionEXT *obj,
41899                                                             const std::string &s, bool commaNeeded = true)
41900 {
41901     PRINT_SPACE
41902     _OUT << "{" << std::endl;
41903     INDENT(4);
41904 
41905     print_uint32_t(obj->binding, "binding", 1);
41906 
41907     print_uint32_t(obj->divisor, "divisor", 0);
41908 
41909     INDENT(-4);
41910     PRINT_SPACE
41911     if (commaNeeded)
41912         _OUT << "}," << std::endl;
41913     else
41914         _OUT << "}" << std::endl;
41915 }
41916 
print_VkPipelineVertexInputDivisorStateCreateInfoEXT(VkPipelineVertexInputDivisorStateCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)41917 static void print_VkPipelineVertexInputDivisorStateCreateInfoEXT(VkPipelineVertexInputDivisorStateCreateInfoEXT obj,
41918                                                                  const std::string &s, bool commaNeeded = true)
41919 {
41920     PRINT_SPACE
41921     _OUT << "{" << std::endl;
41922     INDENT(4);
41923 
41924     print_VkStructureType(obj.sType, "sType", 1);
41925 
41926     if (obj.pNext)
41927     {
41928         dumpPNextChain(obj.pNext);
41929     }
41930     else
41931     {
41932         PRINT_SPACE
41933         _OUT << "\"pNext\":"
41934              << "\"NULL\""
41935              << "," << std::endl;
41936     }
41937 
41938     print_uint32_t(obj.vertexBindingDivisorCount, "vertexBindingDivisorCount", 1);
41939 
41940     PRINT_SPACE
41941     _OUT << "\"pVertexBindingDivisors\": " << std::endl;
41942     if (obj.pVertexBindingDivisors)
41943     {
41944         PRINT_SPACE
41945         _OUT << "[" << std::endl;
41946         for (unsigned int i = 0; i < obj.vertexBindingDivisorCount; i++)
41947         {
41948             if (i + 1 == obj.vertexBindingDivisorCount)
41949                 print_VkVertexInputBindingDivisorDescriptionEXT(obj.pVertexBindingDivisors[i], "pVertexBindingDivisors",
41950                                                                 0);
41951             else
41952                 print_VkVertexInputBindingDivisorDescriptionEXT(obj.pVertexBindingDivisors[i], "pVertexBindingDivisors",
41953                                                                 1);
41954         }
41955         PRINT_SPACE
41956         _OUT << "]" << std::endl;
41957     }
41958     else
41959     {
41960         PRINT_SPACE _OUT << "\"NULL\""
41961                          << "" << std::endl;
41962     }
41963 
41964     INDENT(-4);
41965     PRINT_SPACE
41966     if (commaNeeded)
41967         _OUT << "}," << std::endl;
41968     else
41969         _OUT << "}" << std::endl;
41970 }
print_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)41971 static void print_VkPipelineVertexInputDivisorStateCreateInfoEXT(
41972     const VkPipelineVertexInputDivisorStateCreateInfoEXT *obj, const std::string &s, bool commaNeeded = true)
41973 {
41974     PRINT_SPACE
41975     _OUT << "{" << std::endl;
41976     INDENT(4);
41977 
41978     print_VkStructureType(obj->sType, "sType", 1);
41979 
41980     if (obj->pNext)
41981     {
41982         dumpPNextChain(obj->pNext);
41983     }
41984     else
41985     {
41986         PRINT_SPACE
41987         _OUT << "\"pNext\":"
41988              << "\"NULL\""
41989              << "," << std::endl;
41990     }
41991 
41992     print_uint32_t(obj->vertexBindingDivisorCount, "vertexBindingDivisorCount", 1);
41993 
41994     PRINT_SPACE
41995     _OUT << "\"pVertexBindingDivisors\": " << std::endl;
41996     if (obj->pVertexBindingDivisors)
41997     {
41998         PRINT_SPACE
41999         _OUT << "[" << std::endl;
42000         for (unsigned int i = 0; i < obj->vertexBindingDivisorCount; i++)
42001         {
42002             if (i + 1 == obj->vertexBindingDivisorCount)
42003                 print_VkVertexInputBindingDivisorDescriptionEXT(obj->pVertexBindingDivisors[i],
42004                                                                 "pVertexBindingDivisors", 0);
42005             else
42006                 print_VkVertexInputBindingDivisorDescriptionEXT(obj->pVertexBindingDivisors[i],
42007                                                                 "pVertexBindingDivisors", 1);
42008         }
42009         PRINT_SPACE
42010         _OUT << "]" << std::endl;
42011     }
42012     else
42013     {
42014         PRINT_SPACE _OUT << "\"NULL\""
42015                          << "" << std::endl;
42016     }
42017 
42018     INDENT(-4);
42019     PRINT_SPACE
42020     if (commaNeeded)
42021         _OUT << "}," << std::endl;
42022     else
42023         _OUT << "}" << std::endl;
42024 }
42025 
print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT obj,const std::string & s,bool commaNeeded=true)42026 static void print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
42027     VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT obj, const std::string &s, bool commaNeeded = true)
42028 {
42029     PRINT_SPACE
42030     _OUT << "{" << std::endl;
42031     INDENT(4);
42032 
42033     print_VkStructureType(obj.sType, "sType", 1);
42034 
42035     if (obj.pNext)
42036     {
42037         dumpPNextChain(obj.pNext);
42038     }
42039     else
42040     {
42041         PRINT_SPACE
42042         _OUT << "\"pNext\":"
42043              << "\"NULL\""
42044              << "," << std::endl;
42045     }
42046 
42047     print_VkBool32(obj.vertexAttributeInstanceRateDivisor, "vertexAttributeInstanceRateDivisor", 1);
42048 
42049     print_VkBool32(obj.vertexAttributeInstanceRateZeroDivisor, "vertexAttributeInstanceRateZeroDivisor", 0);
42050 
42051     INDENT(-4);
42052     PRINT_SPACE
42053     if (commaNeeded)
42054         _OUT << "}," << std::endl;
42055     else
42056         _OUT << "}" << std::endl;
42057 }
print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)42058 static void print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
42059     const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *obj, const std::string &s, bool commaNeeded = true)
42060 {
42061     PRINT_SPACE
42062     _OUT << "{" << std::endl;
42063     INDENT(4);
42064 
42065     print_VkStructureType(obj->sType, "sType", 1);
42066 
42067     if (obj->pNext)
42068     {
42069         dumpPNextChain(obj->pNext);
42070     }
42071     else
42072     {
42073         PRINT_SPACE
42074         _OUT << "\"pNext\":"
42075              << "\"NULL\""
42076              << "," << std::endl;
42077     }
42078 
42079     print_VkBool32(obj->vertexAttributeInstanceRateDivisor, "vertexAttributeInstanceRateDivisor", 1);
42080 
42081     print_VkBool32(obj->vertexAttributeInstanceRateZeroDivisor, "vertexAttributeInstanceRateZeroDivisor", 0);
42082 
42083     INDENT(-4);
42084     PRINT_SPACE
42085     if (commaNeeded)
42086         _OUT << "}," << std::endl;
42087     else
42088         _OUT << "}" << std::endl;
42089 }
42090 
print_VkPhysicalDevicePCIBusInfoPropertiesEXT(VkPhysicalDevicePCIBusInfoPropertiesEXT obj,const std::string & s,bool commaNeeded=true)42091 static void print_VkPhysicalDevicePCIBusInfoPropertiesEXT(VkPhysicalDevicePCIBusInfoPropertiesEXT obj,
42092                                                           const std::string &s, bool commaNeeded = true)
42093 {
42094     PRINT_SPACE
42095     _OUT << "{" << std::endl;
42096     INDENT(4);
42097 
42098     print_VkStructureType(obj.sType, "sType", 1);
42099 
42100     if (obj.pNext)
42101     {
42102         dumpPNextChain(obj.pNext);
42103     }
42104     else
42105     {
42106         PRINT_SPACE
42107         _OUT << "\"pNext\":"
42108              << "\"NULL\""
42109              << "," << std::endl;
42110     }
42111 
42112     print_uint32_t(obj.pciDomain, "pciDomain", 1);
42113 
42114     print_uint32_t(obj.pciBus, "pciBus", 1);
42115 
42116     print_uint32_t(obj.pciDevice, "pciDevice", 1);
42117 
42118     print_uint32_t(obj.pciFunction, "pciFunction", 0);
42119 
42120     INDENT(-4);
42121     PRINT_SPACE
42122     if (commaNeeded)
42123         _OUT << "}," << std::endl;
42124     else
42125         _OUT << "}" << std::endl;
42126 }
print_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)42127 static void print_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT *obj,
42128                                                           const std::string &s, bool commaNeeded = true)
42129 {
42130     PRINT_SPACE
42131     _OUT << "{" << std::endl;
42132     INDENT(4);
42133 
42134     print_VkStructureType(obj->sType, "sType", 1);
42135 
42136     if (obj->pNext)
42137     {
42138         dumpPNextChain(obj->pNext);
42139     }
42140     else
42141     {
42142         PRINT_SPACE
42143         _OUT << "\"pNext\":"
42144              << "\"NULL\""
42145              << "," << std::endl;
42146     }
42147 
42148     print_uint32_t(obj->pciDomain, "pciDomain", 1);
42149 
42150     print_uint32_t(obj->pciBus, "pciBus", 1);
42151 
42152     print_uint32_t(obj->pciDevice, "pciDevice", 1);
42153 
42154     print_uint32_t(obj->pciFunction, "pciFunction", 0);
42155 
42156     INDENT(-4);
42157     PRINT_SPACE
42158     if (commaNeeded)
42159         _OUT << "}," << std::endl;
42160     else
42161         _OUT << "}" << std::endl;
42162 }
42163 
print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(VkPhysicalDeviceSubgroupSizeControlFeaturesEXT obj,const std::string & s,bool commaNeeded=true)42164 static void print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(VkPhysicalDeviceSubgroupSizeControlFeaturesEXT obj,
42165                                                                  const std::string &s, bool commaNeeded = true)
42166 {
42167     PRINT_SPACE
42168     _OUT << "{" << std::endl;
42169     INDENT(4);
42170 
42171     print_VkStructureType(obj.sType, "sType", 1);
42172 
42173     if (obj.pNext)
42174     {
42175         dumpPNextChain(obj.pNext);
42176     }
42177     else
42178     {
42179         PRINT_SPACE
42180         _OUT << "\"pNext\":"
42181              << "\"NULL\""
42182              << "," << std::endl;
42183     }
42184 
42185     print_VkBool32(obj.subgroupSizeControl, "subgroupSizeControl", 1);
42186 
42187     print_VkBool32(obj.computeFullSubgroups, "computeFullSubgroups", 0);
42188 
42189     INDENT(-4);
42190     PRINT_SPACE
42191     if (commaNeeded)
42192         _OUT << "}," << std::endl;
42193     else
42194         _OUT << "}" << std::endl;
42195 }
print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)42196 static void print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
42197     const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *obj, const std::string &s, bool commaNeeded = true)
42198 {
42199     PRINT_SPACE
42200     _OUT << "{" << std::endl;
42201     INDENT(4);
42202 
42203     print_VkStructureType(obj->sType, "sType", 1);
42204 
42205     if (obj->pNext)
42206     {
42207         dumpPNextChain(obj->pNext);
42208     }
42209     else
42210     {
42211         PRINT_SPACE
42212         _OUT << "\"pNext\":"
42213              << "\"NULL\""
42214              << "," << std::endl;
42215     }
42216 
42217     print_VkBool32(obj->subgroupSizeControl, "subgroupSizeControl", 1);
42218 
42219     print_VkBool32(obj->computeFullSubgroups, "computeFullSubgroups", 0);
42220 
42221     INDENT(-4);
42222     PRINT_SPACE
42223     if (commaNeeded)
42224         _OUT << "}," << std::endl;
42225     else
42226         _OUT << "}" << std::endl;
42227 }
42228 
print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT obj,const std::string & s,bool commaNeeded=true)42229 static void print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT obj,
42230                                                                    const std::string &s, bool commaNeeded = true)
42231 {
42232     PRINT_SPACE
42233     _OUT << "{" << std::endl;
42234     INDENT(4);
42235 
42236     print_VkStructureType(obj.sType, "sType", 1);
42237 
42238     if (obj.pNext)
42239     {
42240         dumpPNextChain(obj.pNext);
42241     }
42242     else
42243     {
42244         PRINT_SPACE
42245         _OUT << "\"pNext\":"
42246              << "\"NULL\""
42247              << "," << std::endl;
42248     }
42249 
42250     print_uint32_t(obj.minSubgroupSize, "minSubgroupSize", 1);
42251 
42252     print_uint32_t(obj.maxSubgroupSize, "maxSubgroupSize", 1);
42253 
42254     print_uint32_t(obj.maxComputeWorkgroupSubgroups, "maxComputeWorkgroupSubgroups", 1);
42255 
42256     print_VkShaderStageFlags(obj.requiredSubgroupSizeStages, "requiredSubgroupSizeStages", 0);
42257 
42258     INDENT(-4);
42259     PRINT_SPACE
42260     if (commaNeeded)
42261         _OUT << "}," << std::endl;
42262     else
42263         _OUT << "}" << std::endl;
42264 }
print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)42265 static void print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
42266     const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *obj, const std::string &s, bool commaNeeded = true)
42267 {
42268     PRINT_SPACE
42269     _OUT << "{" << std::endl;
42270     INDENT(4);
42271 
42272     print_VkStructureType(obj->sType, "sType", 1);
42273 
42274     if (obj->pNext)
42275     {
42276         dumpPNextChain(obj->pNext);
42277     }
42278     else
42279     {
42280         PRINT_SPACE
42281         _OUT << "\"pNext\":"
42282              << "\"NULL\""
42283              << "," << std::endl;
42284     }
42285 
42286     print_uint32_t(obj->minSubgroupSize, "minSubgroupSize", 1);
42287 
42288     print_uint32_t(obj->maxSubgroupSize, "maxSubgroupSize", 1);
42289 
42290     print_uint32_t(obj->maxComputeWorkgroupSubgroups, "maxComputeWorkgroupSubgroups", 1);
42291 
42292     print_VkShaderStageFlags(obj->requiredSubgroupSizeStages, "requiredSubgroupSizeStages", 0);
42293 
42294     INDENT(-4);
42295     PRINT_SPACE
42296     if (commaNeeded)
42297         _OUT << "}," << std::endl;
42298     else
42299         _OUT << "}" << std::endl;
42300 }
42301 
print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)42302 static void print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
42303     VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT obj, const std::string &s, bool commaNeeded = true)
42304 {
42305     PRINT_SPACE
42306     _OUT << "{" << std::endl;
42307     INDENT(4);
42308 
42309     print_VkStructureType(obj.sType, "sType", 1);
42310 
42311     if (obj.pNext)
42312     {
42313         dumpPNextChain(obj.pNext);
42314     }
42315     else
42316     {
42317         PRINT_SPACE
42318         _OUT << "\"pNext\":"
42319              << "\"NULL\""
42320              << "," << std::endl;
42321     }
42322 
42323     print_uint32_t(obj.requiredSubgroupSize, "requiredSubgroupSize", 0);
42324 
42325     INDENT(-4);
42326     PRINT_SPACE
42327     if (commaNeeded)
42328         _OUT << "}," << std::endl;
42329     else
42330         _OUT << "}" << std::endl;
42331 }
print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)42332 static void print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
42333     const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *obj, const std::string &s, bool commaNeeded = true)
42334 {
42335     PRINT_SPACE
42336     _OUT << "{" << std::endl;
42337     INDENT(4);
42338 
42339     print_VkStructureType(obj->sType, "sType", 1);
42340 
42341     if (obj->pNext)
42342     {
42343         dumpPNextChain(obj->pNext);
42344     }
42345     else
42346     {
42347         PRINT_SPACE
42348         _OUT << "\"pNext\":"
42349              << "\"NULL\""
42350              << "," << std::endl;
42351     }
42352 
42353     print_uint32_t(obj->requiredSubgroupSize, "requiredSubgroupSize", 0);
42354 
42355     INDENT(-4);
42356     PRINT_SPACE
42357     if (commaNeeded)
42358         _OUT << "}," << std::endl;
42359     else
42360         _OUT << "}" << std::endl;
42361 }
42362 
print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT obj,const std::string & s,bool commaNeeded=true)42363 static void print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
42364     VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT obj, const std::string &s, bool commaNeeded = true)
42365 {
42366     PRINT_SPACE
42367     _OUT << "{" << std::endl;
42368     INDENT(4);
42369 
42370     print_VkStructureType(obj.sType, "sType", 1);
42371 
42372     if (obj.pNext)
42373     {
42374         dumpPNextChain(obj.pNext);
42375     }
42376     else
42377     {
42378         PRINT_SPACE
42379         _OUT << "\"pNext\":"
42380              << "\"NULL\""
42381              << "," << std::endl;
42382     }
42383 
42384     print_VkBool32(obj.shaderImageInt64Atomics, "shaderImageInt64Atomics", 1);
42385 
42386     print_VkBool32(obj.sparseImageInt64Atomics, "sparseImageInt64Atomics", 0);
42387 
42388     INDENT(-4);
42389     PRINT_SPACE
42390     if (commaNeeded)
42391         _OUT << "}," << std::endl;
42392     else
42393         _OUT << "}" << std::endl;
42394 }
print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT * obj,const std::string & s,bool commaNeeded=true)42395 static void print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
42396     const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *obj, const std::string &s, bool commaNeeded = true)
42397 {
42398     PRINT_SPACE
42399     _OUT << "{" << std::endl;
42400     INDENT(4);
42401 
42402     print_VkStructureType(obj->sType, "sType", 1);
42403 
42404     if (obj->pNext)
42405     {
42406         dumpPNextChain(obj->pNext);
42407     }
42408     else
42409     {
42410         PRINT_SPACE
42411         _OUT << "\"pNext\":"
42412              << "\"NULL\""
42413              << "," << std::endl;
42414     }
42415 
42416     print_VkBool32(obj->shaderImageInt64Atomics, "shaderImageInt64Atomics", 1);
42417 
42418     print_VkBool32(obj->sparseImageInt64Atomics, "sparseImageInt64Atomics", 0);
42419 
42420     INDENT(-4);
42421     PRINT_SPACE
42422     if (commaNeeded)
42423         _OUT << "}," << std::endl;
42424     else
42425         _OUT << "}" << std::endl;
42426 }
42427 
print_VkPhysicalDeviceMemoryBudgetPropertiesEXT(VkPhysicalDeviceMemoryBudgetPropertiesEXT obj,const std::string & s,bool commaNeeded=true)42428 static void print_VkPhysicalDeviceMemoryBudgetPropertiesEXT(VkPhysicalDeviceMemoryBudgetPropertiesEXT obj,
42429                                                             const std::string &s, bool commaNeeded = true)
42430 {
42431     PRINT_SPACE
42432     _OUT << "{" << std::endl;
42433     INDENT(4);
42434 
42435     print_VkStructureType(obj.sType, "sType", 1);
42436 
42437     if (obj.pNext)
42438     {
42439         dumpPNextChain(obj.pNext);
42440     }
42441     else
42442     {
42443         PRINT_SPACE
42444         _OUT << "\"pNext\":"
42445              << "\"NULL\""
42446              << "," << std::endl;
42447     }
42448 
42449     PRINT_SPACE
42450     _OUT << "\"heapBudget\":" << std::endl;
42451     PRINT_SPACE
42452     _OUT << "[" << std::endl;
42453     for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
42454     {
42455         bool isCommaNeeded = (i + 1) != VK_MAX_MEMORY_HEAPS;
42456         print_VkDeviceSize(obj.heapBudget[i], "", isCommaNeeded);
42457     }
42458     PRINT_SPACE
42459     _OUT << "]"
42460          << "," << std::endl;
42461 
42462     PRINT_SPACE
42463     _OUT << "\"heapUsage\":" << std::endl;
42464     PRINT_SPACE
42465     _OUT << "[" << std::endl;
42466     for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
42467     {
42468         bool isCommaNeeded = (i + 1) != VK_MAX_MEMORY_HEAPS;
42469         print_VkDeviceSize(obj.heapUsage[i], "", isCommaNeeded);
42470     }
42471     PRINT_SPACE
42472     _OUT << "]"
42473          << "" << std::endl;
42474 
42475     INDENT(-4);
42476     PRINT_SPACE
42477     if (commaNeeded)
42478         _OUT << "}," << std::endl;
42479     else
42480         _OUT << "}" << std::endl;
42481 }
print_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)42482 static void print_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT *obj,
42483                                                             const std::string &s, bool commaNeeded = true)
42484 {
42485     PRINT_SPACE
42486     _OUT << "{" << std::endl;
42487     INDENT(4);
42488 
42489     print_VkStructureType(obj->sType, "sType", 1);
42490 
42491     if (obj->pNext)
42492     {
42493         dumpPNextChain(obj->pNext);
42494     }
42495     else
42496     {
42497         PRINT_SPACE
42498         _OUT << "\"pNext\":"
42499              << "\"NULL\""
42500              << "," << std::endl;
42501     }
42502 
42503     PRINT_SPACE
42504     _OUT << "\"heapBudget\":" << std::endl;
42505     PRINT_SPACE
42506     _OUT << "[" << std::endl;
42507     for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
42508     {
42509         bool isCommaNeeded = (i + 1) != VK_MAX_MEMORY_HEAPS;
42510         print_VkDeviceSize(obj->heapBudget[i], "", isCommaNeeded);
42511     }
42512     PRINT_SPACE
42513     _OUT << "]"
42514          << "," << std::endl;
42515 
42516     PRINT_SPACE
42517     _OUT << "\"heapUsage\":" << std::endl;
42518     PRINT_SPACE
42519     _OUT << "[" << std::endl;
42520     for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
42521     {
42522         bool isCommaNeeded = (i + 1) != VK_MAX_MEMORY_HEAPS;
42523         print_VkDeviceSize(obj->heapUsage[i], "", isCommaNeeded);
42524     }
42525     PRINT_SPACE
42526     _OUT << "]"
42527          << "" << std::endl;
42528 
42529     INDENT(-4);
42530     PRINT_SPACE
42531     if (commaNeeded)
42532         _OUT << "}," << std::endl;
42533     else
42534         _OUT << "}" << std::endl;
42535 }
42536 
42537 static std::map<uint64_t, std::string> VkValidationFeatureEnableEXT_map = {
42538     std::make_pair(0, "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT"),
42539     std::make_pair(1, "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT"),
42540     std::make_pair(2, "VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT"),
42541     std::make_pair(3, "VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT"),
42542     std::make_pair(4, "VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT"),
42543 };
print_VkValidationFeatureEnableEXT(VkValidationFeatureEnableEXT obj,const std::string & str,bool commaNeeded=true)42544 static void print_VkValidationFeatureEnableEXT(VkValidationFeatureEnableEXT obj, const std::string &str,
42545                                                bool commaNeeded = true)
42546 {
42547     PRINT_SPACE
42548     if (str != "")
42549         _OUT << "\"" << str << "\""
42550              << " : ";
42551     if (commaNeeded)
42552         _OUT << "\"" << VkValidationFeatureEnableEXT_map[obj] << "\"," << std::endl;
42553     else
42554         _OUT << "\"" << VkValidationFeatureEnableEXT_map[obj] << "\"" << std::endl;
42555 }
print_VkValidationFeatureEnableEXT(const VkValidationFeatureEnableEXT * obj,const std::string & str,bool commaNeeded=true)42556 static void print_VkValidationFeatureEnableEXT(const VkValidationFeatureEnableEXT *obj, const std::string &str,
42557                                                bool commaNeeded = true)
42558 {
42559     PRINT_SPACE
42560     if (str != "")
42561         _OUT << "\"" << str << "\""
42562              << " : ";
42563     if (commaNeeded)
42564         _OUT << "\"" << VkValidationFeatureEnableEXT_map[*obj] << "\"," << std::endl;
42565     else
42566         _OUT << "\"" << VkValidationFeatureEnableEXT_map[*obj] << "\"" << std::endl;
42567 }
42568 
42569 static std::map<uint64_t, std::string> VkValidationFeatureDisableEXT_map = {
42570     std::make_pair(0, "VK_VALIDATION_FEATURE_DISABLE_ALL_EXT"),
42571     std::make_pair(1, "VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT"),
42572     std::make_pair(2, "VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT"),
42573     std::make_pair(3, "VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT"),
42574     std::make_pair(4, "VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT"),
42575     std::make_pair(5, "VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT"),
42576     std::make_pair(6, "VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT"),
42577     std::make_pair(7, "VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT"),
42578 };
print_VkValidationFeatureDisableEXT(VkValidationFeatureDisableEXT obj,const std::string & str,bool commaNeeded=true)42579 static void print_VkValidationFeatureDisableEXT(VkValidationFeatureDisableEXT obj, const std::string &str,
42580                                                 bool commaNeeded = true)
42581 {
42582     PRINT_SPACE
42583     if (str != "")
42584         _OUT << "\"" << str << "\""
42585              << " : ";
42586     if (commaNeeded)
42587         _OUT << "\"" << VkValidationFeatureDisableEXT_map[obj] << "\"," << std::endl;
42588     else
42589         _OUT << "\"" << VkValidationFeatureDisableEXT_map[obj] << "\"" << std::endl;
42590 }
print_VkValidationFeatureDisableEXT(const VkValidationFeatureDisableEXT * obj,const std::string & str,bool commaNeeded=true)42591 static void print_VkValidationFeatureDisableEXT(const VkValidationFeatureDisableEXT *obj, const std::string &str,
42592                                                 bool commaNeeded = true)
42593 {
42594     PRINT_SPACE
42595     if (str != "")
42596         _OUT << "\"" << str << "\""
42597              << " : ";
42598     if (commaNeeded)
42599         _OUT << "\"" << VkValidationFeatureDisableEXT_map[*obj] << "\"," << std::endl;
42600     else
42601         _OUT << "\"" << VkValidationFeatureDisableEXT_map[*obj] << "\"" << std::endl;
42602 }
42603 
print_VkValidationFeaturesEXT(VkValidationFeaturesEXT obj,const std::string & s,bool commaNeeded=true)42604 static void print_VkValidationFeaturesEXT(VkValidationFeaturesEXT obj, const std::string &s, bool commaNeeded = true)
42605 {
42606     PRINT_SPACE
42607     _OUT << "{" << std::endl;
42608     INDENT(4);
42609 
42610     print_VkStructureType(obj.sType, "sType", 1);
42611 
42612     if (obj.pNext)
42613     {
42614         dumpPNextChain(obj.pNext);
42615     }
42616     else
42617     {
42618         PRINT_SPACE
42619         _OUT << "\"pNext\":"
42620              << "\"NULL\""
42621              << "," << std::endl;
42622     }
42623 
42624     print_uint32_t(obj.enabledValidationFeatureCount, "enabledValidationFeatureCount", 1);
42625 
42626     PRINT_SPACE
42627     _OUT << "\"pEnabledValidationFeatures\":" << std::endl;
42628     PRINT_SPACE
42629     if (obj.pEnabledValidationFeatures)
42630     {
42631         _OUT << "[" << std::endl;
42632         for (unsigned int i = 0; i < obj.enabledValidationFeatureCount; i++)
42633         {
42634             bool isCommaNeeded = (i + 1) != obj.enabledValidationFeatureCount;
42635             print_VkValidationFeatureEnableEXT(obj.pEnabledValidationFeatures[i], "", isCommaNeeded);
42636         }
42637         PRINT_SPACE
42638         _OUT << "]"
42639              << "," << std::endl;
42640     }
42641     else
42642     {
42643         _OUT << "\"NULL\""
42644              << "," << std::endl;
42645     }
42646 
42647     print_uint32_t(obj.disabledValidationFeatureCount, "disabledValidationFeatureCount", 1);
42648 
42649     PRINT_SPACE
42650     _OUT << "\"pDisabledValidationFeatures\":" << std::endl;
42651     PRINT_SPACE
42652     if (obj.pDisabledValidationFeatures)
42653     {
42654         _OUT << "[" << std::endl;
42655         for (unsigned int i = 0; i < obj.disabledValidationFeatureCount; i++)
42656         {
42657             bool isCommaNeeded = (i + 1) != obj.disabledValidationFeatureCount;
42658             print_VkValidationFeatureDisableEXT(obj.pDisabledValidationFeatures[i], "", isCommaNeeded);
42659         }
42660         PRINT_SPACE
42661         _OUT << "]"
42662              << "" << std::endl;
42663     }
42664     else
42665     {
42666         _OUT << "\"NULL\""
42667              << "" << std::endl;
42668     }
42669 
42670     INDENT(-4);
42671     PRINT_SPACE
42672     if (commaNeeded)
42673         _OUT << "}," << std::endl;
42674     else
42675         _OUT << "}" << std::endl;
42676 }
print_VkValidationFeaturesEXT(const VkValidationFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)42677 static void print_VkValidationFeaturesEXT(const VkValidationFeaturesEXT *obj, const std::string &s,
42678                                           bool commaNeeded = true)
42679 {
42680     PRINT_SPACE
42681     _OUT << "{" << std::endl;
42682     INDENT(4);
42683 
42684     print_VkStructureType(obj->sType, "sType", 1);
42685 
42686     if (obj->pNext)
42687     {
42688         dumpPNextChain(obj->pNext);
42689     }
42690     else
42691     {
42692         PRINT_SPACE
42693         _OUT << "\"pNext\":"
42694              << "\"NULL\""
42695              << "," << std::endl;
42696     }
42697 
42698     print_uint32_t(obj->enabledValidationFeatureCount, "enabledValidationFeatureCount", 1);
42699 
42700     PRINT_SPACE
42701     _OUT << "\"pEnabledValidationFeatures\":" << std::endl;
42702     PRINT_SPACE
42703     if (obj->pEnabledValidationFeatures)
42704     {
42705         _OUT << "[" << std::endl;
42706         for (unsigned int i = 0; i < obj->enabledValidationFeatureCount; i++)
42707         {
42708             bool isCommaNeeded = (i + 1) != obj->enabledValidationFeatureCount;
42709             print_VkValidationFeatureEnableEXT(obj->pEnabledValidationFeatures[i], "", isCommaNeeded);
42710         }
42711         PRINT_SPACE
42712         _OUT << "]"
42713              << "," << std::endl;
42714     }
42715     else
42716     {
42717         _OUT << "\"NULL\""
42718              << "," << std::endl;
42719     }
42720 
42721     print_uint32_t(obj->disabledValidationFeatureCount, "disabledValidationFeatureCount", 1);
42722 
42723     PRINT_SPACE
42724     _OUT << "\"pDisabledValidationFeatures\":" << std::endl;
42725     PRINT_SPACE
42726     if (obj->pDisabledValidationFeatures)
42727     {
42728         _OUT << "[" << std::endl;
42729         for (unsigned int i = 0; i < obj->disabledValidationFeatureCount; i++)
42730         {
42731             bool isCommaNeeded = (i + 1) != obj->disabledValidationFeatureCount;
42732             print_VkValidationFeatureDisableEXT(obj->pDisabledValidationFeatures[i], "", isCommaNeeded);
42733         }
42734         PRINT_SPACE
42735         _OUT << "]"
42736              << "" << std::endl;
42737     }
42738     else
42739     {
42740         _OUT << "\"NULL\""
42741              << "" << std::endl;
42742     }
42743 
42744     INDENT(-4);
42745     PRINT_SPACE
42746     if (commaNeeded)
42747         _OUT << "}," << std::endl;
42748     else
42749         _OUT << "}" << std::endl;
42750 }
42751 
print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT obj,const std::string & s,bool commaNeeded=true)42752 static void print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
42753     VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT obj, const std::string &s, bool commaNeeded = true)
42754 {
42755     PRINT_SPACE
42756     _OUT << "{" << std::endl;
42757     INDENT(4);
42758 
42759     print_VkStructureType(obj.sType, "sType", 1);
42760 
42761     if (obj.pNext)
42762     {
42763         dumpPNextChain(obj.pNext);
42764     }
42765     else
42766     {
42767         PRINT_SPACE
42768         _OUT << "\"pNext\":"
42769              << "\"NULL\""
42770              << "," << std::endl;
42771     }
42772 
42773     print_VkBool32(obj.fragmentShaderSampleInterlock, "fragmentShaderSampleInterlock", 1);
42774 
42775     print_VkBool32(obj.fragmentShaderPixelInterlock, "fragmentShaderPixelInterlock", 1);
42776 
42777     print_VkBool32(obj.fragmentShaderShadingRateInterlock, "fragmentShaderShadingRateInterlock", 0);
42778 
42779     INDENT(-4);
42780     PRINT_SPACE
42781     if (commaNeeded)
42782         _OUT << "}," << std::endl;
42783     else
42784         _OUT << "}" << std::endl;
42785 }
print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)42786 static void print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
42787     const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *obj, const std::string &s, bool commaNeeded = true)
42788 {
42789     PRINT_SPACE
42790     _OUT << "{" << std::endl;
42791     INDENT(4);
42792 
42793     print_VkStructureType(obj->sType, "sType", 1);
42794 
42795     if (obj->pNext)
42796     {
42797         dumpPNextChain(obj->pNext);
42798     }
42799     else
42800     {
42801         PRINT_SPACE
42802         _OUT << "\"pNext\":"
42803              << "\"NULL\""
42804              << "," << std::endl;
42805     }
42806 
42807     print_VkBool32(obj->fragmentShaderSampleInterlock, "fragmentShaderSampleInterlock", 1);
42808 
42809     print_VkBool32(obj->fragmentShaderPixelInterlock, "fragmentShaderPixelInterlock", 1);
42810 
42811     print_VkBool32(obj->fragmentShaderShadingRateInterlock, "fragmentShaderShadingRateInterlock", 0);
42812 
42813     INDENT(-4);
42814     PRINT_SPACE
42815     if (commaNeeded)
42816         _OUT << "}," << std::endl;
42817     else
42818         _OUT << "}" << std::endl;
42819 }
42820 
print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT obj,const std::string & s,bool commaNeeded=true)42821 static void print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT obj,
42822                                                               const std::string &s, bool commaNeeded = true)
42823 {
42824     PRINT_SPACE
42825     _OUT << "{" << std::endl;
42826     INDENT(4);
42827 
42828     print_VkStructureType(obj.sType, "sType", 1);
42829 
42830     if (obj.pNext)
42831     {
42832         dumpPNextChain(obj.pNext);
42833     }
42834     else
42835     {
42836         PRINT_SPACE
42837         _OUT << "\"pNext\":"
42838              << "\"NULL\""
42839              << "," << std::endl;
42840     }
42841 
42842     print_VkBool32(obj.ycbcrImageArrays, "ycbcrImageArrays", 0);
42843 
42844     INDENT(-4);
42845     PRINT_SPACE
42846     if (commaNeeded)
42847         _OUT << "}," << std::endl;
42848     else
42849         _OUT << "}" << std::endl;
42850 }
print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)42851 static void print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *obj,
42852                                                               const std::string &s, bool commaNeeded = true)
42853 {
42854     PRINT_SPACE
42855     _OUT << "{" << std::endl;
42856     INDENT(4);
42857 
42858     print_VkStructureType(obj->sType, "sType", 1);
42859 
42860     if (obj->pNext)
42861     {
42862         dumpPNextChain(obj->pNext);
42863     }
42864     else
42865     {
42866         PRINT_SPACE
42867         _OUT << "\"pNext\":"
42868              << "\"NULL\""
42869              << "," << std::endl;
42870     }
42871 
42872     print_VkBool32(obj->ycbcrImageArrays, "ycbcrImageArrays", 0);
42873 
42874     INDENT(-4);
42875     PRINT_SPACE
42876     if (commaNeeded)
42877         _OUT << "}," << std::endl;
42878     else
42879         _OUT << "}" << std::endl;
42880 }
42881 
print_VkHeadlessSurfaceCreateFlagsEXT(VkHeadlessSurfaceCreateFlagsEXT obj,const std::string & str,bool commaNeeded=true)42882 static void print_VkHeadlessSurfaceCreateFlagsEXT(VkHeadlessSurfaceCreateFlagsEXT obj, const std::string &str,
42883                                                   bool commaNeeded = true)
42884 {
42885     PRINT_SPACE
42886     if (commaNeeded)
42887         _OUT << "\"" << str << "\""
42888              << " : " << obj << "," << std::endl;
42889     else
42890         _OUT << "\"" << str << "\""
42891              << " : " << obj << std::endl;
42892 }
print_VkHeadlessSurfaceCreateFlagsEXT(const VkHeadlessSurfaceCreateFlagsEXT * obj,const std::string & str,bool commaNeeded=true)42893 static void print_VkHeadlessSurfaceCreateFlagsEXT(const VkHeadlessSurfaceCreateFlagsEXT *obj, const std::string &str,
42894                                                   bool commaNeeded = true)
42895 {
42896     PRINT_SPACE
42897     if (commaNeeded)
42898         _OUT << "\"" << str << "\""
42899              << " : " << obj << "," << std::endl;
42900     else
42901         _OUT << "\"" << str << "\""
42902              << " : " << obj << std::endl;
42903 }
42904 
print_VkHeadlessSurfaceCreateInfoEXT(VkHeadlessSurfaceCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)42905 static void print_VkHeadlessSurfaceCreateInfoEXT(VkHeadlessSurfaceCreateInfoEXT obj, const std::string &s,
42906                                                  bool commaNeeded = true)
42907 {
42908     PRINT_SPACE
42909     _OUT << "{" << std::endl;
42910     INDENT(4);
42911 
42912     print_VkStructureType(obj.sType, "sType", 1);
42913 
42914     if (obj.pNext)
42915     {
42916         dumpPNextChain(obj.pNext);
42917     }
42918     else
42919     {
42920         PRINT_SPACE
42921         _OUT << "\"pNext\":"
42922              << "\"NULL\""
42923              << "," << std::endl;
42924     }
42925 
42926     print_VkHeadlessSurfaceCreateFlagsEXT(obj.flags, "flags", 0);
42927 
42928     INDENT(-4);
42929     PRINT_SPACE
42930     if (commaNeeded)
42931         _OUT << "}," << std::endl;
42932     else
42933         _OUT << "}" << std::endl;
42934 }
print_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)42935 static void print_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT *obj, const std::string &s,
42936                                                  bool commaNeeded = true)
42937 {
42938     PRINT_SPACE
42939     _OUT << "{" << std::endl;
42940     INDENT(4);
42941 
42942     print_VkStructureType(obj->sType, "sType", 1);
42943 
42944     if (obj->pNext)
42945     {
42946         dumpPNextChain(obj->pNext);
42947     }
42948     else
42949     {
42950         PRINT_SPACE
42951         _OUT << "\"pNext\":"
42952              << "\"NULL\""
42953              << "," << std::endl;
42954     }
42955 
42956     print_VkHeadlessSurfaceCreateFlagsEXT(obj->flags, "flags", 0);
42957 
42958     INDENT(-4);
42959     PRINT_SPACE
42960     if (commaNeeded)
42961         _OUT << "}," << std::endl;
42962     else
42963         _OUT << "}" << std::endl;
42964 }
42965 
42966 static std::map<uint64_t, std::string> VkLineRasterizationModeEXT_map = {
42967     std::make_pair(0, "VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT"),
42968     std::make_pair(1, "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT"),
42969     std::make_pair(2, "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT"),
42970     std::make_pair(3, "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT"),
42971 };
print_VkLineRasterizationModeEXT(VkLineRasterizationModeEXT obj,const std::string & str,bool commaNeeded=true)42972 static void print_VkLineRasterizationModeEXT(VkLineRasterizationModeEXT obj, const std::string &str,
42973                                              bool commaNeeded = true)
42974 {
42975     PRINT_SPACE
42976     if (str != "")
42977         _OUT << "\"" << str << "\""
42978              << " : ";
42979     if (commaNeeded)
42980         _OUT << "\"" << VkLineRasterizationModeEXT_map[obj] << "\"," << std::endl;
42981     else
42982         _OUT << "\"" << VkLineRasterizationModeEXT_map[obj] << "\"" << std::endl;
42983 }
print_VkLineRasterizationModeEXT(const VkLineRasterizationModeEXT * obj,const std::string & str,bool commaNeeded=true)42984 static void print_VkLineRasterizationModeEXT(const VkLineRasterizationModeEXT *obj, const std::string &str,
42985                                              bool commaNeeded = true)
42986 {
42987     PRINT_SPACE
42988     if (str != "")
42989         _OUT << "\"" << str << "\""
42990              << " : ";
42991     if (commaNeeded)
42992         _OUT << "\"" << VkLineRasterizationModeEXT_map[*obj] << "\"," << std::endl;
42993     else
42994         _OUT << "\"" << VkLineRasterizationModeEXT_map[*obj] << "\"" << std::endl;
42995 }
42996 
print_VkPhysicalDeviceLineRasterizationFeaturesEXT(VkPhysicalDeviceLineRasterizationFeaturesEXT obj,const std::string & s,bool commaNeeded=true)42997 static void print_VkPhysicalDeviceLineRasterizationFeaturesEXT(VkPhysicalDeviceLineRasterizationFeaturesEXT obj,
42998                                                                const std::string &s, bool commaNeeded = true)
42999 {
43000     PRINT_SPACE
43001     _OUT << "{" << std::endl;
43002     INDENT(4);
43003 
43004     print_VkStructureType(obj.sType, "sType", 1);
43005 
43006     if (obj.pNext)
43007     {
43008         dumpPNextChain(obj.pNext);
43009     }
43010     else
43011     {
43012         PRINT_SPACE
43013         _OUT << "\"pNext\":"
43014              << "\"NULL\""
43015              << "," << std::endl;
43016     }
43017 
43018     print_VkBool32(obj.rectangularLines, "rectangularLines", 1);
43019 
43020     print_VkBool32(obj.bresenhamLines, "bresenhamLines", 1);
43021 
43022     print_VkBool32(obj.smoothLines, "smoothLines", 1);
43023 
43024     print_VkBool32(obj.stippledRectangularLines, "stippledRectangularLines", 1);
43025 
43026     print_VkBool32(obj.stippledBresenhamLines, "stippledBresenhamLines", 1);
43027 
43028     print_VkBool32(obj.stippledSmoothLines, "stippledSmoothLines", 0);
43029 
43030     INDENT(-4);
43031     PRINT_SPACE
43032     if (commaNeeded)
43033         _OUT << "}," << std::endl;
43034     else
43035         _OUT << "}" << std::endl;
43036 }
print_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)43037 static void print_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT *obj,
43038                                                                const std::string &s, bool commaNeeded = true)
43039 {
43040     PRINT_SPACE
43041     _OUT << "{" << std::endl;
43042     INDENT(4);
43043 
43044     print_VkStructureType(obj->sType, "sType", 1);
43045 
43046     if (obj->pNext)
43047     {
43048         dumpPNextChain(obj->pNext);
43049     }
43050     else
43051     {
43052         PRINT_SPACE
43053         _OUT << "\"pNext\":"
43054              << "\"NULL\""
43055              << "," << std::endl;
43056     }
43057 
43058     print_VkBool32(obj->rectangularLines, "rectangularLines", 1);
43059 
43060     print_VkBool32(obj->bresenhamLines, "bresenhamLines", 1);
43061 
43062     print_VkBool32(obj->smoothLines, "smoothLines", 1);
43063 
43064     print_VkBool32(obj->stippledRectangularLines, "stippledRectangularLines", 1);
43065 
43066     print_VkBool32(obj->stippledBresenhamLines, "stippledBresenhamLines", 1);
43067 
43068     print_VkBool32(obj->stippledSmoothLines, "stippledSmoothLines", 0);
43069 
43070     INDENT(-4);
43071     PRINT_SPACE
43072     if (commaNeeded)
43073         _OUT << "}," << std::endl;
43074     else
43075         _OUT << "}" << std::endl;
43076 }
43077 
print_VkPhysicalDeviceLineRasterizationPropertiesEXT(VkPhysicalDeviceLineRasterizationPropertiesEXT obj,const std::string & s,bool commaNeeded=true)43078 static void print_VkPhysicalDeviceLineRasterizationPropertiesEXT(VkPhysicalDeviceLineRasterizationPropertiesEXT obj,
43079                                                                  const std::string &s, bool commaNeeded = true)
43080 {
43081     PRINT_SPACE
43082     _OUT << "{" << std::endl;
43083     INDENT(4);
43084 
43085     print_VkStructureType(obj.sType, "sType", 1);
43086 
43087     if (obj.pNext)
43088     {
43089         dumpPNextChain(obj.pNext);
43090     }
43091     else
43092     {
43093         PRINT_SPACE
43094         _OUT << "\"pNext\":"
43095              << "\"NULL\""
43096              << "," << std::endl;
43097     }
43098 
43099     print_uint32_t(obj.lineSubPixelPrecisionBits, "lineSubPixelPrecisionBits", 0);
43100 
43101     INDENT(-4);
43102     PRINT_SPACE
43103     if (commaNeeded)
43104         _OUT << "}," << std::endl;
43105     else
43106         _OUT << "}" << std::endl;
43107 }
print_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)43108 static void print_VkPhysicalDeviceLineRasterizationPropertiesEXT(
43109     const VkPhysicalDeviceLineRasterizationPropertiesEXT *obj, const std::string &s, bool commaNeeded = true)
43110 {
43111     PRINT_SPACE
43112     _OUT << "{" << std::endl;
43113     INDENT(4);
43114 
43115     print_VkStructureType(obj->sType, "sType", 1);
43116 
43117     if (obj->pNext)
43118     {
43119         dumpPNextChain(obj->pNext);
43120     }
43121     else
43122     {
43123         PRINT_SPACE
43124         _OUT << "\"pNext\":"
43125              << "\"NULL\""
43126              << "," << std::endl;
43127     }
43128 
43129     print_uint32_t(obj->lineSubPixelPrecisionBits, "lineSubPixelPrecisionBits", 0);
43130 
43131     INDENT(-4);
43132     PRINT_SPACE
43133     if (commaNeeded)
43134         _OUT << "}," << std::endl;
43135     else
43136         _OUT << "}" << std::endl;
43137 }
43138 
print_VkPipelineRasterizationLineStateCreateInfoEXT(VkPipelineRasterizationLineStateCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)43139 static void print_VkPipelineRasterizationLineStateCreateInfoEXT(VkPipelineRasterizationLineStateCreateInfoEXT obj,
43140                                                                 const std::string &s, bool commaNeeded = true)
43141 {
43142     PRINT_SPACE
43143     _OUT << "{" << std::endl;
43144     INDENT(4);
43145 
43146     print_VkStructureType(obj.sType, "sType", 1);
43147 
43148     if (obj.pNext)
43149     {
43150         dumpPNextChain(obj.pNext);
43151     }
43152     else
43153     {
43154         PRINT_SPACE
43155         _OUT << "\"pNext\":"
43156              << "\"NULL\""
43157              << "," << std::endl;
43158     }
43159 
43160     print_VkLineRasterizationModeEXT(obj.lineRasterizationMode, "lineRasterizationMode", 1);
43161 
43162     print_VkBool32(obj.stippledLineEnable, "stippledLineEnable", 1);
43163 
43164     print_uint32_t(obj.lineStippleFactor, "lineStippleFactor", 1);
43165 
43166     print_uint16_t(obj.lineStipplePattern, "lineStipplePattern", 0);
43167 
43168     INDENT(-4);
43169     PRINT_SPACE
43170     if (commaNeeded)
43171         _OUT << "}," << std::endl;
43172     else
43173         _OUT << "}" << std::endl;
43174 }
print_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)43175 static void print_VkPipelineRasterizationLineStateCreateInfoEXT(
43176     const VkPipelineRasterizationLineStateCreateInfoEXT *obj, const std::string &s, bool commaNeeded = true)
43177 {
43178     PRINT_SPACE
43179     _OUT << "{" << std::endl;
43180     INDENT(4);
43181 
43182     print_VkStructureType(obj->sType, "sType", 1);
43183 
43184     if (obj->pNext)
43185     {
43186         dumpPNextChain(obj->pNext);
43187     }
43188     else
43189     {
43190         PRINT_SPACE
43191         _OUT << "\"pNext\":"
43192              << "\"NULL\""
43193              << "," << std::endl;
43194     }
43195 
43196     print_VkLineRasterizationModeEXT(obj->lineRasterizationMode, "lineRasterizationMode", 1);
43197 
43198     print_VkBool32(obj->stippledLineEnable, "stippledLineEnable", 1);
43199 
43200     print_uint32_t(obj->lineStippleFactor, "lineStippleFactor", 1);
43201 
43202     print_uint16_t(obj->lineStipplePattern, "lineStipplePattern", 0);
43203 
43204     INDENT(-4);
43205     PRINT_SPACE
43206     if (commaNeeded)
43207         _OUT << "}," << std::endl;
43208     else
43209         _OUT << "}" << std::endl;
43210 }
43211 
print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT obj,const std::string & s,bool commaNeeded=true)43212 static void print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT obj,
43213                                                                const std::string &s, bool commaNeeded = true)
43214 {
43215     PRINT_SPACE
43216     _OUT << "{" << std::endl;
43217     INDENT(4);
43218 
43219     print_VkStructureType(obj.sType, "sType", 1);
43220 
43221     if (obj.pNext)
43222     {
43223         dumpPNextChain(obj.pNext);
43224     }
43225     else
43226     {
43227         PRINT_SPACE
43228         _OUT << "\"pNext\":"
43229              << "\"NULL\""
43230              << "," << std::endl;
43231     }
43232 
43233     print_VkBool32(obj.shaderBufferFloat32Atomics, "shaderBufferFloat32Atomics", 1);
43234 
43235     print_VkBool32(obj.shaderBufferFloat32AtomicAdd, "shaderBufferFloat32AtomicAdd", 1);
43236 
43237     print_VkBool32(obj.shaderBufferFloat64Atomics, "shaderBufferFloat64Atomics", 1);
43238 
43239     print_VkBool32(obj.shaderBufferFloat64AtomicAdd, "shaderBufferFloat64AtomicAdd", 1);
43240 
43241     print_VkBool32(obj.shaderSharedFloat32Atomics, "shaderSharedFloat32Atomics", 1);
43242 
43243     print_VkBool32(obj.shaderSharedFloat32AtomicAdd, "shaderSharedFloat32AtomicAdd", 1);
43244 
43245     print_VkBool32(obj.shaderSharedFloat64Atomics, "shaderSharedFloat64Atomics", 1);
43246 
43247     print_VkBool32(obj.shaderSharedFloat64AtomicAdd, "shaderSharedFloat64AtomicAdd", 1);
43248 
43249     print_VkBool32(obj.shaderImageFloat32Atomics, "shaderImageFloat32Atomics", 1);
43250 
43251     print_VkBool32(obj.shaderImageFloat32AtomicAdd, "shaderImageFloat32AtomicAdd", 1);
43252 
43253     print_VkBool32(obj.sparseImageFloat32Atomics, "sparseImageFloat32Atomics", 1);
43254 
43255     print_VkBool32(obj.sparseImageFloat32AtomicAdd, "sparseImageFloat32AtomicAdd", 0);
43256 
43257     INDENT(-4);
43258     PRINT_SPACE
43259     if (commaNeeded)
43260         _OUT << "}," << std::endl;
43261     else
43262         _OUT << "}" << std::endl;
43263 }
print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)43264 static void print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *obj,
43265                                                                const std::string &s, bool commaNeeded = true)
43266 {
43267     PRINT_SPACE
43268     _OUT << "{" << std::endl;
43269     INDENT(4);
43270 
43271     print_VkStructureType(obj->sType, "sType", 1);
43272 
43273     if (obj->pNext)
43274     {
43275         dumpPNextChain(obj->pNext);
43276     }
43277     else
43278     {
43279         PRINT_SPACE
43280         _OUT << "\"pNext\":"
43281              << "\"NULL\""
43282              << "," << std::endl;
43283     }
43284 
43285     print_VkBool32(obj->shaderBufferFloat32Atomics, "shaderBufferFloat32Atomics", 1);
43286 
43287     print_VkBool32(obj->shaderBufferFloat32AtomicAdd, "shaderBufferFloat32AtomicAdd", 1);
43288 
43289     print_VkBool32(obj->shaderBufferFloat64Atomics, "shaderBufferFloat64Atomics", 1);
43290 
43291     print_VkBool32(obj->shaderBufferFloat64AtomicAdd, "shaderBufferFloat64AtomicAdd", 1);
43292 
43293     print_VkBool32(obj->shaderSharedFloat32Atomics, "shaderSharedFloat32Atomics", 1);
43294 
43295     print_VkBool32(obj->shaderSharedFloat32AtomicAdd, "shaderSharedFloat32AtomicAdd", 1);
43296 
43297     print_VkBool32(obj->shaderSharedFloat64Atomics, "shaderSharedFloat64Atomics", 1);
43298 
43299     print_VkBool32(obj->shaderSharedFloat64AtomicAdd, "shaderSharedFloat64AtomicAdd", 1);
43300 
43301     print_VkBool32(obj->shaderImageFloat32Atomics, "shaderImageFloat32Atomics", 1);
43302 
43303     print_VkBool32(obj->shaderImageFloat32AtomicAdd, "shaderImageFloat32AtomicAdd", 1);
43304 
43305     print_VkBool32(obj->sparseImageFloat32Atomics, "sparseImageFloat32Atomics", 1);
43306 
43307     print_VkBool32(obj->sparseImageFloat32AtomicAdd, "sparseImageFloat32AtomicAdd", 0);
43308 
43309     INDENT(-4);
43310     PRINT_SPACE
43311     if (commaNeeded)
43312         _OUT << "}," << std::endl;
43313     else
43314         _OUT << "}" << std::endl;
43315 }
43316 
print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(VkPhysicalDeviceIndexTypeUint8FeaturesEXT obj,const std::string & s,bool commaNeeded=true)43317 static void print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(VkPhysicalDeviceIndexTypeUint8FeaturesEXT obj,
43318                                                             const std::string &s, bool commaNeeded = true)
43319 {
43320     PRINT_SPACE
43321     _OUT << "{" << std::endl;
43322     INDENT(4);
43323 
43324     print_VkStructureType(obj.sType, "sType", 1);
43325 
43326     if (obj.pNext)
43327     {
43328         dumpPNextChain(obj.pNext);
43329     }
43330     else
43331     {
43332         PRINT_SPACE
43333         _OUT << "\"pNext\":"
43334              << "\"NULL\""
43335              << "," << std::endl;
43336     }
43337 
43338     print_VkBool32(obj.indexTypeUint8, "indexTypeUint8", 0);
43339 
43340     INDENT(-4);
43341     PRINT_SPACE
43342     if (commaNeeded)
43343         _OUT << "}," << std::endl;
43344     else
43345         _OUT << "}" << std::endl;
43346 }
print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * obj,const std::string & s,bool commaNeeded=true)43347 static void print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *obj,
43348                                                             const std::string &s, bool commaNeeded = true)
43349 {
43350     PRINT_SPACE
43351     _OUT << "{" << std::endl;
43352     INDENT(4);
43353 
43354     print_VkStructureType(obj->sType, "sType", 1);
43355 
43356     if (obj->pNext)
43357     {
43358         dumpPNextChain(obj->pNext);
43359     }
43360     else
43361     {
43362         PRINT_SPACE
43363         _OUT << "\"pNext\":"
43364              << "\"NULL\""
43365              << "," << std::endl;
43366     }
43367 
43368     print_VkBool32(obj->indexTypeUint8, "indexTypeUint8", 0);
43369 
43370     INDENT(-4);
43371     PRINT_SPACE
43372     if (commaNeeded)
43373         _OUT << "}," << std::endl;
43374     else
43375         _OUT << "}" << std::endl;
43376 }
43377 
print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT obj,const std::string & s,bool commaNeeded=true)43378 static void print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT obj,
43379                                                                   const std::string &s, bool commaNeeded = true)
43380 {
43381     PRINT_SPACE
43382     _OUT << "{" << std::endl;
43383     INDENT(4);
43384 
43385     print_VkStructureType(obj.sType, "sType", 1);
43386 
43387     if (obj.pNext)
43388     {
43389         dumpPNextChain(obj.pNext);
43390     }
43391     else
43392     {
43393         PRINT_SPACE
43394         _OUT << "\"pNext\":"
43395              << "\"NULL\""
43396              << "," << std::endl;
43397     }
43398 
43399     print_VkBool32(obj.extendedDynamicState, "extendedDynamicState", 0);
43400 
43401     INDENT(-4);
43402     PRINT_SPACE
43403     if (commaNeeded)
43404         _OUT << "}," << std::endl;
43405     else
43406         _OUT << "}" << std::endl;
43407 }
print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)43408 static void print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
43409     const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *obj, const std::string &s, bool commaNeeded = true)
43410 {
43411     PRINT_SPACE
43412     _OUT << "{" << std::endl;
43413     INDENT(4);
43414 
43415     print_VkStructureType(obj->sType, "sType", 1);
43416 
43417     if (obj->pNext)
43418     {
43419         dumpPNextChain(obj->pNext);
43420     }
43421     else
43422     {
43423         PRINT_SPACE
43424         _OUT << "\"pNext\":"
43425              << "\"NULL\""
43426              << "," << std::endl;
43427     }
43428 
43429     print_VkBool32(obj->extendedDynamicState, "extendedDynamicState", 0);
43430 
43431     INDENT(-4);
43432     PRINT_SPACE
43433     if (commaNeeded)
43434         _OUT << "}," << std::endl;
43435     else
43436         _OUT << "}" << std::endl;
43437 }
43438 
print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT obj,const std::string & s,bool commaNeeded=true)43439 static void print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
43440     VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT obj, const std::string &s, bool commaNeeded = true)
43441 {
43442     PRINT_SPACE
43443     _OUT << "{" << std::endl;
43444     INDENT(4);
43445 
43446     print_VkStructureType(obj.sType, "sType", 1);
43447 
43448     if (obj.pNext)
43449     {
43450         dumpPNextChain(obj.pNext);
43451     }
43452     else
43453     {
43454         PRINT_SPACE
43455         _OUT << "\"pNext\":"
43456              << "\"NULL\""
43457              << "," << std::endl;
43458     }
43459 
43460     print_VkBool32(obj.shaderDemoteToHelperInvocation, "shaderDemoteToHelperInvocation", 0);
43461 
43462     INDENT(-4);
43463     PRINT_SPACE
43464     if (commaNeeded)
43465         _OUT << "}," << std::endl;
43466     else
43467         _OUT << "}" << std::endl;
43468 }
print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)43469 static void print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
43470     const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *obj, const std::string &s, bool commaNeeded = true)
43471 {
43472     PRINT_SPACE
43473     _OUT << "{" << std::endl;
43474     INDENT(4);
43475 
43476     print_VkStructureType(obj->sType, "sType", 1);
43477 
43478     if (obj->pNext)
43479     {
43480         dumpPNextChain(obj->pNext);
43481     }
43482     else
43483     {
43484         PRINT_SPACE
43485         _OUT << "\"pNext\":"
43486              << "\"NULL\""
43487              << "," << std::endl;
43488     }
43489 
43490     print_VkBool32(obj->shaderDemoteToHelperInvocation, "shaderDemoteToHelperInvocation", 0);
43491 
43492     INDENT(-4);
43493     PRINT_SPACE
43494     if (commaNeeded)
43495         _OUT << "}," << std::endl;
43496     else
43497         _OUT << "}" << std::endl;
43498 }
43499 
print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT obj,const std::string & s,bool commaNeeded=true)43500 static void print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT obj,
43501                                                                   const std::string &s, bool commaNeeded = true)
43502 {
43503     PRINT_SPACE
43504     _OUT << "{" << std::endl;
43505     INDENT(4);
43506 
43507     print_VkStructureType(obj.sType, "sType", 1);
43508 
43509     if (obj.pNext)
43510     {
43511         dumpPNextChain(obj.pNext);
43512     }
43513     else
43514     {
43515         PRINT_SPACE
43516         _OUT << "\"pNext\":"
43517              << "\"NULL\""
43518              << "," << std::endl;
43519     }
43520 
43521     print_VkBool32(obj.texelBufferAlignment, "texelBufferAlignment", 0);
43522 
43523     INDENT(-4);
43524     PRINT_SPACE
43525     if (commaNeeded)
43526         _OUT << "}," << std::endl;
43527     else
43528         _OUT << "}" << std::endl;
43529 }
print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)43530 static void print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
43531     const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *obj, const std::string &s, bool commaNeeded = true)
43532 {
43533     PRINT_SPACE
43534     _OUT << "{" << std::endl;
43535     INDENT(4);
43536 
43537     print_VkStructureType(obj->sType, "sType", 1);
43538 
43539     if (obj->pNext)
43540     {
43541         dumpPNextChain(obj->pNext);
43542     }
43543     else
43544     {
43545         PRINT_SPACE
43546         _OUT << "\"pNext\":"
43547              << "\"NULL\""
43548              << "," << std::endl;
43549     }
43550 
43551     print_VkBool32(obj->texelBufferAlignment, "texelBufferAlignment", 0);
43552 
43553     INDENT(-4);
43554     PRINT_SPACE
43555     if (commaNeeded)
43556         _OUT << "}," << std::endl;
43557     else
43558         _OUT << "}" << std::endl;
43559 }
43560 
print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT obj,const std::string & s,bool commaNeeded=true)43561 static void print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
43562     VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT obj, const std::string &s, bool commaNeeded = true)
43563 {
43564     PRINT_SPACE
43565     _OUT << "{" << std::endl;
43566     INDENT(4);
43567 
43568     print_VkStructureType(obj.sType, "sType", 1);
43569 
43570     if (obj.pNext)
43571     {
43572         dumpPNextChain(obj.pNext);
43573     }
43574     else
43575     {
43576         PRINT_SPACE
43577         _OUT << "\"pNext\":"
43578              << "\"NULL\""
43579              << "," << std::endl;
43580     }
43581 
43582     print_VkDeviceSize(obj.storageTexelBufferOffsetAlignmentBytes, "storageTexelBufferOffsetAlignmentBytes", 1);
43583 
43584     print_VkBool32(obj.storageTexelBufferOffsetSingleTexelAlignment, "storageTexelBufferOffsetSingleTexelAlignment", 1);
43585 
43586     print_VkDeviceSize(obj.uniformTexelBufferOffsetAlignmentBytes, "uniformTexelBufferOffsetAlignmentBytes", 1);
43587 
43588     print_VkBool32(obj.uniformTexelBufferOffsetSingleTexelAlignment, "uniformTexelBufferOffsetSingleTexelAlignment", 0);
43589 
43590     INDENT(-4);
43591     PRINT_SPACE
43592     if (commaNeeded)
43593         _OUT << "}," << std::endl;
43594     else
43595         _OUT << "}" << std::endl;
43596 }
print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)43597 static void print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
43598     const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *obj, const std::string &s, bool commaNeeded = true)
43599 {
43600     PRINT_SPACE
43601     _OUT << "{" << std::endl;
43602     INDENT(4);
43603 
43604     print_VkStructureType(obj->sType, "sType", 1);
43605 
43606     if (obj->pNext)
43607     {
43608         dumpPNextChain(obj->pNext);
43609     }
43610     else
43611     {
43612         PRINT_SPACE
43613         _OUT << "\"pNext\":"
43614              << "\"NULL\""
43615              << "," << std::endl;
43616     }
43617 
43618     print_VkDeviceSize(obj->storageTexelBufferOffsetAlignmentBytes, "storageTexelBufferOffsetAlignmentBytes", 1);
43619 
43620     print_VkBool32(obj->storageTexelBufferOffsetSingleTexelAlignment, "storageTexelBufferOffsetSingleTexelAlignment",
43621                    1);
43622 
43623     print_VkDeviceSize(obj->uniformTexelBufferOffsetAlignmentBytes, "uniformTexelBufferOffsetAlignmentBytes", 1);
43624 
43625     print_VkBool32(obj->uniformTexelBufferOffsetSingleTexelAlignment, "uniformTexelBufferOffsetSingleTexelAlignment",
43626                    0);
43627 
43628     INDENT(-4);
43629     PRINT_SPACE
43630     if (commaNeeded)
43631         _OUT << "}," << std::endl;
43632     else
43633         _OUT << "}" << std::endl;
43634 }
43635 
print_VkPhysicalDeviceRobustness2FeaturesEXT(VkPhysicalDeviceRobustness2FeaturesEXT obj,const std::string & s,bool commaNeeded=true)43636 static void print_VkPhysicalDeviceRobustness2FeaturesEXT(VkPhysicalDeviceRobustness2FeaturesEXT obj,
43637                                                          const std::string &s, bool commaNeeded = true)
43638 {
43639     PRINT_SPACE
43640     _OUT << "{" << std::endl;
43641     INDENT(4);
43642 
43643     print_VkStructureType(obj.sType, "sType", 1);
43644 
43645     if (obj.pNext)
43646     {
43647         dumpPNextChain(obj.pNext);
43648     }
43649     else
43650     {
43651         PRINT_SPACE
43652         _OUT << "\"pNext\":"
43653              << "\"NULL\""
43654              << "," << std::endl;
43655     }
43656 
43657     print_VkBool32(obj.robustBufferAccess2, "robustBufferAccess2", 1);
43658 
43659     print_VkBool32(obj.robustImageAccess2, "robustImageAccess2", 1);
43660 
43661     print_VkBool32(obj.nullDescriptor, "nullDescriptor", 0);
43662 
43663     INDENT(-4);
43664     PRINT_SPACE
43665     if (commaNeeded)
43666         _OUT << "}," << std::endl;
43667     else
43668         _OUT << "}" << std::endl;
43669 }
print_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT * obj,const std::string & s,bool commaNeeded=true)43670 static void print_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT *obj,
43671                                                          const std::string &s, bool commaNeeded = true)
43672 {
43673     PRINT_SPACE
43674     _OUT << "{" << std::endl;
43675     INDENT(4);
43676 
43677     print_VkStructureType(obj->sType, "sType", 1);
43678 
43679     if (obj->pNext)
43680     {
43681         dumpPNextChain(obj->pNext);
43682     }
43683     else
43684     {
43685         PRINT_SPACE
43686         _OUT << "\"pNext\":"
43687              << "\"NULL\""
43688              << "," << std::endl;
43689     }
43690 
43691     print_VkBool32(obj->robustBufferAccess2, "robustBufferAccess2", 1);
43692 
43693     print_VkBool32(obj->robustImageAccess2, "robustImageAccess2", 1);
43694 
43695     print_VkBool32(obj->nullDescriptor, "nullDescriptor", 0);
43696 
43697     INDENT(-4);
43698     PRINT_SPACE
43699     if (commaNeeded)
43700         _OUT << "}," << std::endl;
43701     else
43702         _OUT << "}" << std::endl;
43703 }
43704 
print_VkPhysicalDeviceRobustness2PropertiesEXT(VkPhysicalDeviceRobustness2PropertiesEXT obj,const std::string & s,bool commaNeeded=true)43705 static void print_VkPhysicalDeviceRobustness2PropertiesEXT(VkPhysicalDeviceRobustness2PropertiesEXT obj,
43706                                                            const std::string &s, bool commaNeeded = true)
43707 {
43708     PRINT_SPACE
43709     _OUT << "{" << std::endl;
43710     INDENT(4);
43711 
43712     print_VkStructureType(obj.sType, "sType", 1);
43713 
43714     if (obj.pNext)
43715     {
43716         dumpPNextChain(obj.pNext);
43717     }
43718     else
43719     {
43720         PRINT_SPACE
43721         _OUT << "\"pNext\":"
43722              << "\"NULL\""
43723              << "," << std::endl;
43724     }
43725 
43726     print_VkDeviceSize(obj.robustStorageBufferAccessSizeAlignment, "robustStorageBufferAccessSizeAlignment", 1);
43727 
43728     print_VkDeviceSize(obj.robustUniformBufferAccessSizeAlignment, "robustUniformBufferAccessSizeAlignment", 0);
43729 
43730     INDENT(-4);
43731     PRINT_SPACE
43732     if (commaNeeded)
43733         _OUT << "}," << std::endl;
43734     else
43735         _OUT << "}" << std::endl;
43736 }
print_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT * obj,const std::string & s,bool commaNeeded=true)43737 static void print_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT *obj,
43738                                                            const std::string &s, bool commaNeeded = true)
43739 {
43740     PRINT_SPACE
43741     _OUT << "{" << std::endl;
43742     INDENT(4);
43743 
43744     print_VkStructureType(obj->sType, "sType", 1);
43745 
43746     if (obj->pNext)
43747     {
43748         dumpPNextChain(obj->pNext);
43749     }
43750     else
43751     {
43752         PRINT_SPACE
43753         _OUT << "\"pNext\":"
43754              << "\"NULL\""
43755              << "," << std::endl;
43756     }
43757 
43758     print_VkDeviceSize(obj->robustStorageBufferAccessSizeAlignment, "robustStorageBufferAccessSizeAlignment", 1);
43759 
43760     print_VkDeviceSize(obj->robustUniformBufferAccessSizeAlignment, "robustUniformBufferAccessSizeAlignment", 0);
43761 
43762     INDENT(-4);
43763     PRINT_SPACE
43764     if (commaNeeded)
43765         _OUT << "}," << std::endl;
43766     else
43767         _OUT << "}" << std::endl;
43768 }
43769 
print_VkSamplerCustomBorderColorCreateInfoEXT(VkSamplerCustomBorderColorCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)43770 static void print_VkSamplerCustomBorderColorCreateInfoEXT(VkSamplerCustomBorderColorCreateInfoEXT obj,
43771                                                           const std::string &s, bool commaNeeded = true)
43772 {
43773     PRINT_SPACE
43774     _OUT << "{" << std::endl;
43775     INDENT(4);
43776 
43777     print_VkStructureType(obj.sType, "sType", 1);
43778 
43779     if (obj.pNext)
43780     {
43781         dumpPNextChain(obj.pNext);
43782     }
43783     else
43784     {
43785         PRINT_SPACE
43786         _OUT << "\"pNext\":"
43787              << "\"NULL\""
43788              << "," << std::endl;
43789     }
43790 
43791     print_VkClearColorValue(obj.customBorderColor, "customBorderColor", 1);
43792 
43793     print_VkFormat(obj.format, "format", 0);
43794 
43795     INDENT(-4);
43796     PRINT_SPACE
43797     if (commaNeeded)
43798         _OUT << "}," << std::endl;
43799     else
43800         _OUT << "}" << std::endl;
43801 }
print_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)43802 static void print_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT *obj,
43803                                                           const std::string &s, bool commaNeeded = true)
43804 {
43805     PRINT_SPACE
43806     _OUT << "{" << std::endl;
43807     INDENT(4);
43808 
43809     print_VkStructureType(obj->sType, "sType", 1);
43810 
43811     if (obj->pNext)
43812     {
43813         dumpPNextChain(obj->pNext);
43814     }
43815     else
43816     {
43817         PRINT_SPACE
43818         _OUT << "\"pNext\":"
43819              << "\"NULL\""
43820              << "," << std::endl;
43821     }
43822 
43823     print_VkClearColorValue(obj->customBorderColor, "customBorderColor", 1);
43824 
43825     print_VkFormat(obj->format, "format", 0);
43826 
43827     INDENT(-4);
43828     PRINT_SPACE
43829     if (commaNeeded)
43830         _OUT << "}," << std::endl;
43831     else
43832         _OUT << "}" << std::endl;
43833 }
43834 
print_VkPhysicalDeviceCustomBorderColorPropertiesEXT(VkPhysicalDeviceCustomBorderColorPropertiesEXT obj,const std::string & s,bool commaNeeded=true)43835 static void print_VkPhysicalDeviceCustomBorderColorPropertiesEXT(VkPhysicalDeviceCustomBorderColorPropertiesEXT obj,
43836                                                                  const std::string &s, bool commaNeeded = true)
43837 {
43838     PRINT_SPACE
43839     _OUT << "{" << std::endl;
43840     INDENT(4);
43841 
43842     print_VkStructureType(obj.sType, "sType", 1);
43843 
43844     if (obj.pNext)
43845     {
43846         dumpPNextChain(obj.pNext);
43847     }
43848     else
43849     {
43850         PRINT_SPACE
43851         _OUT << "\"pNext\":"
43852              << "\"NULL\""
43853              << "," << std::endl;
43854     }
43855 
43856     print_uint32_t(obj.maxCustomBorderColorSamplers, "maxCustomBorderColorSamplers", 0);
43857 
43858     INDENT(-4);
43859     PRINT_SPACE
43860     if (commaNeeded)
43861         _OUT << "}," << std::endl;
43862     else
43863         _OUT << "}" << std::endl;
43864 }
print_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT * obj,const std::string & s,bool commaNeeded=true)43865 static void print_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
43866     const VkPhysicalDeviceCustomBorderColorPropertiesEXT *obj, const std::string &s, bool commaNeeded = true)
43867 {
43868     PRINT_SPACE
43869     _OUT << "{" << std::endl;
43870     INDENT(4);
43871 
43872     print_VkStructureType(obj->sType, "sType", 1);
43873 
43874     if (obj->pNext)
43875     {
43876         dumpPNextChain(obj->pNext);
43877     }
43878     else
43879     {
43880         PRINT_SPACE
43881         _OUT << "\"pNext\":"
43882              << "\"NULL\""
43883              << "," << std::endl;
43884     }
43885 
43886     print_uint32_t(obj->maxCustomBorderColorSamplers, "maxCustomBorderColorSamplers", 0);
43887 
43888     INDENT(-4);
43889     PRINT_SPACE
43890     if (commaNeeded)
43891         _OUT << "}," << std::endl;
43892     else
43893         _OUT << "}" << std::endl;
43894 }
43895 
print_VkPhysicalDeviceCustomBorderColorFeaturesEXT(VkPhysicalDeviceCustomBorderColorFeaturesEXT obj,const std::string & s,bool commaNeeded=true)43896 static void print_VkPhysicalDeviceCustomBorderColorFeaturesEXT(VkPhysicalDeviceCustomBorderColorFeaturesEXT obj,
43897                                                                const std::string &s, bool commaNeeded = true)
43898 {
43899     PRINT_SPACE
43900     _OUT << "{" << std::endl;
43901     INDENT(4);
43902 
43903     print_VkStructureType(obj.sType, "sType", 1);
43904 
43905     if (obj.pNext)
43906     {
43907         dumpPNextChain(obj.pNext);
43908     }
43909     else
43910     {
43911         PRINT_SPACE
43912         _OUT << "\"pNext\":"
43913              << "\"NULL\""
43914              << "," << std::endl;
43915     }
43916 
43917     print_VkBool32(obj.customBorderColors, "customBorderColors", 1);
43918 
43919     print_VkBool32(obj.customBorderColorWithoutFormat, "customBorderColorWithoutFormat", 0);
43920 
43921     INDENT(-4);
43922     PRINT_SPACE
43923     if (commaNeeded)
43924         _OUT << "}," << std::endl;
43925     else
43926         _OUT << "}" << std::endl;
43927 }
print_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)43928 static void print_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT *obj,
43929                                                                const std::string &s, bool commaNeeded = true)
43930 {
43931     PRINT_SPACE
43932     _OUT << "{" << std::endl;
43933     INDENT(4);
43934 
43935     print_VkStructureType(obj->sType, "sType", 1);
43936 
43937     if (obj->pNext)
43938     {
43939         dumpPNextChain(obj->pNext);
43940     }
43941     else
43942     {
43943         PRINT_SPACE
43944         _OUT << "\"pNext\":"
43945              << "\"NULL\""
43946              << "," << std::endl;
43947     }
43948 
43949     print_VkBool32(obj->customBorderColors, "customBorderColors", 1);
43950 
43951     print_VkBool32(obj->customBorderColorWithoutFormat, "customBorderColorWithoutFormat", 0);
43952 
43953     INDENT(-4);
43954     PRINT_SPACE
43955     if (commaNeeded)
43956         _OUT << "}," << std::endl;
43957     else
43958         _OUT << "}" << std::endl;
43959 }
43960 
print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT obj,const std::string & s,bool commaNeeded=true)43961 static void print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT obj,
43962                                                                    const std::string &s, bool commaNeeded = true)
43963 {
43964     PRINT_SPACE
43965     _OUT << "{" << std::endl;
43966     INDENT(4);
43967 
43968     print_VkStructureType(obj.sType, "sType", 1);
43969 
43970     if (obj.pNext)
43971     {
43972         dumpPNextChain(obj.pNext);
43973     }
43974     else
43975     {
43976         PRINT_SPACE
43977         _OUT << "\"pNext\":"
43978              << "\"NULL\""
43979              << "," << std::endl;
43980     }
43981 
43982     print_VkBool32(obj.ycbcr2plane444Formats, "ycbcr2plane444Formats", 0);
43983 
43984     INDENT(-4);
43985     PRINT_SPACE
43986     if (commaNeeded)
43987         _OUT << "}," << std::endl;
43988     else
43989         _OUT << "}" << std::endl;
43990 }
print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)43991 static void print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
43992     const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *obj, const std::string &s, bool commaNeeded = true)
43993 {
43994     PRINT_SPACE
43995     _OUT << "{" << std::endl;
43996     INDENT(4);
43997 
43998     print_VkStructureType(obj->sType, "sType", 1);
43999 
44000     if (obj->pNext)
44001     {
44002         dumpPNextChain(obj->pNext);
44003     }
44004     else
44005     {
44006         PRINT_SPACE
44007         _OUT << "\"pNext\":"
44008              << "\"NULL\""
44009              << "," << std::endl;
44010     }
44011 
44012     print_VkBool32(obj->ycbcr2plane444Formats, "ycbcr2plane444Formats", 0);
44013 
44014     INDENT(-4);
44015     PRINT_SPACE
44016     if (commaNeeded)
44017         _OUT << "}," << std::endl;
44018     else
44019         _OUT << "}" << std::endl;
44020 }
44021 
print_VkPhysicalDeviceImageRobustnessFeaturesEXT(VkPhysicalDeviceImageRobustnessFeaturesEXT obj,const std::string & s,bool commaNeeded=true)44022 static void print_VkPhysicalDeviceImageRobustnessFeaturesEXT(VkPhysicalDeviceImageRobustnessFeaturesEXT obj,
44023                                                              const std::string &s, bool commaNeeded = true)
44024 {
44025     PRINT_SPACE
44026     _OUT << "{" << std::endl;
44027     INDENT(4);
44028 
44029     print_VkStructureType(obj.sType, "sType", 1);
44030 
44031     if (obj.pNext)
44032     {
44033         dumpPNextChain(obj.pNext);
44034     }
44035     else
44036     {
44037         PRINT_SPACE
44038         _OUT << "\"pNext\":"
44039              << "\"NULL\""
44040              << "," << std::endl;
44041     }
44042 
44043     print_VkBool32(obj.robustImageAccess, "robustImageAccess", 0);
44044 
44045     INDENT(-4);
44046     PRINT_SPACE
44047     if (commaNeeded)
44048         _OUT << "}," << std::endl;
44049     else
44050         _OUT << "}" << std::endl;
44051 }
print_VkPhysicalDeviceImageRobustnessFeaturesEXT(const VkPhysicalDeviceImageRobustnessFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)44052 static void print_VkPhysicalDeviceImageRobustnessFeaturesEXT(const VkPhysicalDeviceImageRobustnessFeaturesEXT *obj,
44053                                                              const std::string &s, bool commaNeeded = true)
44054 {
44055     PRINT_SPACE
44056     _OUT << "{" << std::endl;
44057     INDENT(4);
44058 
44059     print_VkStructureType(obj->sType, "sType", 1);
44060 
44061     if (obj->pNext)
44062     {
44063         dumpPNextChain(obj->pNext);
44064     }
44065     else
44066     {
44067         PRINT_SPACE
44068         _OUT << "\"pNext\":"
44069              << "\"NULL\""
44070              << "," << std::endl;
44071     }
44072 
44073     print_VkBool32(obj->robustImageAccess, "robustImageAccess", 0);
44074 
44075     INDENT(-4);
44076     PRINT_SPACE
44077     if (commaNeeded)
44078         _OUT << "}," << std::endl;
44079     else
44080         _OUT << "}" << std::endl;
44081 }
44082 
print_VkPhysicalDevice4444FormatsFeaturesEXT(VkPhysicalDevice4444FormatsFeaturesEXT obj,const std::string & s,bool commaNeeded=true)44083 static void print_VkPhysicalDevice4444FormatsFeaturesEXT(VkPhysicalDevice4444FormatsFeaturesEXT obj,
44084                                                          const std::string &s, bool commaNeeded = true)
44085 {
44086     PRINT_SPACE
44087     _OUT << "{" << std::endl;
44088     INDENT(4);
44089 
44090     print_VkStructureType(obj.sType, "sType", 1);
44091 
44092     if (obj.pNext)
44093     {
44094         dumpPNextChain(obj.pNext);
44095     }
44096     else
44097     {
44098         PRINT_SPACE
44099         _OUT << "\"pNext\":"
44100              << "\"NULL\""
44101              << "," << std::endl;
44102     }
44103 
44104     print_VkBool32(obj.formatA4R4G4B4, "formatA4R4G4B4", 1);
44105 
44106     print_VkBool32(obj.formatA4B4G4R4, "formatA4B4G4R4", 0);
44107 
44108     INDENT(-4);
44109     PRINT_SPACE
44110     if (commaNeeded)
44111         _OUT << "}," << std::endl;
44112     else
44113         _OUT << "}" << std::endl;
44114 }
print_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)44115 static void print_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT *obj,
44116                                                          const std::string &s, bool commaNeeded = true)
44117 {
44118     PRINT_SPACE
44119     _OUT << "{" << std::endl;
44120     INDENT(4);
44121 
44122     print_VkStructureType(obj->sType, "sType", 1);
44123 
44124     if (obj->pNext)
44125     {
44126         dumpPNextChain(obj->pNext);
44127     }
44128     else
44129     {
44130         PRINT_SPACE
44131         _OUT << "\"pNext\":"
44132              << "\"NULL\""
44133              << "," << std::endl;
44134     }
44135 
44136     print_VkBool32(obj->formatA4R4G4B4, "formatA4R4G4B4", 1);
44137 
44138     print_VkBool32(obj->formatA4B4G4R4, "formatA4B4G4R4", 0);
44139 
44140     INDENT(-4);
44141     PRINT_SPACE
44142     if (commaNeeded)
44143         _OUT << "}," << std::endl;
44144     else
44145         _OUT << "}" << std::endl;
44146 }
44147 
print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT obj,const std::string & s,bool commaNeeded=true)44148 static void print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
44149     VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT obj, const std::string &s, bool commaNeeded = true)
44150 {
44151     PRINT_SPACE
44152     _OUT << "{" << std::endl;
44153     INDENT(4);
44154 
44155     print_VkStructureType(obj.sType, "sType", 1);
44156 
44157     if (obj.pNext)
44158     {
44159         dumpPNextChain(obj.pNext);
44160     }
44161     else
44162     {
44163         PRINT_SPACE
44164         _OUT << "\"pNext\":"
44165              << "\"NULL\""
44166              << "," << std::endl;
44167     }
44168 
44169     print_VkBool32(obj.vertexInputDynamicState, "vertexInputDynamicState", 0);
44170 
44171     INDENT(-4);
44172     PRINT_SPACE
44173     if (commaNeeded)
44174         _OUT << "}," << std::endl;
44175     else
44176         _OUT << "}" << std::endl;
44177 }
print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)44178 static void print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
44179     const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *obj, const std::string &s, bool commaNeeded = true)
44180 {
44181     PRINT_SPACE
44182     _OUT << "{" << std::endl;
44183     INDENT(4);
44184 
44185     print_VkStructureType(obj->sType, "sType", 1);
44186 
44187     if (obj->pNext)
44188     {
44189         dumpPNextChain(obj->pNext);
44190     }
44191     else
44192     {
44193         PRINT_SPACE
44194         _OUT << "\"pNext\":"
44195              << "\"NULL\""
44196              << "," << std::endl;
44197     }
44198 
44199     print_VkBool32(obj->vertexInputDynamicState, "vertexInputDynamicState", 0);
44200 
44201     INDENT(-4);
44202     PRINT_SPACE
44203     if (commaNeeded)
44204         _OUT << "}," << std::endl;
44205     else
44206         _OUT << "}" << std::endl;
44207 }
44208 
print_VkVertexInputBindingDescription2EXT(VkVertexInputBindingDescription2EXT obj,const std::string & s,bool commaNeeded=true)44209 static void print_VkVertexInputBindingDescription2EXT(VkVertexInputBindingDescription2EXT obj, const std::string &s,
44210                                                       bool commaNeeded = true)
44211 {
44212     PRINT_SPACE
44213     _OUT << "{" << std::endl;
44214     INDENT(4);
44215 
44216     print_VkStructureType(obj.sType, "sType", 1);
44217 
44218     if (obj.pNext)
44219     {
44220         dumpPNextChain(obj.pNext);
44221     }
44222     else
44223     {
44224         PRINT_SPACE
44225         _OUT << "\"pNext\":"
44226              << "\"NULL\""
44227              << "," << std::endl;
44228     }
44229 
44230     print_uint32_t(obj.binding, "binding", 1);
44231 
44232     print_uint32_t(obj.stride, "stride", 1);
44233 
44234     print_VkVertexInputRate(obj.inputRate, "inputRate", 1);
44235 
44236     print_uint32_t(obj.divisor, "divisor", 0);
44237 
44238     INDENT(-4);
44239     PRINT_SPACE
44240     if (commaNeeded)
44241         _OUT << "}," << std::endl;
44242     else
44243         _OUT << "}" << std::endl;
44244 }
print_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT * obj,const std::string & s,bool commaNeeded=true)44245 static void print_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT *obj,
44246                                                       const std::string &s, bool commaNeeded = true)
44247 {
44248     PRINT_SPACE
44249     _OUT << "{" << std::endl;
44250     INDENT(4);
44251 
44252     print_VkStructureType(obj->sType, "sType", 1);
44253 
44254     if (obj->pNext)
44255     {
44256         dumpPNextChain(obj->pNext);
44257     }
44258     else
44259     {
44260         PRINT_SPACE
44261         _OUT << "\"pNext\":"
44262              << "\"NULL\""
44263              << "," << std::endl;
44264     }
44265 
44266     print_uint32_t(obj->binding, "binding", 1);
44267 
44268     print_uint32_t(obj->stride, "stride", 1);
44269 
44270     print_VkVertexInputRate(obj->inputRate, "inputRate", 1);
44271 
44272     print_uint32_t(obj->divisor, "divisor", 0);
44273 
44274     INDENT(-4);
44275     PRINT_SPACE
44276     if (commaNeeded)
44277         _OUT << "}," << std::endl;
44278     else
44279         _OUT << "}" << std::endl;
44280 }
44281 
print_VkVertexInputAttributeDescription2EXT(VkVertexInputAttributeDescription2EXT obj,const std::string & s,bool commaNeeded=true)44282 static void print_VkVertexInputAttributeDescription2EXT(VkVertexInputAttributeDescription2EXT obj, const std::string &s,
44283                                                         bool commaNeeded = true)
44284 {
44285     PRINT_SPACE
44286     _OUT << "{" << std::endl;
44287     INDENT(4);
44288 
44289     print_VkStructureType(obj.sType, "sType", 1);
44290 
44291     if (obj.pNext)
44292     {
44293         dumpPNextChain(obj.pNext);
44294     }
44295     else
44296     {
44297         PRINT_SPACE
44298         _OUT << "\"pNext\":"
44299              << "\"NULL\""
44300              << "," << std::endl;
44301     }
44302 
44303     print_uint32_t(obj.location, "location", 1);
44304 
44305     print_uint32_t(obj.binding, "binding", 1);
44306 
44307     print_VkFormat(obj.format, "format", 1);
44308 
44309     print_uint32_t(obj.offset, "offset", 0);
44310 
44311     INDENT(-4);
44312     PRINT_SPACE
44313     if (commaNeeded)
44314         _OUT << "}," << std::endl;
44315     else
44316         _OUT << "}" << std::endl;
44317 }
print_VkVertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT * obj,const std::string & s,bool commaNeeded=true)44318 static void print_VkVertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT *obj,
44319                                                         const std::string &s, bool commaNeeded = true)
44320 {
44321     PRINT_SPACE
44322     _OUT << "{" << std::endl;
44323     INDENT(4);
44324 
44325     print_VkStructureType(obj->sType, "sType", 1);
44326 
44327     if (obj->pNext)
44328     {
44329         dumpPNextChain(obj->pNext);
44330     }
44331     else
44332     {
44333         PRINT_SPACE
44334         _OUT << "\"pNext\":"
44335              << "\"NULL\""
44336              << "," << std::endl;
44337     }
44338 
44339     print_uint32_t(obj->location, "location", 1);
44340 
44341     print_uint32_t(obj->binding, "binding", 1);
44342 
44343     print_VkFormat(obj->format, "format", 1);
44344 
44345     print_uint32_t(obj->offset, "offset", 0);
44346 
44347     INDENT(-4);
44348     PRINT_SPACE
44349     if (commaNeeded)
44350         _OUT << "}," << std::endl;
44351     else
44352         _OUT << "}" << std::endl;
44353 }
44354 
print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT obj,const std::string & s,bool commaNeeded=true)44355 static void print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT obj,
44356                                                                    const std::string &s, bool commaNeeded = true)
44357 {
44358     PRINT_SPACE
44359     _OUT << "{" << std::endl;
44360     INDENT(4);
44361 
44362     print_VkStructureType(obj.sType, "sType", 1);
44363 
44364     if (obj.pNext)
44365     {
44366         dumpPNextChain(obj.pNext);
44367     }
44368     else
44369     {
44370         PRINT_SPACE
44371         _OUT << "\"pNext\":"
44372              << "\"NULL\""
44373              << "," << std::endl;
44374     }
44375 
44376     print_VkBool32(obj.extendedDynamicState2, "extendedDynamicState2", 1);
44377 
44378     print_VkBool32(obj.extendedDynamicState2LogicOp, "extendedDynamicState2LogicOp", 1);
44379 
44380     print_VkBool32(obj.extendedDynamicState2PatchControlPoints, "extendedDynamicState2PatchControlPoints", 0);
44381 
44382     INDENT(-4);
44383     PRINT_SPACE
44384     if (commaNeeded)
44385         _OUT << "}," << std::endl;
44386     else
44387         _OUT << "}" << std::endl;
44388 }
print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * obj,const std::string & s,bool commaNeeded=true)44389 static void print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
44390     const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *obj, const std::string &s, bool commaNeeded = true)
44391 {
44392     PRINT_SPACE
44393     _OUT << "{" << std::endl;
44394     INDENT(4);
44395 
44396     print_VkStructureType(obj->sType, "sType", 1);
44397 
44398     if (obj->pNext)
44399     {
44400         dumpPNextChain(obj->pNext);
44401     }
44402     else
44403     {
44404         PRINT_SPACE
44405         _OUT << "\"pNext\":"
44406              << "\"NULL\""
44407              << "," << std::endl;
44408     }
44409 
44410     print_VkBool32(obj->extendedDynamicState2, "extendedDynamicState2", 1);
44411 
44412     print_VkBool32(obj->extendedDynamicState2LogicOp, "extendedDynamicState2LogicOp", 1);
44413 
44414     print_VkBool32(obj->extendedDynamicState2PatchControlPoints, "extendedDynamicState2PatchControlPoints", 0);
44415 
44416     INDENT(-4);
44417     PRINT_SPACE
44418     if (commaNeeded)
44419         _OUT << "}," << std::endl;
44420     else
44421         _OUT << "}" << std::endl;
44422 }
44423 
print_VkPhysicalDeviceColorWriteEnableFeaturesEXT(VkPhysicalDeviceColorWriteEnableFeaturesEXT obj,const std::string & s,bool commaNeeded=true)44424 static void print_VkPhysicalDeviceColorWriteEnableFeaturesEXT(VkPhysicalDeviceColorWriteEnableFeaturesEXT obj,
44425                                                               const std::string &s, bool commaNeeded = true)
44426 {
44427     PRINT_SPACE
44428     _OUT << "{" << std::endl;
44429     INDENT(4);
44430 
44431     print_VkStructureType(obj.sType, "sType", 1);
44432 
44433     if (obj.pNext)
44434     {
44435         dumpPNextChain(obj.pNext);
44436     }
44437     else
44438     {
44439         PRINT_SPACE
44440         _OUT << "\"pNext\":"
44441              << "\"NULL\""
44442              << "," << std::endl;
44443     }
44444 
44445     print_VkBool32(obj.colorWriteEnable, "colorWriteEnable", 0);
44446 
44447     INDENT(-4);
44448     PRINT_SPACE
44449     if (commaNeeded)
44450         _OUT << "}," << std::endl;
44451     else
44452         _OUT << "}" << std::endl;
44453 }
print_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT * obj,const std::string & s,bool commaNeeded=true)44454 static void print_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT *obj,
44455                                                               const std::string &s, bool commaNeeded = true)
44456 {
44457     PRINT_SPACE
44458     _OUT << "{" << std::endl;
44459     INDENT(4);
44460 
44461     print_VkStructureType(obj->sType, "sType", 1);
44462 
44463     if (obj->pNext)
44464     {
44465         dumpPNextChain(obj->pNext);
44466     }
44467     else
44468     {
44469         PRINT_SPACE
44470         _OUT << "\"pNext\":"
44471              << "\"NULL\""
44472              << "," << std::endl;
44473     }
44474 
44475     print_VkBool32(obj->colorWriteEnable, "colorWriteEnable", 0);
44476 
44477     INDENT(-4);
44478     PRINT_SPACE
44479     if (commaNeeded)
44480         _OUT << "}," << std::endl;
44481     else
44482         _OUT << "}" << std::endl;
44483 }
44484 
print_VkPipelineColorWriteCreateInfoEXT(VkPipelineColorWriteCreateInfoEXT obj,const std::string & s,bool commaNeeded=true)44485 static void print_VkPipelineColorWriteCreateInfoEXT(VkPipelineColorWriteCreateInfoEXT obj, const std::string &s,
44486                                                     bool commaNeeded = true)
44487 {
44488     PRINT_SPACE
44489     _OUT << "{" << std::endl;
44490     INDENT(4);
44491 
44492     print_VkStructureType(obj.sType, "sType", 1);
44493 
44494     if (obj.pNext)
44495     {
44496         dumpPNextChain(obj.pNext);
44497     }
44498     else
44499     {
44500         PRINT_SPACE
44501         _OUT << "\"pNext\":"
44502              << "\"NULL\""
44503              << "," << std::endl;
44504     }
44505 
44506     print_uint32_t(obj.attachmentCount, "attachmentCount", 1);
44507 
44508     PRINT_SPACE
44509     _OUT << "\"pColorWriteEnables\":" << std::endl;
44510     PRINT_SPACE
44511     if (obj.pColorWriteEnables)
44512     {
44513         _OUT << "[" << std::endl;
44514         for (unsigned int i = 0; i < obj.attachmentCount; i++)
44515         {
44516             bool isCommaNeeded = (i + 1) != obj.attachmentCount;
44517             print_VkBool32(obj.pColorWriteEnables[i], "", isCommaNeeded);
44518         }
44519         PRINT_SPACE
44520         _OUT << "]"
44521              << "" << std::endl;
44522     }
44523     else
44524     {
44525         _OUT << "\"NULL\""
44526              << "" << std::endl;
44527     }
44528 
44529     INDENT(-4);
44530     PRINT_SPACE
44531     if (commaNeeded)
44532         _OUT << "}," << std::endl;
44533     else
44534         _OUT << "}" << std::endl;
44535 }
print_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT * obj,const std::string & s,bool commaNeeded=true)44536 static void print_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT *obj, const std::string &s,
44537                                                     bool commaNeeded = true)
44538 {
44539     PRINT_SPACE
44540     _OUT << "{" << std::endl;
44541     INDENT(4);
44542 
44543     print_VkStructureType(obj->sType, "sType", 1);
44544 
44545     if (obj->pNext)
44546     {
44547         dumpPNextChain(obj->pNext);
44548     }
44549     else
44550     {
44551         PRINT_SPACE
44552         _OUT << "\"pNext\":"
44553              << "\"NULL\""
44554              << "," << std::endl;
44555     }
44556 
44557     print_uint32_t(obj->attachmentCount, "attachmentCount", 1);
44558 
44559     PRINT_SPACE
44560     _OUT << "\"pColorWriteEnables\":" << std::endl;
44561     PRINT_SPACE
44562     if (obj->pColorWriteEnables)
44563     {
44564         _OUT << "[" << std::endl;
44565         for (unsigned int i = 0; i < obj->attachmentCount; i++)
44566         {
44567             bool isCommaNeeded = (i + 1) != obj->attachmentCount;
44568             print_VkBool32(obj->pColorWriteEnables[i], "", isCommaNeeded);
44569         }
44570         PRINT_SPACE
44571         _OUT << "]"
44572              << "" << std::endl;
44573     }
44574     else
44575     {
44576         _OUT << "\"NULL\""
44577              << "" << std::endl;
44578     }
44579 
44580     INDENT(-4);
44581     PRINT_SPACE
44582     if (commaNeeded)
44583         _OUT << "}," << std::endl;
44584     else
44585         _OUT << "}" << std::endl;
44586 }
44587 
print_VkApplicationParametersEXT(VkApplicationParametersEXT obj,const std::string & s,bool commaNeeded=true)44588 static void print_VkApplicationParametersEXT(VkApplicationParametersEXT obj, const std::string &s,
44589                                              bool commaNeeded = true)
44590 {
44591     PRINT_SPACE
44592     _OUT << "{" << std::endl;
44593     INDENT(4);
44594 
44595     print_VkStructureType(obj.sType, "sType", 1);
44596 
44597     if (obj.pNext)
44598     {
44599         dumpPNextChain(obj.pNext);
44600     }
44601     else
44602     {
44603         PRINT_SPACE
44604         _OUT << "\"pNext\":"
44605              << "\"NULL\""
44606              << "," << std::endl;
44607     }
44608 
44609     print_uint32_t(obj.vendorID, "vendorID", 1);
44610 
44611     print_uint32_t(obj.deviceID, "deviceID", 1);
44612 
44613     print_uint32_t(obj.key, "key", 1);
44614 
44615     print_uint64_t(obj.value, "value", 0);
44616 
44617     INDENT(-4);
44618     PRINT_SPACE
44619     if (commaNeeded)
44620         _OUT << "}," << std::endl;
44621     else
44622         _OUT << "}" << std::endl;
44623 }
print_VkApplicationParametersEXT(const VkApplicationParametersEXT * obj,const std::string & s,bool commaNeeded=true)44624 static void print_VkApplicationParametersEXT(const VkApplicationParametersEXT *obj, const std::string &s,
44625                                              bool commaNeeded = true)
44626 {
44627     PRINT_SPACE
44628     _OUT << "{" << std::endl;
44629     INDENT(4);
44630 
44631     print_VkStructureType(obj->sType, "sType", 1);
44632 
44633     if (obj->pNext)
44634     {
44635         dumpPNextChain(obj->pNext);
44636     }
44637     else
44638     {
44639         PRINT_SPACE
44640         _OUT << "\"pNext\":"
44641              << "\"NULL\""
44642              << "," << std::endl;
44643     }
44644 
44645     print_uint32_t(obj->vendorID, "vendorID", 1);
44646 
44647     print_uint32_t(obj->deviceID, "deviceID", 1);
44648 
44649     print_uint32_t(obj->key, "key", 1);
44650 
44651     print_uint64_t(obj->value, "value", 0);
44652 
44653     INDENT(-4);
44654     PRINT_SPACE
44655     if (commaNeeded)
44656         _OUT << "}," << std::endl;
44657     else
44658         _OUT << "}" << std::endl;
44659 }
44660 
44661 /*************************************** Begin prototypes ***********************************/
44662 /*************************************** End prototypes ***********************************/
44663 
dumpPNextChain(const void * pNext)44664 static void dumpPNextChain(const void *pNext)
44665 {
44666     VkBaseInStructure *pBase = (VkBaseInStructure *)pNext;
44667     if (pNext)
44668     {
44669         PRINT_SPACE
44670         _OUT << "\"pNext\":" << std::endl;
44671 
44672         switch (pBase->sType)
44673         {
44674         case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
44675             print_VkDisplayPresentInfoKHR((VkDisplayPresentInfoKHR *)pNext, "VkDisplayPresentInfoKHR", true);
44676             break;
44677         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
44678             print_VkValidationFeaturesEXT((VkValidationFeaturesEXT *)pNext, "VkValidationFeaturesEXT", true);
44679             break;
44680         case VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT:
44681             print_VkApplicationParametersEXT((VkApplicationParametersEXT *)pNext, "VkApplicationParametersEXT", true);
44682             break;
44683         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
44684             print_VkPhysicalDeviceFeatures2((VkPhysicalDeviceFeatures2 *)pNext, "VkPhysicalDeviceFeatures2", true);
44685             break;
44686         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
44687             print_VkPhysicalDeviceDriverProperties((VkPhysicalDeviceDriverProperties *)pNext,
44688                                                    "VkPhysicalDeviceDriverProperties", true);
44689             break;
44690         case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
44691             print_VkPresentRegionsKHR((VkPresentRegionsKHR *)pNext, "VkPresentRegionsKHR", true);
44692             break;
44693         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
44694             print_VkPhysicalDeviceVariablePointersFeatures((VkPhysicalDeviceVariablePointersFeatures *)pNext,
44695                                                            "VkPhysicalDeviceVariablePointersFeatures", true);
44696             break;
44697         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
44698             print_VkPhysicalDeviceExternalImageFormatInfo((VkPhysicalDeviceExternalImageFormatInfo *)pNext,
44699                                                           "VkPhysicalDeviceExternalImageFormatInfo", true);
44700             break;
44701         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
44702             print_VkExternalImageFormatProperties((VkExternalImageFormatProperties *)pNext,
44703                                                   "VkExternalImageFormatProperties", true);
44704             break;
44705         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
44706             print_VkPhysicalDeviceIDProperties((VkPhysicalDeviceIDProperties *)pNext, "VkPhysicalDeviceIDProperties",
44707                                                true);
44708             break;
44709         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
44710             print_VkExternalMemoryImageCreateInfo((VkExternalMemoryImageCreateInfo *)pNext,
44711                                                   "VkExternalMemoryImageCreateInfo", true);
44712             break;
44713         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
44714             print_VkExternalMemoryBufferCreateInfo((VkExternalMemoryBufferCreateInfo *)pNext,
44715                                                    "VkExternalMemoryBufferCreateInfo", true);
44716             break;
44717         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
44718             print_VkExportMemoryAllocateInfo((VkExportMemoryAllocateInfo *)pNext, "VkExportMemoryAllocateInfo", true);
44719             break;
44720         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
44721             print_VkImportMemoryFdInfoKHR((VkImportMemoryFdInfoKHR *)pNext, "VkImportMemoryFdInfoKHR", true);
44722             break;
44723         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
44724             print_VkExportSemaphoreCreateInfo((VkExportSemaphoreCreateInfo *)pNext, "VkExportSemaphoreCreateInfo",
44725                                               true);
44726             break;
44727         case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
44728             print_VkExportFenceCreateInfo((VkExportFenceCreateInfo *)pNext, "VkExportFenceCreateInfo", true);
44729             break;
44730         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
44731             print_VkPhysicalDeviceMultiviewFeatures((VkPhysicalDeviceMultiviewFeatures *)pNext,
44732                                                     "VkPhysicalDeviceMultiviewFeatures", true);
44733             break;
44734         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
44735             print_VkPhysicalDeviceMultiviewProperties((VkPhysicalDeviceMultiviewProperties *)pNext,
44736                                                       "VkPhysicalDeviceMultiviewProperties", true);
44737             break;
44738         case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
44739             print_VkRenderPassMultiviewCreateInfo((VkRenderPassMultiviewCreateInfo *)pNext,
44740                                                   "VkRenderPassMultiviewCreateInfo", true);
44741             break;
44742         case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
44743             print_VkSwapchainCounterCreateInfoEXT((VkSwapchainCounterCreateInfoEXT *)pNext,
44744                                                   "VkSwapchainCounterCreateInfoEXT", true);
44745             break;
44746         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
44747             print_VkMemoryAllocateFlagsInfo((VkMemoryAllocateFlagsInfo *)pNext, "VkMemoryAllocateFlagsInfo", true);
44748             break;
44749         case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
44750             print_VkBindBufferMemoryDeviceGroupInfo((VkBindBufferMemoryDeviceGroupInfo *)pNext,
44751                                                     "VkBindBufferMemoryDeviceGroupInfo", true);
44752             break;
44753         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
44754             print_VkBindImageMemoryDeviceGroupInfo((VkBindImageMemoryDeviceGroupInfo *)pNext,
44755                                                    "VkBindImageMemoryDeviceGroupInfo", true);
44756             break;
44757         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
44758             print_VkDeviceGroupRenderPassBeginInfo((VkDeviceGroupRenderPassBeginInfo *)pNext,
44759                                                    "VkDeviceGroupRenderPassBeginInfo", true);
44760             break;
44761         case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
44762             print_VkDeviceGroupCommandBufferBeginInfo((VkDeviceGroupCommandBufferBeginInfo *)pNext,
44763                                                       "VkDeviceGroupCommandBufferBeginInfo", true);
44764             break;
44765         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
44766             print_VkDeviceGroupSubmitInfo((VkDeviceGroupSubmitInfo *)pNext, "VkDeviceGroupSubmitInfo", true);
44767             break;
44768         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
44769             print_VkImageSwapchainCreateInfoKHR((VkImageSwapchainCreateInfoKHR *)pNext, "VkImageSwapchainCreateInfoKHR",
44770                                                 true);
44771             break;
44772         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
44773             print_VkBindImageMemorySwapchainInfoKHR((VkBindImageMemorySwapchainInfoKHR *)pNext,
44774                                                     "VkBindImageMemorySwapchainInfoKHR", true);
44775             break;
44776         case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
44777             print_VkDeviceGroupPresentInfoKHR((VkDeviceGroupPresentInfoKHR *)pNext, "VkDeviceGroupPresentInfoKHR",
44778                                               true);
44779             break;
44780         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
44781             print_VkDeviceGroupDeviceCreateInfo((VkDeviceGroupDeviceCreateInfo *)pNext, "VkDeviceGroupDeviceCreateInfo",
44782                                                 true);
44783             break;
44784         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
44785             print_VkDeviceGroupSwapchainCreateInfoKHR((VkDeviceGroupSwapchainCreateInfoKHR *)pNext,
44786                                                       "VkDeviceGroupSwapchainCreateInfoKHR", true);
44787             break;
44788         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
44789             print_VkPhysicalDeviceDiscardRectanglePropertiesEXT((VkPhysicalDeviceDiscardRectanglePropertiesEXT *)pNext,
44790                                                                 "VkPhysicalDeviceDiscardRectanglePropertiesEXT", true);
44791             break;
44792         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
44793             print_VkPipelineDiscardRectangleStateCreateInfoEXT((VkPipelineDiscardRectangleStateCreateInfoEXT *)pNext,
44794                                                                "VkPipelineDiscardRectangleStateCreateInfoEXT", true);
44795             break;
44796         case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
44797             print_VkRenderPassInputAttachmentAspectCreateInfo((VkRenderPassInputAttachmentAspectCreateInfo *)pNext,
44798                                                               "VkRenderPassInputAttachmentAspectCreateInfo", true);
44799             break;
44800         case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
44801             print_VkSharedPresentSurfaceCapabilitiesKHR((VkSharedPresentSurfaceCapabilitiesKHR *)pNext,
44802                                                         "VkSharedPresentSurfaceCapabilitiesKHR", true);
44803             break;
44804         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
44805             print_VkPhysicalDevice16BitStorageFeatures((VkPhysicalDevice16BitStorageFeatures *)pNext,
44806                                                        "VkPhysicalDevice16BitStorageFeatures", true);
44807             break;
44808         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
44809             print_VkPhysicalDeviceSubgroupProperties((VkPhysicalDeviceSubgroupProperties *)pNext,
44810                                                      "VkPhysicalDeviceSubgroupProperties", true);
44811             break;
44812         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
44813             print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
44814                 (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pNext,
44815                 "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures", true);
44816             break;
44817         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
44818             print_VkPhysicalDevicePointClippingProperties((VkPhysicalDevicePointClippingProperties *)pNext,
44819                                                           "VkPhysicalDevicePointClippingProperties", true);
44820             break;
44821         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
44822             print_VkMemoryDedicatedRequirements((VkMemoryDedicatedRequirements *)pNext, "VkMemoryDedicatedRequirements",
44823                                                 true);
44824             break;
44825         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
44826             print_VkMemoryDedicatedAllocateInfo((VkMemoryDedicatedAllocateInfo *)pNext, "VkMemoryDedicatedAllocateInfo",
44827                                                 true);
44828             break;
44829         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
44830             print_VkImageViewUsageCreateInfo((VkImageViewUsageCreateInfo *)pNext, "VkImageViewUsageCreateInfo", true);
44831             break;
44832         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
44833             print_VkPipelineTessellationDomainOriginStateCreateInfo(
44834                 (VkPipelineTessellationDomainOriginStateCreateInfo *)pNext,
44835                 "VkPipelineTessellationDomainOriginStateCreateInfo", true);
44836             break;
44837         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
44838             print_VkSamplerYcbcrConversionInfo((VkSamplerYcbcrConversionInfo *)pNext, "VkSamplerYcbcrConversionInfo",
44839                                                true);
44840             break;
44841         case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
44842             print_VkBindImagePlaneMemoryInfo((VkBindImagePlaneMemoryInfo *)pNext, "VkBindImagePlaneMemoryInfo", true);
44843             break;
44844         case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
44845             print_VkImagePlaneMemoryRequirementsInfo((VkImagePlaneMemoryRequirementsInfo *)pNext,
44846                                                      "VkImagePlaneMemoryRequirementsInfo", true);
44847             break;
44848         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
44849             print_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
44850                 (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pNext,
44851                 "VkPhysicalDeviceSamplerYcbcrConversionFeatures", true);
44852             break;
44853         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
44854             print_VkSamplerYcbcrConversionImageFormatProperties((VkSamplerYcbcrConversionImageFormatProperties *)pNext,
44855                                                                 "VkSamplerYcbcrConversionImageFormatProperties", true);
44856             break;
44857         case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
44858             print_VkProtectedSubmitInfo((VkProtectedSubmitInfo *)pNext, "VkProtectedSubmitInfo", true);
44859             break;
44860         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
44861             print_VkPhysicalDeviceProtectedMemoryFeatures((VkPhysicalDeviceProtectedMemoryFeatures *)pNext,
44862                                                           "VkPhysicalDeviceProtectedMemoryFeatures", true);
44863             break;
44864         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
44865             print_VkPhysicalDeviceProtectedMemoryProperties((VkPhysicalDeviceProtectedMemoryProperties *)pNext,
44866                                                             "VkPhysicalDeviceProtectedMemoryProperties", true);
44867             break;
44868         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
44869             print_VkPhysicalDeviceSamplerFilterMinmaxProperties((VkPhysicalDeviceSamplerFilterMinmaxProperties *)pNext,
44870                                                                 "VkPhysicalDeviceSamplerFilterMinmaxProperties", true);
44871             break;
44872         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
44873             print_VkSampleLocationsInfoEXT((VkSampleLocationsInfoEXT *)pNext, "VkSampleLocationsInfoEXT", true);
44874             break;
44875         case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
44876             print_VkRenderPassSampleLocationsBeginInfoEXT((VkRenderPassSampleLocationsBeginInfoEXT *)pNext,
44877                                                           "VkRenderPassSampleLocationsBeginInfoEXT", true);
44878             break;
44879         case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
44880             print_VkPipelineSampleLocationsStateCreateInfoEXT((VkPipelineSampleLocationsStateCreateInfoEXT *)pNext,
44881                                                               "VkPipelineSampleLocationsStateCreateInfoEXT", true);
44882             break;
44883         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
44884             print_VkPhysicalDeviceSampleLocationsPropertiesEXT((VkPhysicalDeviceSampleLocationsPropertiesEXT *)pNext,
44885                                                                "VkPhysicalDeviceSampleLocationsPropertiesEXT", true);
44886             break;
44887         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
44888             print_VkSamplerReductionModeCreateInfo((VkSamplerReductionModeCreateInfo *)pNext,
44889                                                    "VkSamplerReductionModeCreateInfo", true);
44890             break;
44891         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
44892             print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
44893                 (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)pNext,
44894                 "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT", true);
44895             break;
44896         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
44897             print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
44898                 (VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)pNext,
44899                 "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT", true);
44900             break;
44901         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
44902             print_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
44903                 (VkPipelineColorBlendAdvancedStateCreateInfoEXT *)pNext,
44904                 "VkPipelineColorBlendAdvancedStateCreateInfoEXT", true);
44905             break;
44906         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
44907             print_VkImageFormatListCreateInfo((VkImageFormatListCreateInfo *)pNext, "VkImageFormatListCreateInfo",
44908                                               true);
44909             break;
44910         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
44911             print_VkPhysicalDeviceMaintenance3Properties((VkPhysicalDeviceMaintenance3Properties *)pNext,
44912                                                          "VkPhysicalDeviceMaintenance3Properties", true);
44913             break;
44914         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
44915             print_VkPhysicalDeviceShaderDrawParametersFeatures((VkPhysicalDeviceShaderDrawParametersFeatures *)pNext,
44916                                                                "VkPhysicalDeviceShaderDrawParametersFeatures", true);
44917             break;
44918         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
44919             print_VkPhysicalDeviceShaderFloat16Int8Features((VkPhysicalDeviceShaderFloat16Int8Features *)pNext,
44920                                                             "VkPhysicalDeviceShaderFloat16Int8Features", true);
44921             break;
44922         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
44923             print_VkPhysicalDeviceFloatControlsProperties((VkPhysicalDeviceFloatControlsProperties *)pNext,
44924                                                           "VkPhysicalDeviceFloatControlsProperties", true);
44925             break;
44926         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
44927             print_VkPhysicalDeviceHostQueryResetFeatures((VkPhysicalDeviceHostQueryResetFeatures *)pNext,
44928                                                          "VkPhysicalDeviceHostQueryResetFeatures", true);
44929             break;
44930         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
44931             print_VkDeviceQueueGlobalPriorityCreateInfoEXT((VkDeviceQueueGlobalPriorityCreateInfoEXT *)pNext,
44932                                                            "VkDeviceQueueGlobalPriorityCreateInfoEXT", true);
44933             break;
44934         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
44935             print_VkDebugUtilsMessengerCreateInfoEXT((VkDebugUtilsMessengerCreateInfoEXT *)pNext,
44936                                                      "VkDebugUtilsMessengerCreateInfoEXT", true);
44937             break;
44938         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
44939             print_VkImportMemoryHostPointerInfoEXT((VkImportMemoryHostPointerInfoEXT *)pNext,
44940                                                    "VkImportMemoryHostPointerInfoEXT", true);
44941             break;
44942         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
44943             print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
44944                 (VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)pNext,
44945                 "VkPhysicalDeviceExternalMemoryHostPropertiesEXT", true);
44946             break;
44947         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
44948             print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
44949                 (VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)pNext,
44950                 "VkPhysicalDeviceConservativeRasterizationPropertiesEXT", true);
44951             break;
44952         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
44953             print_VkPipelineRasterizationConservativeStateCreateInfoEXT(
44954                 (VkPipelineRasterizationConservativeStateCreateInfoEXT *)pNext,
44955                 "VkPipelineRasterizationConservativeStateCreateInfoEXT", true);
44956             break;
44957         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
44958             print_VkPhysicalDeviceDescriptorIndexingFeatures((VkPhysicalDeviceDescriptorIndexingFeatures *)pNext,
44959                                                              "VkPhysicalDeviceDescriptorIndexingFeatures", true);
44960             break;
44961         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
44962             print_VkPhysicalDeviceDescriptorIndexingProperties((VkPhysicalDeviceDescriptorIndexingProperties *)pNext,
44963                                                                "VkPhysicalDeviceDescriptorIndexingProperties", true);
44964             break;
44965         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
44966             print_VkDescriptorSetLayoutBindingFlagsCreateInfo((VkDescriptorSetLayoutBindingFlagsCreateInfo *)pNext,
44967                                                               "VkDescriptorSetLayoutBindingFlagsCreateInfo", true);
44968             break;
44969         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
44970             print_VkDescriptorSetVariableDescriptorCountAllocateInfo(
44971                 (VkDescriptorSetVariableDescriptorCountAllocateInfo *)pNext,
44972                 "VkDescriptorSetVariableDescriptorCountAllocateInfo", true);
44973             break;
44974         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
44975             print_VkDescriptorSetVariableDescriptorCountLayoutSupport(
44976                 (VkDescriptorSetVariableDescriptorCountLayoutSupport *)pNext,
44977                 "VkDescriptorSetVariableDescriptorCountLayoutSupport", true);
44978             break;
44979         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
44980             print_VkPhysicalDeviceTimelineSemaphoreFeatures((VkPhysicalDeviceTimelineSemaphoreFeatures *)pNext,
44981                                                             "VkPhysicalDeviceTimelineSemaphoreFeatures", true);
44982             break;
44983         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
44984             print_VkPhysicalDeviceTimelineSemaphoreProperties((VkPhysicalDeviceTimelineSemaphoreProperties *)pNext,
44985                                                               "VkPhysicalDeviceTimelineSemaphoreProperties", true);
44986             break;
44987         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
44988             print_VkSemaphoreTypeCreateInfo((VkSemaphoreTypeCreateInfo *)pNext, "VkSemaphoreTypeCreateInfo", true);
44989             break;
44990         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
44991             print_VkTimelineSemaphoreSubmitInfo((VkTimelineSemaphoreSubmitInfo *)pNext, "VkTimelineSemaphoreSubmitInfo",
44992                                                 true);
44993             break;
44994         case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
44995             print_VkPipelineVertexInputDivisorStateCreateInfoEXT(
44996                 (VkPipelineVertexInputDivisorStateCreateInfoEXT *)pNext,
44997                 "VkPipelineVertexInputDivisorStateCreateInfoEXT", true);
44998             break;
44999         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
45000             print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
45001                 (VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)pNext,
45002                 "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT", true);
45003             break;
45004         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
45005             print_VkPhysicalDevicePCIBusInfoPropertiesEXT((VkPhysicalDevicePCIBusInfoPropertiesEXT *)pNext,
45006                                                           "VkPhysicalDevicePCIBusInfoPropertiesEXT", true);
45007             break;
45008         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
45009             print_VkPhysicalDevice8BitStorageFeatures((VkPhysicalDevice8BitStorageFeatures *)pNext,
45010                                                       "VkPhysicalDevice8BitStorageFeatures", true);
45011             break;
45012         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
45013             print_VkPhysicalDeviceVulkanMemoryModelFeatures((VkPhysicalDeviceVulkanMemoryModelFeatures *)pNext,
45014                                                             "VkPhysicalDeviceVulkanMemoryModelFeatures", true);
45015             break;
45016         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
45017             print_VkPhysicalDeviceShaderAtomicInt64Features((VkPhysicalDeviceShaderAtomicInt64Features *)pNext,
45018                                                             "VkPhysicalDeviceShaderAtomicInt64Features", true);
45019             break;
45020         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
45021             print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT((VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)pNext,
45022                                                                "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT", true);
45023             break;
45024         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
45025             print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
45026                 (VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pNext,
45027                 "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT", true);
45028             break;
45029         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
45030             print_VkPhysicalDeviceDepthStencilResolveProperties((VkPhysicalDeviceDepthStencilResolveProperties *)pNext,
45031                                                                 "VkPhysicalDeviceDepthStencilResolveProperties", true);
45032             break;
45033         case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
45034             print_VkSubpassDescriptionDepthStencilResolve((VkSubpassDescriptionDepthStencilResolve *)pNext,
45035                                                           "VkSubpassDescriptionDepthStencilResolve", true);
45036             break;
45037         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
45038             print_VkImageViewASTCDecodeModeEXT((VkImageViewASTCDecodeModeEXT *)pNext, "VkImageViewASTCDecodeModeEXT",
45039                                                true);
45040             break;
45041         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
45042             print_VkPhysicalDeviceASTCDecodeFeaturesEXT((VkPhysicalDeviceASTCDecodeFeaturesEXT *)pNext,
45043                                                         "VkPhysicalDeviceASTCDecodeFeaturesEXT", true);
45044             break;
45045         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
45046             print_VkDrmFormatModifierPropertiesListEXT((VkDrmFormatModifierPropertiesListEXT *)pNext,
45047                                                        "VkDrmFormatModifierPropertiesListEXT", true);
45048             break;
45049         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
45050             print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT((VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pNext,
45051                                                                 "VkPhysicalDeviceImageDrmFormatModifierInfoEXT", true);
45052             break;
45053         case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
45054             print_VkImageDrmFormatModifierListCreateInfoEXT((VkImageDrmFormatModifierListCreateInfoEXT *)pNext,
45055                                                             "VkImageDrmFormatModifierListCreateInfoEXT", true);
45056             break;
45057         case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
45058             print_VkImageDrmFormatModifierExplicitCreateInfoEXT((VkImageDrmFormatModifierExplicitCreateInfoEXT *)pNext,
45059                                                                 "VkImageDrmFormatModifierExplicitCreateInfoEXT", true);
45060             break;
45061         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
45062             print_VkImageStencilUsageCreateInfo((VkImageStencilUsageCreateInfo *)pNext, "VkImageStencilUsageCreateInfo",
45063                                                 true);
45064             break;
45065         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
45066             print_VkPhysicalDeviceScalarBlockLayoutFeatures((VkPhysicalDeviceScalarBlockLayoutFeatures *)pNext,
45067                                                             "VkPhysicalDeviceScalarBlockLayoutFeatures", true);
45068             break;
45069         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
45070             print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
45071                 (VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pNext,
45072                 "VkPhysicalDeviceUniformBufferStandardLayoutFeatures", true);
45073             break;
45074         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
45075             print_VkPhysicalDeviceDepthClipEnableFeaturesEXT((VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pNext,
45076                                                              "VkPhysicalDeviceDepthClipEnableFeaturesEXT", true);
45077             break;
45078         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
45079             print_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
45080                 (VkPipelineRasterizationDepthClipStateCreateInfoEXT *)pNext,
45081                 "VkPipelineRasterizationDepthClipStateCreateInfoEXT", true);
45082             break;
45083         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
45084             print_VkPhysicalDeviceMemoryBudgetPropertiesEXT((VkPhysicalDeviceMemoryBudgetPropertiesEXT *)pNext,
45085                                                             "VkPhysicalDeviceMemoryBudgetPropertiesEXT", true);
45086             break;
45087         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
45088             print_VkPhysicalDeviceBufferDeviceAddressFeatures((VkPhysicalDeviceBufferDeviceAddressFeatures *)pNext,
45089                                                               "VkPhysicalDeviceBufferDeviceAddressFeatures", true);
45090             break;
45091         case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
45092             print_VkBufferOpaqueCaptureAddressCreateInfo((VkBufferOpaqueCaptureAddressCreateInfo *)pNext,
45093                                                          "VkBufferOpaqueCaptureAddressCreateInfo", true);
45094             break;
45095         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
45096             print_VkPhysicalDeviceImageViewImageFormatInfoEXT((VkPhysicalDeviceImageViewImageFormatInfoEXT *)pNext,
45097                                                               "VkPhysicalDeviceImageViewImageFormatInfoEXT", true);
45098             break;
45099         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
45100             print_VkFilterCubicImageViewImageFormatPropertiesEXT(
45101                 (VkFilterCubicImageViewImageFormatPropertiesEXT *)pNext,
45102                 "VkFilterCubicImageViewImageFormatPropertiesEXT", true);
45103             break;
45104         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
45105             print_VkPhysicalDeviceImagelessFramebufferFeatures((VkPhysicalDeviceImagelessFramebufferFeatures *)pNext,
45106                                                                "VkPhysicalDeviceImagelessFramebufferFeatures", true);
45107             break;
45108         case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
45109             print_VkFramebufferAttachmentsCreateInfo((VkFramebufferAttachmentsCreateInfo *)pNext,
45110                                                      "VkFramebufferAttachmentsCreateInfo", true);
45111             break;
45112         case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
45113             print_VkRenderPassAttachmentBeginInfo((VkRenderPassAttachmentBeginInfo *)pNext,
45114                                                   "VkRenderPassAttachmentBeginInfo", true);
45115             break;
45116         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
45117             print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
45118                 (VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *)pNext,
45119                 "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT", true);
45120             break;
45121         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
45122             print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT((VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)pNext,
45123                                                               "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT", true);
45124             break;
45125         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
45126             print_VkPhysicalDevicePerformanceQueryFeaturesKHR((VkPhysicalDevicePerformanceQueryFeaturesKHR *)pNext,
45127                                                               "VkPhysicalDevicePerformanceQueryFeaturesKHR", true);
45128             break;
45129         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
45130             print_VkPhysicalDevicePerformanceQueryPropertiesKHR((VkPhysicalDevicePerformanceQueryPropertiesKHR *)pNext,
45131                                                                 "VkPhysicalDevicePerformanceQueryPropertiesKHR", true);
45132             break;
45133         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
45134             print_VkQueryPoolPerformanceCreateInfoKHR((VkQueryPoolPerformanceCreateInfoKHR *)pNext,
45135                                                       "VkQueryPoolPerformanceCreateInfoKHR", true);
45136             break;
45137         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
45138             print_VkPerformanceQuerySubmitInfoKHR((VkPerformanceQuerySubmitInfoKHR *)pNext,
45139                                                   "VkPerformanceQuerySubmitInfoKHR", true);
45140             break;
45141         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:
45142             print_VkPerformanceQueryReservationInfoKHR((VkPerformanceQueryReservationInfoKHR *)pNext,
45143                                                        "VkPerformanceQueryReservationInfoKHR", true);
45144             break;
45145         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
45146             print_VkPhysicalDeviceShaderClockFeaturesKHR((VkPhysicalDeviceShaderClockFeaturesKHR *)pNext,
45147                                                          "VkPhysicalDeviceShaderClockFeaturesKHR", true);
45148             break;
45149         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
45150             print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT((VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pNext,
45151                                                             "VkPhysicalDeviceIndexTypeUint8FeaturesEXT", true);
45152             break;
45153         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
45154             print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
45155                 (VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)pNext,
45156                 "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT", true);
45157             break;
45158         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
45159             print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
45160                 (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pNext,
45161                 "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures", true);
45162             break;
45163         case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
45164             print_VkAttachmentReferenceStencilLayout((VkAttachmentReferenceStencilLayout *)pNext,
45165                                                      "VkAttachmentReferenceStencilLayout", true);
45166             break;
45167         case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
45168             print_VkAttachmentDescriptionStencilLayout((VkAttachmentDescriptionStencilLayout *)pNext,
45169                                                        "VkAttachmentDescriptionStencilLayout", true);
45170             break;
45171         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
45172             print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
45173                 (VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *)pNext,
45174                 "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT", true);
45175             break;
45176         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
45177             print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
45178                 (VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pNext,
45179                 "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT", true);
45180             break;
45181         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
45182             print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
45183                 (VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *)pNext,
45184                 "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT", true);
45185             break;
45186         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
45187             print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
45188                 (VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *)pNext,
45189                 "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT", true);
45190             break;
45191         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
45192             print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
45193                 (VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *)pNext,
45194                 "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT", true);
45195             break;
45196         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
45197             print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
45198                 (VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *)pNext,
45199                 "VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT", true);
45200             break;
45201         case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
45202             print_VkMemoryOpaqueCaptureAddressAllocateInfo((VkMemoryOpaqueCaptureAddressAllocateInfo *)pNext,
45203                                                            "VkMemoryOpaqueCaptureAddressAllocateInfo", true);
45204             break;
45205         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
45206             print_VkPhysicalDeviceLineRasterizationFeaturesEXT((VkPhysicalDeviceLineRasterizationFeaturesEXT *)pNext,
45207                                                                "VkPhysicalDeviceLineRasterizationFeaturesEXT", true);
45208             break;
45209         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
45210             print_VkPhysicalDeviceLineRasterizationPropertiesEXT(
45211                 (VkPhysicalDeviceLineRasterizationPropertiesEXT *)pNext,
45212                 "VkPhysicalDeviceLineRasterizationPropertiesEXT", true);
45213             break;
45214         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
45215             print_VkPipelineRasterizationLineStateCreateInfoEXT((VkPipelineRasterizationLineStateCreateInfoEXT *)pNext,
45216                                                                 "VkPipelineRasterizationLineStateCreateInfoEXT", true);
45217             break;
45218         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
45219             print_VkPhysicalDeviceVulkan11Features((VkPhysicalDeviceVulkan11Features *)pNext,
45220                                                    "VkPhysicalDeviceVulkan11Features", true);
45221             break;
45222         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
45223             print_VkPhysicalDeviceVulkan11Properties((VkPhysicalDeviceVulkan11Properties *)pNext,
45224                                                      "VkPhysicalDeviceVulkan11Properties", true);
45225             break;
45226         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
45227             print_VkPhysicalDeviceVulkan12Features((VkPhysicalDeviceVulkan12Features *)pNext,
45228                                                    "VkPhysicalDeviceVulkan12Features", true);
45229             break;
45230         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
45231             print_VkPhysicalDeviceVulkan12Properties((VkPhysicalDeviceVulkan12Properties *)pNext,
45232                                                      "VkPhysicalDeviceVulkan12Properties", true);
45233             break;
45234         case VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO:
45235             print_VkFaultCallbackInfo((VkFaultCallbackInfo *)pNext, "VkFaultCallbackInfo", true);
45236             break;
45237         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
45238             print_VkSamplerCustomBorderColorCreateInfoEXT((VkSamplerCustomBorderColorCreateInfoEXT *)pNext,
45239                                                           "VkSamplerCustomBorderColorCreateInfoEXT", true);
45240             break;
45241         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
45242             print_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
45243                 (VkPhysicalDeviceCustomBorderColorPropertiesEXT *)pNext,
45244                 "VkPhysicalDeviceCustomBorderColorPropertiesEXT", true);
45245             break;
45246         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
45247             print_VkPhysicalDeviceCustomBorderColorFeaturesEXT((VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pNext,
45248                                                                "VkPhysicalDeviceCustomBorderColorFeaturesEXT", true);
45249             break;
45250         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
45251             print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
45252                 (VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pNext,
45253                 "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT", true);
45254             break;
45255         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
45256             print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
45257                 (VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pNext,
45258                 "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT", true);
45259             break;
45260         case VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO:
45261             print_VkPipelineOfflineCreateInfo((VkPipelineOfflineCreateInfo *)pNext, "VkPipelineOfflineCreateInfo",
45262                                               true);
45263             break;
45264         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
45265             print_VkPhysicalDeviceRobustness2FeaturesEXT((VkPhysicalDeviceRobustness2FeaturesEXT *)pNext,
45266                                                          "VkPhysicalDeviceRobustness2FeaturesEXT", true);
45267             break;
45268         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
45269             print_VkPhysicalDeviceRobustness2PropertiesEXT((VkPhysicalDeviceRobustness2PropertiesEXT *)pNext,
45270                                                            "VkPhysicalDeviceRobustness2PropertiesEXT", true);
45271             break;
45272         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
45273             print_VkPhysicalDeviceImageRobustnessFeaturesEXT((VkPhysicalDeviceImageRobustnessFeaturesEXT *)pNext,
45274                                                              "VkPhysicalDeviceImageRobustnessFeaturesEXT", true);
45275             break;
45276         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
45277             print_VkPhysicalDevice4444FormatsFeaturesEXT((VkPhysicalDevice4444FormatsFeaturesEXT *)pNext,
45278                                                          "VkPhysicalDevice4444FormatsFeaturesEXT", true);
45279             break;
45280         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
45281             print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
45282                 (VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)pNext,
45283                 "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT", true);
45284             break;
45285         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
45286             print_VkFragmentShadingRateAttachmentInfoKHR((VkFragmentShadingRateAttachmentInfoKHR *)pNext,
45287                                                          "VkFragmentShadingRateAttachmentInfoKHR", true);
45288             break;
45289         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
45290             print_VkPipelineFragmentShadingRateStateCreateInfoKHR(
45291                 (VkPipelineFragmentShadingRateStateCreateInfoKHR *)pNext,
45292                 "VkPipelineFragmentShadingRateStateCreateInfoKHR", true);
45293             break;
45294         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
45295             print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
45296                 (VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)pNext,
45297                 "VkPhysicalDeviceFragmentShadingRateFeaturesKHR", true);
45298             break;
45299         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
45300             print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
45301                 (VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)pNext,
45302                 "VkPhysicalDeviceFragmentShadingRatePropertiesKHR", true);
45303             break;
45304         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
45305             print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
45306                 (VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *)pNext,
45307                 "VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR", true);
45308             break;
45309         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
45310             print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
45311                 (VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)pNext,
45312                 "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT", true);
45313             break;
45314         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
45315             print_VkPhysicalDeviceColorWriteEnableFeaturesEXT((VkPhysicalDeviceColorWriteEnableFeaturesEXT *)pNext,
45316                                                               "VkPhysicalDeviceColorWriteEnableFeaturesEXT", true);
45317             break;
45318         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
45319             print_VkPipelineColorWriteCreateInfoEXT((VkPipelineColorWriteCreateInfoEXT *)pNext,
45320                                                     "VkPipelineColorWriteCreateInfoEXT", true);
45321             break;
45322         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
45323             print_VkMemoryBarrier2KHR((VkMemoryBarrier2KHR *)pNext, "VkMemoryBarrier2KHR", true);
45324             break;
45325         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
45326             print_VkQueueFamilyCheckpointProperties2NV((VkQueueFamilyCheckpointProperties2NV *)pNext,
45327                                                        "VkQueueFamilyCheckpointProperties2NV", true);
45328             break;
45329         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
45330             print_VkPhysicalDeviceSynchronization2FeaturesKHR((VkPhysicalDeviceSynchronization2FeaturesKHR *)pNext,
45331                                                               "VkPhysicalDeviceSynchronization2FeaturesKHR", true);
45332             break;
45333         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES:
45334             print_VkPhysicalDeviceVulkanSC10Properties((VkPhysicalDeviceVulkanSC10Properties *)pNext,
45335                                                        "VkPhysicalDeviceVulkanSC10Properties", true);
45336             break;
45337         case VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO:
45338             print_VkDeviceObjectReservationCreateInfo((VkDeviceObjectReservationCreateInfo *)pNext,
45339                                                       "VkDeviceObjectReservationCreateInfo", true);
45340             break;
45341         case VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO:
45342             print_VkCommandPoolMemoryReservationCreateInfo((VkCommandPoolMemoryReservationCreateInfo *)pNext,
45343                                                            "VkCommandPoolMemoryReservationCreateInfo", true);
45344             break;
45345         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES:
45346             print_VkPhysicalDeviceVulkanSC10Features((VkPhysicalDeviceVulkanSC10Features *)pNext,
45347                                                      "VkPhysicalDeviceVulkanSC10Features", true);
45348             break;
45349         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
45350             print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
45351                 (VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pNext,
45352                 "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT", true);
45353             break;
45354         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
45355             print_VkDrmFormatModifierPropertiesList2EXT((VkDrmFormatModifierPropertiesList2EXT *)pNext,
45356                                                         "VkDrmFormatModifierPropertiesList2EXT", true);
45357             break;
45358         default:
45359             assert(false); // No structure type matching
45360         }
45361     }
45362 }
45363 
45364 } //End of namespace vk_json
45365 
45366 #endif // _VULKAN_JSON_DATA_HPP