1 // Copyright (C) 2018 The Android Open Source Project
2 // Copyright (C) 2018 Google Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15
16 // Autogenerated module goldfish_vk_counting_guest
17 //
18 // (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
19 // codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
20 // codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
21 //
22 // Please do not modify directly;
23 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
24 // or directly from Python by defining:
25 // VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
26 // VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
27 // CEREAL_OUTPUT_DIR: Where to put the generated sources.
28 //
29 // python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
30 // $CEREAL_OUTPUT_DIR
31 //
32
33 #include "goldfish_vk_counting_guest.h"
34
35 #include <cstring>
36
37 #include "goldfish_vk_extension_structs_guest.h"
38 #include "goldfish_vk_private_defs.h"
39
40 namespace gfxstream {
41 namespace vk {
42
43 void count_extension_struct(uint32_t featureBits, VkStructureType rootType,
44 const void* structExtension, size_t* count);
45
46 #ifdef VK_VERSION_1_0
count_VkExtent2D(uint32_t featureBits,VkStructureType rootType,const VkExtent2D * toCount,size_t * count)47 void count_VkExtent2D(uint32_t featureBits, VkStructureType rootType, const VkExtent2D* toCount,
48 size_t* count) {
49 (void)featureBits;
50 (void)rootType;
51 (void)toCount;
52 (void)count;
53 *count += sizeof(uint32_t);
54 *count += sizeof(uint32_t);
55 }
56
count_VkExtent3D(uint32_t featureBits,VkStructureType rootType,const VkExtent3D * toCount,size_t * count)57 void count_VkExtent3D(uint32_t featureBits, VkStructureType rootType, const VkExtent3D* toCount,
58 size_t* count) {
59 (void)featureBits;
60 (void)rootType;
61 (void)toCount;
62 (void)count;
63 *count += sizeof(uint32_t);
64 *count += sizeof(uint32_t);
65 *count += sizeof(uint32_t);
66 }
67
count_VkOffset2D(uint32_t featureBits,VkStructureType rootType,const VkOffset2D * toCount,size_t * count)68 void count_VkOffset2D(uint32_t featureBits, VkStructureType rootType, const VkOffset2D* toCount,
69 size_t* count) {
70 (void)featureBits;
71 (void)rootType;
72 (void)toCount;
73 (void)count;
74 *count += sizeof(int32_t);
75 *count += sizeof(int32_t);
76 }
77
count_VkOffset3D(uint32_t featureBits,VkStructureType rootType,const VkOffset3D * toCount,size_t * count)78 void count_VkOffset3D(uint32_t featureBits, VkStructureType rootType, const VkOffset3D* toCount,
79 size_t* count) {
80 (void)featureBits;
81 (void)rootType;
82 (void)toCount;
83 (void)count;
84 *count += sizeof(int32_t);
85 *count += sizeof(int32_t);
86 *count += sizeof(int32_t);
87 }
88
count_VkRect2D(uint32_t featureBits,VkStructureType rootType,const VkRect2D * toCount,size_t * count)89 void count_VkRect2D(uint32_t featureBits, VkStructureType rootType, const VkRect2D* toCount,
90 size_t* count) {
91 (void)featureBits;
92 (void)rootType;
93 (void)toCount;
94 (void)count;
95 count_VkOffset2D(featureBits, rootType, (VkOffset2D*)(&toCount->offset), count);
96 count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->extent), count);
97 }
98
count_VkBaseInStructure(uint32_t featureBits,VkStructureType rootType,const VkBaseInStructure * toCount,size_t * count)99 void count_VkBaseInStructure(uint32_t featureBits, VkStructureType rootType,
100 const VkBaseInStructure* toCount, size_t* count) {
101 (void)featureBits;
102 (void)rootType;
103 (void)toCount;
104 (void)count;
105 *count += sizeof(VkStructureType);
106 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
107 rootType = toCount->sType;
108 }
109 count_extension_struct(featureBits, rootType, toCount->pNext, count);
110 }
111
count_VkBaseOutStructure(uint32_t featureBits,VkStructureType rootType,const VkBaseOutStructure * toCount,size_t * count)112 void count_VkBaseOutStructure(uint32_t featureBits, VkStructureType rootType,
113 const VkBaseOutStructure* toCount, size_t* count) {
114 (void)featureBits;
115 (void)rootType;
116 (void)toCount;
117 (void)count;
118 *count += sizeof(VkStructureType);
119 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
120 rootType = toCount->sType;
121 }
122 count_extension_struct(featureBits, rootType, toCount->pNext, count);
123 }
124
count_VkBufferMemoryBarrier(uint32_t featureBits,VkStructureType rootType,const VkBufferMemoryBarrier * toCount,size_t * count)125 void count_VkBufferMemoryBarrier(uint32_t featureBits, VkStructureType rootType,
126 const VkBufferMemoryBarrier* toCount, size_t* count) {
127 (void)featureBits;
128 (void)rootType;
129 (void)toCount;
130 (void)count;
131 *count += sizeof(VkStructureType);
132 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
133 rootType = toCount->sType;
134 }
135 count_extension_struct(featureBits, rootType, toCount->pNext, count);
136 *count += sizeof(VkAccessFlags);
137 *count += sizeof(VkAccessFlags);
138 *count += sizeof(uint32_t);
139 *count += sizeof(uint32_t);
140 uint64_t cgen_var_0;
141 *count += 1 * 8;
142 *count += sizeof(VkDeviceSize);
143 *count += sizeof(VkDeviceSize);
144 }
145
count_VkDispatchIndirectCommand(uint32_t featureBits,VkStructureType rootType,const VkDispatchIndirectCommand * toCount,size_t * count)146 void count_VkDispatchIndirectCommand(uint32_t featureBits, VkStructureType rootType,
147 const VkDispatchIndirectCommand* toCount, size_t* count) {
148 (void)featureBits;
149 (void)rootType;
150 (void)toCount;
151 (void)count;
152 *count += sizeof(uint32_t);
153 *count += sizeof(uint32_t);
154 *count += sizeof(uint32_t);
155 }
156
count_VkDrawIndexedIndirectCommand(uint32_t featureBits,VkStructureType rootType,const VkDrawIndexedIndirectCommand * toCount,size_t * count)157 void count_VkDrawIndexedIndirectCommand(uint32_t featureBits, VkStructureType rootType,
158 const VkDrawIndexedIndirectCommand* toCount,
159 size_t* count) {
160 (void)featureBits;
161 (void)rootType;
162 (void)toCount;
163 (void)count;
164 *count += sizeof(uint32_t);
165 *count += sizeof(uint32_t);
166 *count += sizeof(uint32_t);
167 *count += sizeof(int32_t);
168 *count += sizeof(uint32_t);
169 }
170
count_VkDrawIndirectCommand(uint32_t featureBits,VkStructureType rootType,const VkDrawIndirectCommand * toCount,size_t * count)171 void count_VkDrawIndirectCommand(uint32_t featureBits, VkStructureType rootType,
172 const VkDrawIndirectCommand* toCount, size_t* count) {
173 (void)featureBits;
174 (void)rootType;
175 (void)toCount;
176 (void)count;
177 *count += sizeof(uint32_t);
178 *count += sizeof(uint32_t);
179 *count += sizeof(uint32_t);
180 *count += sizeof(uint32_t);
181 }
182
count_VkImageSubresourceRange(uint32_t featureBits,VkStructureType rootType,const VkImageSubresourceRange * toCount,size_t * count)183 void count_VkImageSubresourceRange(uint32_t featureBits, VkStructureType rootType,
184 const VkImageSubresourceRange* toCount, size_t* count) {
185 (void)featureBits;
186 (void)rootType;
187 (void)toCount;
188 (void)count;
189 *count += sizeof(VkImageAspectFlags);
190 *count += sizeof(uint32_t);
191 *count += sizeof(uint32_t);
192 *count += sizeof(uint32_t);
193 *count += sizeof(uint32_t);
194 }
195
count_VkImageMemoryBarrier(uint32_t featureBits,VkStructureType rootType,const VkImageMemoryBarrier * toCount,size_t * count)196 void count_VkImageMemoryBarrier(uint32_t featureBits, VkStructureType rootType,
197 const VkImageMemoryBarrier* toCount, size_t* count) {
198 (void)featureBits;
199 (void)rootType;
200 (void)toCount;
201 (void)count;
202 *count += sizeof(VkStructureType);
203 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
204 rootType = toCount->sType;
205 }
206 count_extension_struct(featureBits, rootType, toCount->pNext, count);
207 *count += sizeof(VkAccessFlags);
208 *count += sizeof(VkAccessFlags);
209 *count += sizeof(VkImageLayout);
210 *count += sizeof(VkImageLayout);
211 *count += sizeof(uint32_t);
212 *count += sizeof(uint32_t);
213 uint64_t cgen_var_0;
214 *count += 1 * 8;
215 count_VkImageSubresourceRange(featureBits, rootType,
216 (VkImageSubresourceRange*)(&toCount->subresourceRange), count);
217 }
218
count_VkMemoryBarrier(uint32_t featureBits,VkStructureType rootType,const VkMemoryBarrier * toCount,size_t * count)219 void count_VkMemoryBarrier(uint32_t featureBits, VkStructureType rootType,
220 const VkMemoryBarrier* toCount, size_t* count) {
221 (void)featureBits;
222 (void)rootType;
223 (void)toCount;
224 (void)count;
225 *count += sizeof(VkStructureType);
226 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
227 rootType = toCount->sType;
228 }
229 count_extension_struct(featureBits, rootType, toCount->pNext, count);
230 *count += sizeof(VkAccessFlags);
231 *count += sizeof(VkAccessFlags);
232 }
233
count_VkPipelineCacheHeaderVersionOne(uint32_t featureBits,VkStructureType rootType,const VkPipelineCacheHeaderVersionOne * toCount,size_t * count)234 void count_VkPipelineCacheHeaderVersionOne(uint32_t featureBits, VkStructureType rootType,
235 const VkPipelineCacheHeaderVersionOne* toCount,
236 size_t* count) {
237 (void)featureBits;
238 (void)rootType;
239 (void)toCount;
240 (void)count;
241 *count += sizeof(uint32_t);
242 *count += sizeof(VkPipelineCacheHeaderVersion);
243 *count += sizeof(uint32_t);
244 *count += sizeof(uint32_t);
245 *count += VK_UUID_SIZE * sizeof(uint8_t);
246 }
247
count_VkAllocationCallbacks(uint32_t featureBits,VkStructureType rootType,const VkAllocationCallbacks * toCount,size_t * count)248 void count_VkAllocationCallbacks(uint32_t featureBits, VkStructureType rootType,
249 const VkAllocationCallbacks* toCount, size_t* count) {
250 (void)featureBits;
251 (void)rootType;
252 (void)toCount;
253 (void)count;
254 // WARNING PTR CHECK
255 *count += 8;
256 if (toCount->pUserData) {
257 *count += sizeof(uint8_t);
258 }
259 *count += 8;
260 *count += 8;
261 *count += 8;
262 *count += 8;
263 *count += 8;
264 }
265
count_VkApplicationInfo(uint32_t featureBits,VkStructureType rootType,const VkApplicationInfo * toCount,size_t * count)266 void count_VkApplicationInfo(uint32_t featureBits, VkStructureType rootType,
267 const VkApplicationInfo* toCount, size_t* count) {
268 (void)featureBits;
269 (void)rootType;
270 (void)toCount;
271 (void)count;
272 *count += sizeof(VkStructureType);
273 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
274 rootType = toCount->sType;
275 }
276 count_extension_struct(featureBits, rootType, toCount->pNext, count);
277 if (featureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
278 // WARNING PTR CHECK
279 *count += 8;
280 if (toCount->pApplicationName) {
281 *count += sizeof(uint32_t) +
282 (toCount->pApplicationName ? strlen(toCount->pApplicationName) : 0);
283 }
284 } else {
285 *count +=
286 sizeof(uint32_t) + (toCount->pApplicationName ? strlen(toCount->pApplicationName) : 0);
287 }
288 *count += sizeof(uint32_t);
289 if (featureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
290 // WARNING PTR CHECK
291 *count += 8;
292 if (toCount->pEngineName) {
293 *count += sizeof(uint32_t) + (toCount->pEngineName ? strlen(toCount->pEngineName) : 0);
294 }
295 } else {
296 *count += sizeof(uint32_t) + (toCount->pEngineName ? strlen(toCount->pEngineName) : 0);
297 }
298 *count += sizeof(uint32_t);
299 *count += sizeof(uint32_t);
300 }
301
count_VkFormatProperties(uint32_t featureBits,VkStructureType rootType,const VkFormatProperties * toCount,size_t * count)302 void count_VkFormatProperties(uint32_t featureBits, VkStructureType rootType,
303 const VkFormatProperties* toCount, size_t* count) {
304 (void)featureBits;
305 (void)rootType;
306 (void)toCount;
307 (void)count;
308 *count += sizeof(VkFormatFeatureFlags);
309 *count += sizeof(VkFormatFeatureFlags);
310 *count += sizeof(VkFormatFeatureFlags);
311 }
312
count_VkImageFormatProperties(uint32_t featureBits,VkStructureType rootType,const VkImageFormatProperties * toCount,size_t * count)313 void count_VkImageFormatProperties(uint32_t featureBits, VkStructureType rootType,
314 const VkImageFormatProperties* toCount, size_t* count) {
315 (void)featureBits;
316 (void)rootType;
317 (void)toCount;
318 (void)count;
319 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->maxExtent), count);
320 *count += sizeof(uint32_t);
321 *count += sizeof(uint32_t);
322 *count += sizeof(VkSampleCountFlags);
323 *count += sizeof(VkDeviceSize);
324 }
325
count_VkInstanceCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkInstanceCreateInfo * toCount,size_t * count)326 void count_VkInstanceCreateInfo(uint32_t featureBits, VkStructureType rootType,
327 const VkInstanceCreateInfo* toCount, size_t* count) {
328 (void)featureBits;
329 (void)rootType;
330 (void)toCount;
331 (void)count;
332 *count += sizeof(VkStructureType);
333 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
334 rootType = toCount->sType;
335 }
336 count_extension_struct(featureBits, rootType, toCount->pNext, count);
337 *count += sizeof(VkInstanceCreateFlags);
338 // WARNING PTR CHECK
339 *count += 8;
340 if (toCount->pApplicationInfo) {
341 count_VkApplicationInfo(featureBits, rootType,
342 (const VkApplicationInfo*)(toCount->pApplicationInfo), count);
343 }
344 *count += sizeof(uint32_t);
345 *count += sizeof(uint32_t);
346 if (toCount) {
347 for (uint32_t i = 0; i < toCount->enabledLayerCount; ++i) {
348 size_t l =
349 toCount->ppEnabledLayerNames[i] ? strlen(toCount->ppEnabledLayerNames[i]) : 0;
350 *count +=
351 sizeof(uint32_t) +
352 (toCount->ppEnabledLayerNames[i] ? strlen(toCount->ppEnabledLayerNames[i]) : 0);
353 }
354 }
355 *count += sizeof(uint32_t);
356 *count += sizeof(uint32_t);
357 if (toCount) {
358 for (uint32_t i = 0; i < toCount->enabledExtensionCount; ++i) {
359 size_t l = toCount->ppEnabledExtensionNames[i]
360 ? strlen(toCount->ppEnabledExtensionNames[i])
361 : 0;
362 *count += sizeof(uint32_t) + (toCount->ppEnabledExtensionNames[i]
363 ? strlen(toCount->ppEnabledExtensionNames[i])
364 : 0);
365 }
366 }
367 }
368
count_VkMemoryHeap(uint32_t featureBits,VkStructureType rootType,const VkMemoryHeap * toCount,size_t * count)369 void count_VkMemoryHeap(uint32_t featureBits, VkStructureType rootType, const VkMemoryHeap* toCount,
370 size_t* count) {
371 (void)featureBits;
372 (void)rootType;
373 (void)toCount;
374 (void)count;
375 *count += sizeof(VkDeviceSize);
376 *count += sizeof(VkMemoryHeapFlags);
377 }
378
count_VkMemoryType(uint32_t featureBits,VkStructureType rootType,const VkMemoryType * toCount,size_t * count)379 void count_VkMemoryType(uint32_t featureBits, VkStructureType rootType, const VkMemoryType* toCount,
380 size_t* count) {
381 (void)featureBits;
382 (void)rootType;
383 (void)toCount;
384 (void)count;
385 *count += sizeof(VkMemoryPropertyFlags);
386 *count += sizeof(uint32_t);
387 }
388
count_VkPhysicalDeviceFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceFeatures * toCount,size_t * count)389 void count_VkPhysicalDeviceFeatures(uint32_t featureBits, VkStructureType rootType,
390 const VkPhysicalDeviceFeatures* toCount, size_t* count) {
391 (void)featureBits;
392 (void)rootType;
393 (void)toCount;
394 (void)count;
395 *count += sizeof(VkBool32);
396 *count += sizeof(VkBool32);
397 *count += sizeof(VkBool32);
398 *count += sizeof(VkBool32);
399 *count += sizeof(VkBool32);
400 *count += sizeof(VkBool32);
401 *count += sizeof(VkBool32);
402 *count += sizeof(VkBool32);
403 *count += sizeof(VkBool32);
404 *count += sizeof(VkBool32);
405 *count += sizeof(VkBool32);
406 *count += sizeof(VkBool32);
407 *count += sizeof(VkBool32);
408 *count += sizeof(VkBool32);
409 *count += sizeof(VkBool32);
410 *count += sizeof(VkBool32);
411 *count += sizeof(VkBool32);
412 *count += sizeof(VkBool32);
413 *count += sizeof(VkBool32);
414 *count += sizeof(VkBool32);
415 *count += sizeof(VkBool32);
416 *count += sizeof(VkBool32);
417 *count += sizeof(VkBool32);
418 *count += sizeof(VkBool32);
419 *count += sizeof(VkBool32);
420 *count += sizeof(VkBool32);
421 *count += sizeof(VkBool32);
422 *count += sizeof(VkBool32);
423 *count += sizeof(VkBool32);
424 *count += sizeof(VkBool32);
425 *count += sizeof(VkBool32);
426 *count += sizeof(VkBool32);
427 *count += sizeof(VkBool32);
428 *count += sizeof(VkBool32);
429 *count += sizeof(VkBool32);
430 *count += sizeof(VkBool32);
431 *count += sizeof(VkBool32);
432 *count += sizeof(VkBool32);
433 *count += sizeof(VkBool32);
434 *count += sizeof(VkBool32);
435 *count += sizeof(VkBool32);
436 *count += sizeof(VkBool32);
437 *count += sizeof(VkBool32);
438 *count += sizeof(VkBool32);
439 *count += sizeof(VkBool32);
440 *count += sizeof(VkBool32);
441 *count += sizeof(VkBool32);
442 *count += sizeof(VkBool32);
443 *count += sizeof(VkBool32);
444 *count += sizeof(VkBool32);
445 *count += sizeof(VkBool32);
446 *count += sizeof(VkBool32);
447 *count += sizeof(VkBool32);
448 *count += sizeof(VkBool32);
449 *count += sizeof(VkBool32);
450 }
451
count_VkPhysicalDeviceLimits(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceLimits * toCount,size_t * count)452 void count_VkPhysicalDeviceLimits(uint32_t featureBits, VkStructureType rootType,
453 const VkPhysicalDeviceLimits* toCount, size_t* count) {
454 (void)featureBits;
455 (void)rootType;
456 (void)toCount;
457 (void)count;
458 *count += sizeof(uint32_t);
459 *count += sizeof(uint32_t);
460 *count += sizeof(uint32_t);
461 *count += sizeof(uint32_t);
462 *count += sizeof(uint32_t);
463 *count += sizeof(uint32_t);
464 *count += sizeof(uint32_t);
465 *count += sizeof(uint32_t);
466 *count += sizeof(uint32_t);
467 *count += sizeof(uint32_t);
468 *count += sizeof(uint32_t);
469 *count += sizeof(VkDeviceSize);
470 *count += sizeof(VkDeviceSize);
471 *count += sizeof(uint32_t);
472 *count += sizeof(uint32_t);
473 *count += sizeof(uint32_t);
474 *count += sizeof(uint32_t);
475 *count += sizeof(uint32_t);
476 *count += sizeof(uint32_t);
477 *count += sizeof(uint32_t);
478 *count += sizeof(uint32_t);
479 *count += sizeof(uint32_t);
480 *count += sizeof(uint32_t);
481 *count += sizeof(uint32_t);
482 *count += sizeof(uint32_t);
483 *count += sizeof(uint32_t);
484 *count += sizeof(uint32_t);
485 *count += sizeof(uint32_t);
486 *count += sizeof(uint32_t);
487 *count += sizeof(uint32_t);
488 *count += sizeof(uint32_t);
489 *count += sizeof(uint32_t);
490 *count += sizeof(uint32_t);
491 *count += sizeof(uint32_t);
492 *count += sizeof(uint32_t);
493 *count += sizeof(uint32_t);
494 *count += sizeof(uint32_t);
495 *count += sizeof(uint32_t);
496 *count += sizeof(uint32_t);
497 *count += sizeof(uint32_t);
498 *count += sizeof(uint32_t);
499 *count += sizeof(uint32_t);
500 *count += sizeof(uint32_t);
501 *count += sizeof(uint32_t);
502 *count += sizeof(uint32_t);
503 *count += sizeof(uint32_t);
504 *count += sizeof(uint32_t);
505 *count += sizeof(uint32_t);
506 *count += sizeof(uint32_t);
507 *count += sizeof(uint32_t);
508 *count += sizeof(uint32_t);
509 *count += sizeof(uint32_t);
510 *count += 3 * sizeof(uint32_t);
511 *count += sizeof(uint32_t);
512 *count += 3 * sizeof(uint32_t);
513 *count += sizeof(uint32_t);
514 *count += sizeof(uint32_t);
515 *count += sizeof(uint32_t);
516 *count += sizeof(uint32_t);
517 *count += sizeof(uint32_t);
518 *count += sizeof(float);
519 *count += sizeof(float);
520 *count += sizeof(uint32_t);
521 *count += 2 * sizeof(uint32_t);
522 *count += 2 * sizeof(float);
523 *count += sizeof(uint32_t);
524 *count += 8;
525 *count += sizeof(VkDeviceSize);
526 *count += sizeof(VkDeviceSize);
527 *count += sizeof(VkDeviceSize);
528 *count += sizeof(int32_t);
529 *count += sizeof(uint32_t);
530 *count += sizeof(int32_t);
531 *count += sizeof(uint32_t);
532 *count += sizeof(float);
533 *count += sizeof(float);
534 *count += sizeof(uint32_t);
535 *count += sizeof(uint32_t);
536 *count += sizeof(uint32_t);
537 *count += sizeof(uint32_t);
538 *count += sizeof(VkSampleCountFlags);
539 *count += sizeof(VkSampleCountFlags);
540 *count += sizeof(VkSampleCountFlags);
541 *count += sizeof(VkSampleCountFlags);
542 *count += sizeof(uint32_t);
543 *count += sizeof(VkSampleCountFlags);
544 *count += sizeof(VkSampleCountFlags);
545 *count += sizeof(VkSampleCountFlags);
546 *count += sizeof(VkSampleCountFlags);
547 *count += sizeof(VkSampleCountFlags);
548 *count += sizeof(uint32_t);
549 *count += sizeof(VkBool32);
550 *count += sizeof(float);
551 *count += sizeof(uint32_t);
552 *count += sizeof(uint32_t);
553 *count += sizeof(uint32_t);
554 *count += sizeof(uint32_t);
555 *count += 2 * sizeof(float);
556 *count += 2 * sizeof(float);
557 *count += sizeof(float);
558 *count += sizeof(float);
559 *count += sizeof(VkBool32);
560 *count += sizeof(VkBool32);
561 *count += sizeof(VkDeviceSize);
562 *count += sizeof(VkDeviceSize);
563 *count += sizeof(VkDeviceSize);
564 }
565
count_VkPhysicalDeviceMemoryProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceMemoryProperties * toCount,size_t * count)566 void count_VkPhysicalDeviceMemoryProperties(uint32_t featureBits, VkStructureType rootType,
567 const VkPhysicalDeviceMemoryProperties* toCount,
568 size_t* count) {
569 (void)featureBits;
570 (void)rootType;
571 (void)toCount;
572 (void)count;
573 *count += sizeof(uint32_t);
574 for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i) {
575 count_VkMemoryType(featureBits, rootType, (VkMemoryType*)(toCount->memoryTypes + i), count);
576 }
577 *count += sizeof(uint32_t);
578 for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i) {
579 count_VkMemoryHeap(featureBits, rootType, (VkMemoryHeap*)(toCount->memoryHeaps + i), count);
580 }
581 }
582
count_VkPhysicalDeviceSparseProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceSparseProperties * toCount,size_t * count)583 void count_VkPhysicalDeviceSparseProperties(uint32_t featureBits, VkStructureType rootType,
584 const VkPhysicalDeviceSparseProperties* toCount,
585 size_t* count) {
586 (void)featureBits;
587 (void)rootType;
588 (void)toCount;
589 (void)count;
590 *count += sizeof(VkBool32);
591 *count += sizeof(VkBool32);
592 *count += sizeof(VkBool32);
593 *count += sizeof(VkBool32);
594 *count += sizeof(VkBool32);
595 }
596
count_VkPhysicalDeviceProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceProperties * toCount,size_t * count)597 void count_VkPhysicalDeviceProperties(uint32_t featureBits, VkStructureType rootType,
598 const VkPhysicalDeviceProperties* toCount, size_t* count) {
599 (void)featureBits;
600 (void)rootType;
601 (void)toCount;
602 (void)count;
603 *count += sizeof(uint32_t);
604 *count += sizeof(uint32_t);
605 *count += sizeof(uint32_t);
606 *count += sizeof(uint32_t);
607 *count += sizeof(VkPhysicalDeviceType);
608 *count += VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char);
609 *count += VK_UUID_SIZE * sizeof(uint8_t);
610 count_VkPhysicalDeviceLimits(featureBits, rootType, (VkPhysicalDeviceLimits*)(&toCount->limits),
611 count);
612 count_VkPhysicalDeviceSparseProperties(
613 featureBits, rootType, (VkPhysicalDeviceSparseProperties*)(&toCount->sparseProperties),
614 count);
615 }
616
count_VkQueueFamilyProperties(uint32_t featureBits,VkStructureType rootType,const VkQueueFamilyProperties * toCount,size_t * count)617 void count_VkQueueFamilyProperties(uint32_t featureBits, VkStructureType rootType,
618 const VkQueueFamilyProperties* toCount, size_t* count) {
619 (void)featureBits;
620 (void)rootType;
621 (void)toCount;
622 (void)count;
623 *count += sizeof(VkQueueFlags);
624 *count += sizeof(uint32_t);
625 *count += sizeof(uint32_t);
626 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->minImageTransferGranularity),
627 count);
628 }
629
count_VkDeviceQueueCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkDeviceQueueCreateInfo * toCount,size_t * count)630 void count_VkDeviceQueueCreateInfo(uint32_t featureBits, VkStructureType rootType,
631 const VkDeviceQueueCreateInfo* toCount, size_t* count) {
632 (void)featureBits;
633 (void)rootType;
634 (void)toCount;
635 (void)count;
636 *count += sizeof(VkStructureType);
637 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
638 rootType = toCount->sType;
639 }
640 count_extension_struct(featureBits, rootType, toCount->pNext, count);
641 *count += sizeof(VkDeviceQueueCreateFlags);
642 *count += sizeof(uint32_t);
643 *count += sizeof(uint32_t);
644 if (toCount) {
645 *count += toCount->queueCount * sizeof(const float);
646 }
647 }
648
count_VkDeviceCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkDeviceCreateInfo * toCount,size_t * count)649 void count_VkDeviceCreateInfo(uint32_t featureBits, VkStructureType rootType,
650 const VkDeviceCreateInfo* toCount, size_t* count) {
651 (void)featureBits;
652 (void)rootType;
653 (void)toCount;
654 (void)count;
655 *count += sizeof(VkStructureType);
656 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
657 rootType = toCount->sType;
658 }
659 count_extension_struct(featureBits, rootType, toCount->pNext, count);
660 *count += sizeof(VkDeviceCreateFlags);
661 *count += sizeof(uint32_t);
662 if (toCount) {
663 for (uint32_t i = 0; i < (uint32_t)toCount->queueCreateInfoCount; ++i) {
664 count_VkDeviceQueueCreateInfo(
665 featureBits, rootType,
666 (const VkDeviceQueueCreateInfo*)(toCount->pQueueCreateInfos + i), count);
667 }
668 }
669 *count += sizeof(uint32_t);
670 *count += sizeof(uint32_t);
671 if (toCount) {
672 for (uint32_t i = 0; i < toCount->enabledLayerCount; ++i) {
673 size_t l =
674 toCount->ppEnabledLayerNames[i] ? strlen(toCount->ppEnabledLayerNames[i]) : 0;
675 *count +=
676 sizeof(uint32_t) +
677 (toCount->ppEnabledLayerNames[i] ? strlen(toCount->ppEnabledLayerNames[i]) : 0);
678 }
679 }
680 *count += sizeof(uint32_t);
681 *count += sizeof(uint32_t);
682 if (toCount) {
683 for (uint32_t i = 0; i < toCount->enabledExtensionCount; ++i) {
684 size_t l = toCount->ppEnabledExtensionNames[i]
685 ? strlen(toCount->ppEnabledExtensionNames[i])
686 : 0;
687 *count += sizeof(uint32_t) + (toCount->ppEnabledExtensionNames[i]
688 ? strlen(toCount->ppEnabledExtensionNames[i])
689 : 0);
690 }
691 }
692 // WARNING PTR CHECK
693 *count += 8;
694 if (toCount->pEnabledFeatures) {
695 count_VkPhysicalDeviceFeatures(featureBits, rootType,
696 (const VkPhysicalDeviceFeatures*)(toCount->pEnabledFeatures),
697 count);
698 }
699 }
700
count_VkExtensionProperties(uint32_t featureBits,VkStructureType rootType,const VkExtensionProperties * toCount,size_t * count)701 void count_VkExtensionProperties(uint32_t featureBits, VkStructureType rootType,
702 const VkExtensionProperties* toCount, size_t* count) {
703 (void)featureBits;
704 (void)rootType;
705 (void)toCount;
706 (void)count;
707 *count += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
708 *count += sizeof(uint32_t);
709 }
710
count_VkLayerProperties(uint32_t featureBits,VkStructureType rootType,const VkLayerProperties * toCount,size_t * count)711 void count_VkLayerProperties(uint32_t featureBits, VkStructureType rootType,
712 const VkLayerProperties* toCount, size_t* count) {
713 (void)featureBits;
714 (void)rootType;
715 (void)toCount;
716 (void)count;
717 *count += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
718 *count += sizeof(uint32_t);
719 *count += sizeof(uint32_t);
720 *count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
721 }
722
count_VkSubmitInfo(uint32_t featureBits,VkStructureType rootType,const VkSubmitInfo * toCount,size_t * count)723 void count_VkSubmitInfo(uint32_t featureBits, VkStructureType rootType, const VkSubmitInfo* toCount,
724 size_t* count) {
725 (void)featureBits;
726 (void)rootType;
727 (void)toCount;
728 (void)count;
729 *count += sizeof(VkStructureType);
730 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
731 rootType = toCount->sType;
732 }
733 count_extension_struct(featureBits, rootType, toCount->pNext, count);
734 *count += sizeof(uint32_t);
735 if (toCount->waitSemaphoreCount) {
736 *count += toCount->waitSemaphoreCount * 8;
737 }
738 if (toCount) {
739 *count += toCount->waitSemaphoreCount * sizeof(const VkPipelineStageFlags);
740 }
741 *count += sizeof(uint32_t);
742 if (toCount->commandBufferCount) {
743 *count += toCount->commandBufferCount * 8;
744 }
745 *count += sizeof(uint32_t);
746 if (toCount->signalSemaphoreCount) {
747 *count += toCount->signalSemaphoreCount * 8;
748 }
749 }
750
count_VkMappedMemoryRange(uint32_t featureBits,VkStructureType rootType,const VkMappedMemoryRange * toCount,size_t * count)751 void count_VkMappedMemoryRange(uint32_t featureBits, VkStructureType rootType,
752 const VkMappedMemoryRange* toCount, size_t* count) {
753 (void)featureBits;
754 (void)rootType;
755 (void)toCount;
756 (void)count;
757 *count += sizeof(VkStructureType);
758 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
759 rootType = toCount->sType;
760 }
761 count_extension_struct(featureBits, rootType, toCount->pNext, count);
762 uint64_t cgen_var_0;
763 *count += 1 * 8;
764 *count += sizeof(VkDeviceSize);
765 *count += sizeof(VkDeviceSize);
766 }
767
count_VkMemoryAllocateInfo(uint32_t featureBits,VkStructureType rootType,const VkMemoryAllocateInfo * toCount,size_t * count)768 void count_VkMemoryAllocateInfo(uint32_t featureBits, VkStructureType rootType,
769 const VkMemoryAllocateInfo* toCount, size_t* count) {
770 (void)featureBits;
771 (void)rootType;
772 (void)toCount;
773 (void)count;
774 *count += sizeof(VkStructureType);
775 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
776 rootType = toCount->sType;
777 }
778 count_extension_struct(featureBits, rootType, toCount->pNext, count);
779 *count += sizeof(VkDeviceSize);
780 *count += sizeof(uint32_t);
781 }
782
count_VkMemoryRequirements(uint32_t featureBits,VkStructureType rootType,const VkMemoryRequirements * toCount,size_t * count)783 void count_VkMemoryRequirements(uint32_t featureBits, VkStructureType rootType,
784 const VkMemoryRequirements* toCount, size_t* count) {
785 (void)featureBits;
786 (void)rootType;
787 (void)toCount;
788 (void)count;
789 *count += sizeof(VkDeviceSize);
790 *count += sizeof(VkDeviceSize);
791 *count += sizeof(uint32_t);
792 }
793
count_VkSparseMemoryBind(uint32_t featureBits,VkStructureType rootType,const VkSparseMemoryBind * toCount,size_t * count)794 void count_VkSparseMemoryBind(uint32_t featureBits, VkStructureType rootType,
795 const VkSparseMemoryBind* toCount, size_t* count) {
796 (void)featureBits;
797 (void)rootType;
798 (void)toCount;
799 (void)count;
800 *count += sizeof(VkDeviceSize);
801 *count += sizeof(VkDeviceSize);
802 uint64_t cgen_var_0;
803 *count += 1 * 8;
804 *count += sizeof(VkDeviceSize);
805 *count += sizeof(VkSparseMemoryBindFlags);
806 }
807
count_VkSparseBufferMemoryBindInfo(uint32_t featureBits,VkStructureType rootType,const VkSparseBufferMemoryBindInfo * toCount,size_t * count)808 void count_VkSparseBufferMemoryBindInfo(uint32_t featureBits, VkStructureType rootType,
809 const VkSparseBufferMemoryBindInfo* toCount,
810 size_t* count) {
811 (void)featureBits;
812 (void)rootType;
813 (void)toCount;
814 (void)count;
815 uint64_t cgen_var_0;
816 *count += 1 * 8;
817 *count += sizeof(uint32_t);
818 if (toCount) {
819 for (uint32_t i = 0; i < (uint32_t)toCount->bindCount; ++i) {
820 count_VkSparseMemoryBind(featureBits, rootType,
821 (const VkSparseMemoryBind*)(toCount->pBinds + i), count);
822 }
823 }
824 }
825
count_VkSparseImageOpaqueMemoryBindInfo(uint32_t featureBits,VkStructureType rootType,const VkSparseImageOpaqueMemoryBindInfo * toCount,size_t * count)826 void count_VkSparseImageOpaqueMemoryBindInfo(uint32_t featureBits, VkStructureType rootType,
827 const VkSparseImageOpaqueMemoryBindInfo* toCount,
828 size_t* count) {
829 (void)featureBits;
830 (void)rootType;
831 (void)toCount;
832 (void)count;
833 uint64_t cgen_var_0;
834 *count += 1 * 8;
835 *count += sizeof(uint32_t);
836 if (toCount) {
837 for (uint32_t i = 0; i < (uint32_t)toCount->bindCount; ++i) {
838 count_VkSparseMemoryBind(featureBits, rootType,
839 (const VkSparseMemoryBind*)(toCount->pBinds + i), count);
840 }
841 }
842 }
843
count_VkImageSubresource(uint32_t featureBits,VkStructureType rootType,const VkImageSubresource * toCount,size_t * count)844 void count_VkImageSubresource(uint32_t featureBits, VkStructureType rootType,
845 const VkImageSubresource* toCount, size_t* count) {
846 (void)featureBits;
847 (void)rootType;
848 (void)toCount;
849 (void)count;
850 *count += sizeof(VkImageAspectFlags);
851 *count += sizeof(uint32_t);
852 *count += sizeof(uint32_t);
853 }
854
count_VkSparseImageMemoryBind(uint32_t featureBits,VkStructureType rootType,const VkSparseImageMemoryBind * toCount,size_t * count)855 void count_VkSparseImageMemoryBind(uint32_t featureBits, VkStructureType rootType,
856 const VkSparseImageMemoryBind* toCount, size_t* count) {
857 (void)featureBits;
858 (void)rootType;
859 (void)toCount;
860 (void)count;
861 count_VkImageSubresource(featureBits, rootType, (VkImageSubresource*)(&toCount->subresource),
862 count);
863 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->offset), count);
864 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->extent), count);
865 uint64_t cgen_var_0;
866 *count += 1 * 8;
867 *count += sizeof(VkDeviceSize);
868 *count += sizeof(VkSparseMemoryBindFlags);
869 }
870
count_VkSparseImageMemoryBindInfo(uint32_t featureBits,VkStructureType rootType,const VkSparseImageMemoryBindInfo * toCount,size_t * count)871 void count_VkSparseImageMemoryBindInfo(uint32_t featureBits, VkStructureType rootType,
872 const VkSparseImageMemoryBindInfo* toCount, size_t* count) {
873 (void)featureBits;
874 (void)rootType;
875 (void)toCount;
876 (void)count;
877 uint64_t cgen_var_0;
878 *count += 1 * 8;
879 *count += sizeof(uint32_t);
880 if (toCount) {
881 for (uint32_t i = 0; i < (uint32_t)toCount->bindCount; ++i) {
882 count_VkSparseImageMemoryBind(featureBits, rootType,
883 (const VkSparseImageMemoryBind*)(toCount->pBinds + i),
884 count);
885 }
886 }
887 }
888
count_VkBindSparseInfo(uint32_t featureBits,VkStructureType rootType,const VkBindSparseInfo * toCount,size_t * count)889 void count_VkBindSparseInfo(uint32_t featureBits, VkStructureType rootType,
890 const VkBindSparseInfo* toCount, size_t* count) {
891 (void)featureBits;
892 (void)rootType;
893 (void)toCount;
894 (void)count;
895 *count += sizeof(VkStructureType);
896 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
897 rootType = toCount->sType;
898 }
899 count_extension_struct(featureBits, rootType, toCount->pNext, count);
900 *count += sizeof(uint32_t);
901 if (toCount->waitSemaphoreCount) {
902 *count += toCount->waitSemaphoreCount * 8;
903 }
904 *count += sizeof(uint32_t);
905 if (toCount) {
906 for (uint32_t i = 0; i < (uint32_t)toCount->bufferBindCount; ++i) {
907 count_VkSparseBufferMemoryBindInfo(
908 featureBits, rootType,
909 (const VkSparseBufferMemoryBindInfo*)(toCount->pBufferBinds + i), count);
910 }
911 }
912 *count += sizeof(uint32_t);
913 if (toCount) {
914 for (uint32_t i = 0; i < (uint32_t)toCount->imageOpaqueBindCount; ++i) {
915 count_VkSparseImageOpaqueMemoryBindInfo(
916 featureBits, rootType,
917 (const VkSparseImageOpaqueMemoryBindInfo*)(toCount->pImageOpaqueBinds + i), count);
918 }
919 }
920 *count += sizeof(uint32_t);
921 if (toCount) {
922 for (uint32_t i = 0; i < (uint32_t)toCount->imageBindCount; ++i) {
923 count_VkSparseImageMemoryBindInfo(
924 featureBits, rootType,
925 (const VkSparseImageMemoryBindInfo*)(toCount->pImageBinds + i), count);
926 }
927 }
928 *count += sizeof(uint32_t);
929 if (toCount->signalSemaphoreCount) {
930 *count += toCount->signalSemaphoreCount * 8;
931 }
932 }
933
count_VkSparseImageFormatProperties(uint32_t featureBits,VkStructureType rootType,const VkSparseImageFormatProperties * toCount,size_t * count)934 void count_VkSparseImageFormatProperties(uint32_t featureBits, VkStructureType rootType,
935 const VkSparseImageFormatProperties* toCount,
936 size_t* count) {
937 (void)featureBits;
938 (void)rootType;
939 (void)toCount;
940 (void)count;
941 *count += sizeof(VkImageAspectFlags);
942 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->imageGranularity), count);
943 *count += sizeof(VkSparseImageFormatFlags);
944 }
945
count_VkSparseImageMemoryRequirements(uint32_t featureBits,VkStructureType rootType,const VkSparseImageMemoryRequirements * toCount,size_t * count)946 void count_VkSparseImageMemoryRequirements(uint32_t featureBits, VkStructureType rootType,
947 const VkSparseImageMemoryRequirements* toCount,
948 size_t* count) {
949 (void)featureBits;
950 (void)rootType;
951 (void)toCount;
952 (void)count;
953 count_VkSparseImageFormatProperties(
954 featureBits, rootType, (VkSparseImageFormatProperties*)(&toCount->formatProperties), count);
955 *count += sizeof(uint32_t);
956 *count += sizeof(VkDeviceSize);
957 *count += sizeof(VkDeviceSize);
958 *count += sizeof(VkDeviceSize);
959 }
960
count_VkFenceCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkFenceCreateInfo * toCount,size_t * count)961 void count_VkFenceCreateInfo(uint32_t featureBits, VkStructureType rootType,
962 const VkFenceCreateInfo* toCount, size_t* count) {
963 (void)featureBits;
964 (void)rootType;
965 (void)toCount;
966 (void)count;
967 *count += sizeof(VkStructureType);
968 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
969 rootType = toCount->sType;
970 }
971 count_extension_struct(featureBits, rootType, toCount->pNext, count);
972 *count += sizeof(VkFenceCreateFlags);
973 }
974
count_VkSemaphoreCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkSemaphoreCreateInfo * toCount,size_t * count)975 void count_VkSemaphoreCreateInfo(uint32_t featureBits, VkStructureType rootType,
976 const VkSemaphoreCreateInfo* toCount, size_t* count) {
977 (void)featureBits;
978 (void)rootType;
979 (void)toCount;
980 (void)count;
981 *count += sizeof(VkStructureType);
982 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
983 rootType = toCount->sType;
984 }
985 count_extension_struct(featureBits, rootType, toCount->pNext, count);
986 *count += sizeof(VkSemaphoreCreateFlags);
987 }
988
count_VkEventCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkEventCreateInfo * toCount,size_t * count)989 void count_VkEventCreateInfo(uint32_t featureBits, VkStructureType rootType,
990 const VkEventCreateInfo* toCount, size_t* count) {
991 (void)featureBits;
992 (void)rootType;
993 (void)toCount;
994 (void)count;
995 *count += sizeof(VkStructureType);
996 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
997 rootType = toCount->sType;
998 }
999 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1000 *count += sizeof(VkEventCreateFlags);
1001 }
1002
count_VkQueryPoolCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkQueryPoolCreateInfo * toCount,size_t * count)1003 void count_VkQueryPoolCreateInfo(uint32_t featureBits, VkStructureType rootType,
1004 const VkQueryPoolCreateInfo* toCount, size_t* count) {
1005 (void)featureBits;
1006 (void)rootType;
1007 (void)toCount;
1008 (void)count;
1009 *count += sizeof(VkStructureType);
1010 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1011 rootType = toCount->sType;
1012 }
1013 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1014 *count += sizeof(VkQueryPoolCreateFlags);
1015 *count += sizeof(VkQueryType);
1016 *count += sizeof(uint32_t);
1017 *count += sizeof(VkQueryPipelineStatisticFlags);
1018 }
1019
count_VkBufferCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkBufferCreateInfo * toCount,size_t * count)1020 void count_VkBufferCreateInfo(uint32_t featureBits, VkStructureType rootType,
1021 const VkBufferCreateInfo* toCount, size_t* count) {
1022 (void)featureBits;
1023 (void)rootType;
1024 (void)toCount;
1025 (void)count;
1026 *count += sizeof(VkStructureType);
1027 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1028 rootType = toCount->sType;
1029 }
1030 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1031 *count += sizeof(VkBufferCreateFlags);
1032 *count += sizeof(VkDeviceSize);
1033 *count += sizeof(VkBufferUsageFlags);
1034 *count += sizeof(VkSharingMode);
1035 *count += sizeof(uint32_t);
1036 // WARNING PTR CHECK
1037 *count += 8;
1038 if (toCount->pQueueFamilyIndices) {
1039 if (toCount) {
1040 *count += toCount->queueFamilyIndexCount * sizeof(const uint32_t);
1041 }
1042 }
1043 }
1044
count_VkBufferViewCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkBufferViewCreateInfo * toCount,size_t * count)1045 void count_VkBufferViewCreateInfo(uint32_t featureBits, VkStructureType rootType,
1046 const VkBufferViewCreateInfo* toCount, size_t* count) {
1047 (void)featureBits;
1048 (void)rootType;
1049 (void)toCount;
1050 (void)count;
1051 *count += sizeof(VkStructureType);
1052 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1053 rootType = toCount->sType;
1054 }
1055 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1056 *count += sizeof(VkBufferViewCreateFlags);
1057 uint64_t cgen_var_0;
1058 *count += 1 * 8;
1059 *count += sizeof(VkFormat);
1060 *count += sizeof(VkDeviceSize);
1061 *count += sizeof(VkDeviceSize);
1062 }
1063
count_VkImageCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkImageCreateInfo * toCount,size_t * count)1064 void count_VkImageCreateInfo(uint32_t featureBits, VkStructureType rootType,
1065 const VkImageCreateInfo* toCount, size_t* count) {
1066 (void)featureBits;
1067 (void)rootType;
1068 (void)toCount;
1069 (void)count;
1070 *count += sizeof(VkStructureType);
1071 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1072 rootType = toCount->sType;
1073 }
1074 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1075 *count += sizeof(VkImageCreateFlags);
1076 *count += sizeof(VkImageType);
1077 *count += sizeof(VkFormat);
1078 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->extent), count);
1079 *count += sizeof(uint32_t);
1080 *count += sizeof(uint32_t);
1081 *count += sizeof(VkSampleCountFlagBits);
1082 *count += sizeof(VkImageTiling);
1083 *count += sizeof(VkImageUsageFlags);
1084 *count += sizeof(VkSharingMode);
1085 *count += sizeof(uint32_t);
1086 // WARNING PTR CHECK
1087 *count += 8;
1088 if (toCount->pQueueFamilyIndices) {
1089 if (toCount) {
1090 *count += toCount->queueFamilyIndexCount * sizeof(const uint32_t);
1091 }
1092 }
1093 *count += sizeof(VkImageLayout);
1094 }
1095
count_VkSubresourceLayout(uint32_t featureBits,VkStructureType rootType,const VkSubresourceLayout * toCount,size_t * count)1096 void count_VkSubresourceLayout(uint32_t featureBits, VkStructureType rootType,
1097 const VkSubresourceLayout* toCount, size_t* count) {
1098 (void)featureBits;
1099 (void)rootType;
1100 (void)toCount;
1101 (void)count;
1102 *count += sizeof(VkDeviceSize);
1103 *count += sizeof(VkDeviceSize);
1104 *count += sizeof(VkDeviceSize);
1105 *count += sizeof(VkDeviceSize);
1106 *count += sizeof(VkDeviceSize);
1107 }
1108
count_VkComponentMapping(uint32_t featureBits,VkStructureType rootType,const VkComponentMapping * toCount,size_t * count)1109 void count_VkComponentMapping(uint32_t featureBits, VkStructureType rootType,
1110 const VkComponentMapping* toCount, size_t* count) {
1111 (void)featureBits;
1112 (void)rootType;
1113 (void)toCount;
1114 (void)count;
1115 *count += sizeof(VkComponentSwizzle);
1116 *count += sizeof(VkComponentSwizzle);
1117 *count += sizeof(VkComponentSwizzle);
1118 *count += sizeof(VkComponentSwizzle);
1119 }
1120
count_VkImageViewCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkImageViewCreateInfo * toCount,size_t * count)1121 void count_VkImageViewCreateInfo(uint32_t featureBits, VkStructureType rootType,
1122 const VkImageViewCreateInfo* toCount, size_t* count) {
1123 (void)featureBits;
1124 (void)rootType;
1125 (void)toCount;
1126 (void)count;
1127 *count += sizeof(VkStructureType);
1128 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1129 rootType = toCount->sType;
1130 }
1131 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1132 *count += sizeof(VkImageViewCreateFlags);
1133 uint64_t cgen_var_0;
1134 *count += 1 * 8;
1135 *count += sizeof(VkImageViewType);
1136 *count += sizeof(VkFormat);
1137 count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->components),
1138 count);
1139 count_VkImageSubresourceRange(featureBits, rootType,
1140 (VkImageSubresourceRange*)(&toCount->subresourceRange), count);
1141 }
1142
count_VkShaderModuleCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkShaderModuleCreateInfo * toCount,size_t * count)1143 void count_VkShaderModuleCreateInfo(uint32_t featureBits, VkStructureType rootType,
1144 const VkShaderModuleCreateInfo* toCount, size_t* count) {
1145 (void)featureBits;
1146 (void)rootType;
1147 (void)toCount;
1148 (void)count;
1149 *count += sizeof(VkStructureType);
1150 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1151 rootType = toCount->sType;
1152 }
1153 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1154 *count += sizeof(VkShaderModuleCreateFlags);
1155 *count += 8;
1156 if (toCount) {
1157 *count += (toCount->codeSize / 4) * sizeof(const uint32_t);
1158 }
1159 }
1160
count_VkPipelineCacheCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineCacheCreateInfo * toCount,size_t * count)1161 void count_VkPipelineCacheCreateInfo(uint32_t featureBits, VkStructureType rootType,
1162 const VkPipelineCacheCreateInfo* toCount, size_t* count) {
1163 (void)featureBits;
1164 (void)rootType;
1165 (void)toCount;
1166 (void)count;
1167 *count += sizeof(VkStructureType);
1168 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1169 rootType = toCount->sType;
1170 }
1171 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1172 *count += sizeof(VkPipelineCacheCreateFlags);
1173 *count += 8;
1174 if (toCount) {
1175 *count += toCount->initialDataSize * sizeof(const uint8_t);
1176 }
1177 }
1178
count_VkSpecializationMapEntry(uint32_t featureBits,VkStructureType rootType,const VkSpecializationMapEntry * toCount,size_t * count)1179 void count_VkSpecializationMapEntry(uint32_t featureBits, VkStructureType rootType,
1180 const VkSpecializationMapEntry* toCount, size_t* count) {
1181 (void)featureBits;
1182 (void)rootType;
1183 (void)toCount;
1184 (void)count;
1185 *count += sizeof(uint32_t);
1186 *count += sizeof(uint32_t);
1187 *count += 8;
1188 }
1189
count_VkSpecializationInfo(uint32_t featureBits,VkStructureType rootType,const VkSpecializationInfo * toCount,size_t * count)1190 void count_VkSpecializationInfo(uint32_t featureBits, VkStructureType rootType,
1191 const VkSpecializationInfo* toCount, size_t* count) {
1192 (void)featureBits;
1193 (void)rootType;
1194 (void)toCount;
1195 (void)count;
1196 *count += sizeof(uint32_t);
1197 if (toCount) {
1198 for (uint32_t i = 0; i < (uint32_t)toCount->mapEntryCount; ++i) {
1199 count_VkSpecializationMapEntry(
1200 featureBits, rootType, (const VkSpecializationMapEntry*)(toCount->pMapEntries + i),
1201 count);
1202 }
1203 }
1204 *count += 8;
1205 if (toCount) {
1206 *count += toCount->dataSize * sizeof(const uint8_t);
1207 }
1208 }
1209
count_VkPipelineShaderStageCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineShaderStageCreateInfo * toCount,size_t * count)1210 void count_VkPipelineShaderStageCreateInfo(uint32_t featureBits, VkStructureType rootType,
1211 const VkPipelineShaderStageCreateInfo* toCount,
1212 size_t* count) {
1213 (void)featureBits;
1214 (void)rootType;
1215 (void)toCount;
1216 (void)count;
1217 *count += sizeof(VkStructureType);
1218 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1219 rootType = toCount->sType;
1220 }
1221 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1222 *count += sizeof(VkPipelineShaderStageCreateFlags);
1223 *count += sizeof(VkShaderStageFlagBits);
1224 uint64_t cgen_var_0;
1225 *count += 1 * 8;
1226 *count += sizeof(uint32_t) + (toCount->pName ? strlen(toCount->pName) : 0);
1227 // WARNING PTR CHECK
1228 *count += 8;
1229 if (toCount->pSpecializationInfo) {
1230 count_VkSpecializationInfo(featureBits, rootType,
1231 (const VkSpecializationInfo*)(toCount->pSpecializationInfo),
1232 count);
1233 }
1234 }
1235
count_VkComputePipelineCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkComputePipelineCreateInfo * toCount,size_t * count)1236 void count_VkComputePipelineCreateInfo(uint32_t featureBits, VkStructureType rootType,
1237 const VkComputePipelineCreateInfo* toCount, size_t* count) {
1238 (void)featureBits;
1239 (void)rootType;
1240 (void)toCount;
1241 (void)count;
1242 *count += sizeof(VkStructureType);
1243 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1244 rootType = toCount->sType;
1245 }
1246 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1247 *count += sizeof(VkPipelineCreateFlags);
1248 count_VkPipelineShaderStageCreateInfo(
1249 featureBits, rootType, (VkPipelineShaderStageCreateInfo*)(&toCount->stage), count);
1250 uint64_t cgen_var_0;
1251 *count += 1 * 8;
1252 uint64_t cgen_var_1;
1253 *count += 1 * 8;
1254 *count += sizeof(int32_t);
1255 }
1256
count_VkVertexInputBindingDescription(uint32_t featureBits,VkStructureType rootType,const VkVertexInputBindingDescription * toCount,size_t * count)1257 void count_VkVertexInputBindingDescription(uint32_t featureBits, VkStructureType rootType,
1258 const VkVertexInputBindingDescription* toCount,
1259 size_t* count) {
1260 (void)featureBits;
1261 (void)rootType;
1262 (void)toCount;
1263 (void)count;
1264 *count += sizeof(uint32_t);
1265 *count += sizeof(uint32_t);
1266 *count += sizeof(VkVertexInputRate);
1267 }
1268
count_VkVertexInputAttributeDescription(uint32_t featureBits,VkStructureType rootType,const VkVertexInputAttributeDescription * toCount,size_t * count)1269 void count_VkVertexInputAttributeDescription(uint32_t featureBits, VkStructureType rootType,
1270 const VkVertexInputAttributeDescription* toCount,
1271 size_t* count) {
1272 (void)featureBits;
1273 (void)rootType;
1274 (void)toCount;
1275 (void)count;
1276 *count += sizeof(uint32_t);
1277 *count += sizeof(uint32_t);
1278 *count += sizeof(VkFormat);
1279 *count += sizeof(uint32_t);
1280 }
1281
count_VkPipelineVertexInputStateCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineVertexInputStateCreateInfo * toCount,size_t * count)1282 void count_VkPipelineVertexInputStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
1283 const VkPipelineVertexInputStateCreateInfo* toCount,
1284 size_t* count) {
1285 (void)featureBits;
1286 (void)rootType;
1287 (void)toCount;
1288 (void)count;
1289 *count += sizeof(VkStructureType);
1290 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1291 rootType = toCount->sType;
1292 }
1293 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1294 *count += sizeof(VkPipelineVertexInputStateCreateFlags);
1295 *count += sizeof(uint32_t);
1296 if (toCount) {
1297 for (uint32_t i = 0; i < (uint32_t)toCount->vertexBindingDescriptionCount; ++i) {
1298 count_VkVertexInputBindingDescription(
1299 featureBits, rootType,
1300 (const VkVertexInputBindingDescription*)(toCount->pVertexBindingDescriptions + i),
1301 count);
1302 }
1303 }
1304 *count += sizeof(uint32_t);
1305 if (toCount) {
1306 for (uint32_t i = 0; i < (uint32_t)toCount->vertexAttributeDescriptionCount; ++i) {
1307 count_VkVertexInputAttributeDescription(
1308 featureBits, rootType,
1309 (const VkVertexInputAttributeDescription*)(toCount->pVertexAttributeDescriptions +
1310 i),
1311 count);
1312 }
1313 }
1314 }
1315
count_VkPipelineInputAssemblyStateCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineInputAssemblyStateCreateInfo * toCount,size_t * count)1316 void count_VkPipelineInputAssemblyStateCreateInfo(
1317 uint32_t featureBits, VkStructureType rootType,
1318 const VkPipelineInputAssemblyStateCreateInfo* toCount, size_t* count) {
1319 (void)featureBits;
1320 (void)rootType;
1321 (void)toCount;
1322 (void)count;
1323 *count += sizeof(VkStructureType);
1324 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1325 rootType = toCount->sType;
1326 }
1327 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1328 *count += sizeof(VkPipelineInputAssemblyStateCreateFlags);
1329 *count += sizeof(VkPrimitiveTopology);
1330 *count += sizeof(VkBool32);
1331 }
1332
count_VkPipelineTessellationStateCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineTessellationStateCreateInfo * toCount,size_t * count)1333 void count_VkPipelineTessellationStateCreateInfo(
1334 uint32_t featureBits, VkStructureType rootType,
1335 const VkPipelineTessellationStateCreateInfo* toCount, size_t* count) {
1336 (void)featureBits;
1337 (void)rootType;
1338 (void)toCount;
1339 (void)count;
1340 *count += sizeof(VkStructureType);
1341 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1342 rootType = toCount->sType;
1343 }
1344 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1345 *count += sizeof(VkPipelineTessellationStateCreateFlags);
1346 *count += sizeof(uint32_t);
1347 }
1348
count_VkViewport(uint32_t featureBits,VkStructureType rootType,const VkViewport * toCount,size_t * count)1349 void count_VkViewport(uint32_t featureBits, VkStructureType rootType, const VkViewport* toCount,
1350 size_t* count) {
1351 (void)featureBits;
1352 (void)rootType;
1353 (void)toCount;
1354 (void)count;
1355 *count += sizeof(float);
1356 *count += sizeof(float);
1357 *count += sizeof(float);
1358 *count += sizeof(float);
1359 *count += sizeof(float);
1360 *count += sizeof(float);
1361 }
1362
count_VkPipelineViewportStateCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineViewportStateCreateInfo * toCount,size_t * count)1363 void count_VkPipelineViewportStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
1364 const VkPipelineViewportStateCreateInfo* toCount,
1365 size_t* count) {
1366 (void)featureBits;
1367 (void)rootType;
1368 (void)toCount;
1369 (void)count;
1370 *count += sizeof(VkStructureType);
1371 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1372 rootType = toCount->sType;
1373 }
1374 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1375 *count += sizeof(VkPipelineViewportStateCreateFlags);
1376 *count += sizeof(uint32_t);
1377 // WARNING PTR CHECK
1378 *count += 8;
1379 if (toCount->pViewports) {
1380 if (toCount) {
1381 for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i) {
1382 count_VkViewport(featureBits, rootType,
1383 (const VkViewport*)(toCount->pViewports + i), count);
1384 }
1385 }
1386 }
1387 *count += sizeof(uint32_t);
1388 // WARNING PTR CHECK
1389 *count += 8;
1390 if (toCount->pScissors) {
1391 if (toCount) {
1392 for (uint32_t i = 0; i < (uint32_t)toCount->scissorCount; ++i) {
1393 count_VkRect2D(featureBits, rootType, (const VkRect2D*)(toCount->pScissors + i),
1394 count);
1395 }
1396 }
1397 }
1398 }
1399
count_VkPipelineRasterizationStateCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineRasterizationStateCreateInfo * toCount,size_t * count)1400 void count_VkPipelineRasterizationStateCreateInfo(
1401 uint32_t featureBits, VkStructureType rootType,
1402 const VkPipelineRasterizationStateCreateInfo* toCount, size_t* count) {
1403 (void)featureBits;
1404 (void)rootType;
1405 (void)toCount;
1406 (void)count;
1407 *count += sizeof(VkStructureType);
1408 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1409 rootType = toCount->sType;
1410 }
1411 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1412 *count += sizeof(VkPipelineRasterizationStateCreateFlags);
1413 *count += sizeof(VkBool32);
1414 *count += sizeof(VkBool32);
1415 *count += sizeof(VkPolygonMode);
1416 *count += sizeof(VkCullModeFlags);
1417 *count += sizeof(VkFrontFace);
1418 *count += sizeof(VkBool32);
1419 *count += sizeof(float);
1420 *count += sizeof(float);
1421 *count += sizeof(float);
1422 *count += sizeof(float);
1423 }
1424
count_VkPipelineMultisampleStateCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineMultisampleStateCreateInfo * toCount,size_t * count)1425 void count_VkPipelineMultisampleStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
1426 const VkPipelineMultisampleStateCreateInfo* toCount,
1427 size_t* count) {
1428 (void)featureBits;
1429 (void)rootType;
1430 (void)toCount;
1431 (void)count;
1432 *count += sizeof(VkStructureType);
1433 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1434 rootType = toCount->sType;
1435 }
1436 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1437 *count += sizeof(VkPipelineMultisampleStateCreateFlags);
1438 *count += sizeof(VkSampleCountFlagBits);
1439 *count += sizeof(VkBool32);
1440 *count += sizeof(float);
1441 // WARNING PTR CHECK
1442 *count += 8;
1443 if (toCount->pSampleMask) {
1444 if (toCount) {
1445 *count += (((toCount->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask);
1446 }
1447 }
1448 *count += sizeof(VkBool32);
1449 *count += sizeof(VkBool32);
1450 }
1451
count_VkStencilOpState(uint32_t featureBits,VkStructureType rootType,const VkStencilOpState * toCount,size_t * count)1452 void count_VkStencilOpState(uint32_t featureBits, VkStructureType rootType,
1453 const VkStencilOpState* toCount, size_t* count) {
1454 (void)featureBits;
1455 (void)rootType;
1456 (void)toCount;
1457 (void)count;
1458 *count += sizeof(VkStencilOp);
1459 *count += sizeof(VkStencilOp);
1460 *count += sizeof(VkStencilOp);
1461 *count += sizeof(VkCompareOp);
1462 *count += sizeof(uint32_t);
1463 *count += sizeof(uint32_t);
1464 *count += sizeof(uint32_t);
1465 }
1466
count_VkPipelineDepthStencilStateCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineDepthStencilStateCreateInfo * toCount,size_t * count)1467 void count_VkPipelineDepthStencilStateCreateInfo(
1468 uint32_t featureBits, VkStructureType rootType,
1469 const VkPipelineDepthStencilStateCreateInfo* toCount, size_t* count) {
1470 (void)featureBits;
1471 (void)rootType;
1472 (void)toCount;
1473 (void)count;
1474 *count += sizeof(VkStructureType);
1475 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1476 rootType = toCount->sType;
1477 }
1478 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1479 *count += sizeof(VkPipelineDepthStencilStateCreateFlags);
1480 *count += sizeof(VkBool32);
1481 *count += sizeof(VkBool32);
1482 *count += sizeof(VkCompareOp);
1483 *count += sizeof(VkBool32);
1484 *count += sizeof(VkBool32);
1485 count_VkStencilOpState(featureBits, rootType, (VkStencilOpState*)(&toCount->front), count);
1486 count_VkStencilOpState(featureBits, rootType, (VkStencilOpState*)(&toCount->back), count);
1487 *count += sizeof(float);
1488 *count += sizeof(float);
1489 }
1490
count_VkPipelineColorBlendAttachmentState(uint32_t featureBits,VkStructureType rootType,const VkPipelineColorBlendAttachmentState * toCount,size_t * count)1491 void count_VkPipelineColorBlendAttachmentState(uint32_t featureBits, VkStructureType rootType,
1492 const VkPipelineColorBlendAttachmentState* toCount,
1493 size_t* count) {
1494 (void)featureBits;
1495 (void)rootType;
1496 (void)toCount;
1497 (void)count;
1498 *count += sizeof(VkBool32);
1499 *count += sizeof(VkBlendFactor);
1500 *count += sizeof(VkBlendFactor);
1501 *count += sizeof(VkBlendOp);
1502 *count += sizeof(VkBlendFactor);
1503 *count += sizeof(VkBlendFactor);
1504 *count += sizeof(VkBlendOp);
1505 *count += sizeof(VkColorComponentFlags);
1506 }
1507
count_VkPipelineColorBlendStateCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineColorBlendStateCreateInfo * toCount,size_t * count)1508 void count_VkPipelineColorBlendStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
1509 const VkPipelineColorBlendStateCreateInfo* toCount,
1510 size_t* count) {
1511 (void)featureBits;
1512 (void)rootType;
1513 (void)toCount;
1514 (void)count;
1515 *count += sizeof(VkStructureType);
1516 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1517 rootType = toCount->sType;
1518 }
1519 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1520 *count += sizeof(VkPipelineColorBlendStateCreateFlags);
1521 *count += sizeof(VkBool32);
1522 *count += sizeof(VkLogicOp);
1523 *count += sizeof(uint32_t);
1524 if (toCount) {
1525 for (uint32_t i = 0; i < (uint32_t)toCount->attachmentCount; ++i) {
1526 count_VkPipelineColorBlendAttachmentState(
1527 featureBits, rootType,
1528 (const VkPipelineColorBlendAttachmentState*)(toCount->pAttachments + i), count);
1529 }
1530 }
1531 *count += 4 * sizeof(float);
1532 }
1533
count_VkPipelineDynamicStateCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineDynamicStateCreateInfo * toCount,size_t * count)1534 void count_VkPipelineDynamicStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
1535 const VkPipelineDynamicStateCreateInfo* toCount,
1536 size_t* count) {
1537 (void)featureBits;
1538 (void)rootType;
1539 (void)toCount;
1540 (void)count;
1541 *count += sizeof(VkStructureType);
1542 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1543 rootType = toCount->sType;
1544 }
1545 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1546 *count += sizeof(VkPipelineDynamicStateCreateFlags);
1547 *count += sizeof(uint32_t);
1548 if (toCount) {
1549 *count += toCount->dynamicStateCount * sizeof(const VkDynamicState);
1550 }
1551 }
1552
count_VkGraphicsPipelineCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkGraphicsPipelineCreateInfo * toCount,size_t * count)1553 void count_VkGraphicsPipelineCreateInfo(uint32_t featureBits, VkStructureType rootType,
1554 const VkGraphicsPipelineCreateInfo* toCount,
1555 size_t* count) {
1556 (void)featureBits;
1557 (void)rootType;
1558 (void)toCount;
1559 (void)count;
1560 uint32_t hasRasterization = 1;
1561 if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
1562 hasRasterization =
1563 ((((0 == toCount->pRasterizationState))
1564 ? (0)
1565 : (!((*(toCount->pRasterizationState)).rasterizerDiscardEnable))) ||
1566 (((0 == toCount->pDynamicState))
1567 ? (0)
1568 : (arrayany((*(toCount->pDynamicState)).pDynamicStates, 0,
1569 (*(toCount->pDynamicState)).dynamicStateCount, [](VkDynamicState s) {
1570 return (s == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE);
1571 }))));
1572 *count += 4;
1573 }
1574 uint32_t hasTessellation = 1;
1575 if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
1576 hasTessellation = arrayany(
1577 toCount->pStages, 0, toCount->stageCount, [](VkPipelineShaderStageCreateInfo s) {
1578 return ((s.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) ||
1579 (s.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT));
1580 });
1581 *count += 4;
1582 }
1583 *count += sizeof(VkStructureType);
1584 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1585 rootType = toCount->sType;
1586 }
1587 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1588 *count += sizeof(VkPipelineCreateFlags);
1589 *count += sizeof(uint32_t);
1590 if (toCount) {
1591 for (uint32_t i = 0; i < (uint32_t)toCount->stageCount; ++i) {
1592 count_VkPipelineShaderStageCreateInfo(
1593 featureBits, rootType,
1594 (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
1595 }
1596 }
1597 // WARNING PTR CHECK
1598 if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
1599 *count += 8;
1600 }
1601 if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
1602 toCount->pVertexInputState)) {
1603 count_VkPipelineVertexInputStateCreateInfo(
1604 featureBits, rootType,
1605 (const VkPipelineVertexInputStateCreateInfo*)(toCount->pVertexInputState), count);
1606 }
1607 // WARNING PTR CHECK
1608 if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
1609 *count += 8;
1610 }
1611 if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
1612 toCount->pInputAssemblyState)) {
1613 count_VkPipelineInputAssemblyStateCreateInfo(
1614 featureBits, rootType,
1615 (const VkPipelineInputAssemblyStateCreateInfo*)(toCount->pInputAssemblyState), count);
1616 }
1617 // WARNING PTR CHECK
1618 *count += 8;
1619 if (toCount->pTessellationState) {
1620 if (hasTessellation) {
1621 count_VkPipelineTessellationStateCreateInfo(
1622 featureBits, rootType,
1623 (const VkPipelineTessellationStateCreateInfo*)(toCount->pTessellationState), count);
1624 }
1625 }
1626 // WARNING PTR CHECK
1627 *count += 8;
1628 if (toCount->pViewportState) {
1629 if (hasRasterization) {
1630 count_VkPipelineViewportStateCreateInfo(
1631 featureBits, rootType,
1632 (const VkPipelineViewportStateCreateInfo*)(toCount->pViewportState), count);
1633 }
1634 }
1635 // WARNING PTR CHECK
1636 if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
1637 *count += 8;
1638 }
1639 if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
1640 toCount->pRasterizationState)) {
1641 count_VkPipelineRasterizationStateCreateInfo(
1642 featureBits, rootType,
1643 (const VkPipelineRasterizationStateCreateInfo*)(toCount->pRasterizationState), count);
1644 }
1645 // WARNING PTR CHECK
1646 *count += 8;
1647 if (toCount->pMultisampleState) {
1648 if (hasRasterization) {
1649 count_VkPipelineMultisampleStateCreateInfo(
1650 featureBits, rootType,
1651 (const VkPipelineMultisampleStateCreateInfo*)(toCount->pMultisampleState), count);
1652 }
1653 }
1654 // WARNING PTR CHECK
1655 *count += 8;
1656 if (toCount->pDepthStencilState) {
1657 if (hasRasterization) {
1658 count_VkPipelineDepthStencilStateCreateInfo(
1659 featureBits, rootType,
1660 (const VkPipelineDepthStencilStateCreateInfo*)(toCount->pDepthStencilState), count);
1661 }
1662 }
1663 // WARNING PTR CHECK
1664 *count += 8;
1665 if (toCount->pColorBlendState) {
1666 if (hasRasterization) {
1667 count_VkPipelineColorBlendStateCreateInfo(
1668 featureBits, rootType,
1669 (const VkPipelineColorBlendStateCreateInfo*)(toCount->pColorBlendState), count);
1670 }
1671 }
1672 // WARNING PTR CHECK
1673 *count += 8;
1674 if (toCount->pDynamicState) {
1675 count_VkPipelineDynamicStateCreateInfo(
1676 featureBits, rootType,
1677 (const VkPipelineDynamicStateCreateInfo*)(toCount->pDynamicState), count);
1678 }
1679 uint64_t cgen_var_0;
1680 *count += 1 * 8;
1681 uint64_t cgen_var_1;
1682 *count += 1 * 8;
1683 *count += sizeof(uint32_t);
1684 uint64_t cgen_var_2;
1685 *count += 1 * 8;
1686 *count += sizeof(int32_t);
1687 }
1688
count_VkPushConstantRange(uint32_t featureBits,VkStructureType rootType,const VkPushConstantRange * toCount,size_t * count)1689 void count_VkPushConstantRange(uint32_t featureBits, VkStructureType rootType,
1690 const VkPushConstantRange* toCount, size_t* count) {
1691 (void)featureBits;
1692 (void)rootType;
1693 (void)toCount;
1694 (void)count;
1695 *count += sizeof(VkShaderStageFlags);
1696 *count += sizeof(uint32_t);
1697 *count += sizeof(uint32_t);
1698 }
1699
count_VkPipelineLayoutCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineLayoutCreateInfo * toCount,size_t * count)1700 void count_VkPipelineLayoutCreateInfo(uint32_t featureBits, VkStructureType rootType,
1701 const VkPipelineLayoutCreateInfo* toCount, size_t* count) {
1702 (void)featureBits;
1703 (void)rootType;
1704 (void)toCount;
1705 (void)count;
1706 *count += sizeof(VkStructureType);
1707 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1708 rootType = toCount->sType;
1709 }
1710 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1711 *count += sizeof(VkPipelineLayoutCreateFlags);
1712 *count += sizeof(uint32_t);
1713 if (toCount->setLayoutCount) {
1714 *count += toCount->setLayoutCount * 8;
1715 }
1716 *count += sizeof(uint32_t);
1717 if (toCount) {
1718 for (uint32_t i = 0; i < (uint32_t)toCount->pushConstantRangeCount; ++i) {
1719 count_VkPushConstantRange(
1720 featureBits, rootType,
1721 (const VkPushConstantRange*)(toCount->pPushConstantRanges + i), count);
1722 }
1723 }
1724 }
1725
count_VkSamplerCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkSamplerCreateInfo * toCount,size_t * count)1726 void count_VkSamplerCreateInfo(uint32_t featureBits, VkStructureType rootType,
1727 const VkSamplerCreateInfo* toCount, size_t* count) {
1728 (void)featureBits;
1729 (void)rootType;
1730 (void)toCount;
1731 (void)count;
1732 *count += sizeof(VkStructureType);
1733 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1734 rootType = toCount->sType;
1735 }
1736 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1737 *count += sizeof(VkSamplerCreateFlags);
1738 *count += sizeof(VkFilter);
1739 *count += sizeof(VkFilter);
1740 *count += sizeof(VkSamplerMipmapMode);
1741 *count += sizeof(VkSamplerAddressMode);
1742 *count += sizeof(VkSamplerAddressMode);
1743 *count += sizeof(VkSamplerAddressMode);
1744 *count += sizeof(float);
1745 *count += sizeof(VkBool32);
1746 *count += sizeof(float);
1747 *count += sizeof(VkBool32);
1748 *count += sizeof(VkCompareOp);
1749 *count += sizeof(float);
1750 *count += sizeof(float);
1751 *count += sizeof(VkBorderColor);
1752 *count += sizeof(VkBool32);
1753 }
1754
count_VkCopyDescriptorSet(uint32_t featureBits,VkStructureType rootType,const VkCopyDescriptorSet * toCount,size_t * count)1755 void count_VkCopyDescriptorSet(uint32_t featureBits, VkStructureType rootType,
1756 const VkCopyDescriptorSet* toCount, size_t* count) {
1757 (void)featureBits;
1758 (void)rootType;
1759 (void)toCount;
1760 (void)count;
1761 *count += sizeof(VkStructureType);
1762 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1763 rootType = toCount->sType;
1764 }
1765 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1766 uint64_t cgen_var_0;
1767 *count += 1 * 8;
1768 *count += sizeof(uint32_t);
1769 *count += sizeof(uint32_t);
1770 uint64_t cgen_var_1;
1771 *count += 1 * 8;
1772 *count += sizeof(uint32_t);
1773 *count += sizeof(uint32_t);
1774 *count += sizeof(uint32_t);
1775 }
1776
count_VkDescriptorBufferInfo(uint32_t featureBits,VkStructureType rootType,const VkDescriptorBufferInfo * toCount,size_t * count)1777 void count_VkDescriptorBufferInfo(uint32_t featureBits, VkStructureType rootType,
1778 const VkDescriptorBufferInfo* toCount, size_t* count) {
1779 (void)featureBits;
1780 (void)rootType;
1781 (void)toCount;
1782 (void)count;
1783 uint64_t cgen_var_0;
1784 *count += 1 * 8;
1785 *count += sizeof(VkDeviceSize);
1786 *count += sizeof(VkDeviceSize);
1787 }
1788
count_VkDescriptorImageInfo(uint32_t featureBits,VkStructureType rootType,const VkDescriptorImageInfo * toCount,size_t * count)1789 void count_VkDescriptorImageInfo(uint32_t featureBits, VkStructureType rootType,
1790 const VkDescriptorImageInfo* toCount, size_t* count) {
1791 (void)featureBits;
1792 (void)rootType;
1793 (void)toCount;
1794 (void)count;
1795 uint64_t cgen_var_0;
1796 *count += 1 * 8;
1797 uint64_t cgen_var_1;
1798 *count += 1 * 8;
1799 *count += sizeof(VkImageLayout);
1800 }
1801
count_VkDescriptorPoolSize(uint32_t featureBits,VkStructureType rootType,const VkDescriptorPoolSize * toCount,size_t * count)1802 void count_VkDescriptorPoolSize(uint32_t featureBits, VkStructureType rootType,
1803 const VkDescriptorPoolSize* toCount, size_t* count) {
1804 (void)featureBits;
1805 (void)rootType;
1806 (void)toCount;
1807 (void)count;
1808 *count += sizeof(VkDescriptorType);
1809 *count += sizeof(uint32_t);
1810 }
1811
count_VkDescriptorPoolCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkDescriptorPoolCreateInfo * toCount,size_t * count)1812 void count_VkDescriptorPoolCreateInfo(uint32_t featureBits, VkStructureType rootType,
1813 const VkDescriptorPoolCreateInfo* toCount, size_t* count) {
1814 (void)featureBits;
1815 (void)rootType;
1816 (void)toCount;
1817 (void)count;
1818 *count += sizeof(VkStructureType);
1819 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1820 rootType = toCount->sType;
1821 }
1822 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1823 *count += sizeof(VkDescriptorPoolCreateFlags);
1824 *count += sizeof(uint32_t);
1825 *count += sizeof(uint32_t);
1826 if (toCount) {
1827 for (uint32_t i = 0; i < (uint32_t)toCount->poolSizeCount; ++i) {
1828 count_VkDescriptorPoolSize(featureBits, rootType,
1829 (const VkDescriptorPoolSize*)(toCount->pPoolSizes + i),
1830 count);
1831 }
1832 }
1833 }
1834
count_VkDescriptorSetAllocateInfo(uint32_t featureBits,VkStructureType rootType,const VkDescriptorSetAllocateInfo * toCount,size_t * count)1835 void count_VkDescriptorSetAllocateInfo(uint32_t featureBits, VkStructureType rootType,
1836 const VkDescriptorSetAllocateInfo* toCount, size_t* count) {
1837 (void)featureBits;
1838 (void)rootType;
1839 (void)toCount;
1840 (void)count;
1841 *count += sizeof(VkStructureType);
1842 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1843 rootType = toCount->sType;
1844 }
1845 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1846 uint64_t cgen_var_0;
1847 *count += 1 * 8;
1848 *count += sizeof(uint32_t);
1849 if (toCount->descriptorSetCount) {
1850 *count += toCount->descriptorSetCount * 8;
1851 }
1852 }
1853
count_VkDescriptorSetLayoutBinding(uint32_t featureBits,VkStructureType rootType,const VkDescriptorSetLayoutBinding * toCount,size_t * count)1854 void count_VkDescriptorSetLayoutBinding(uint32_t featureBits, VkStructureType rootType,
1855 const VkDescriptorSetLayoutBinding* toCount,
1856 size_t* count) {
1857 (void)featureBits;
1858 (void)rootType;
1859 (void)toCount;
1860 (void)count;
1861 *count += sizeof(uint32_t);
1862 *count += sizeof(VkDescriptorType);
1863 *count += sizeof(uint32_t);
1864 *count += sizeof(VkShaderStageFlags);
1865 // WARNING PTR CHECK
1866 *count += 8;
1867 if (toCount->pImmutableSamplers) {
1868 if (toCount->descriptorCount) {
1869 *count += toCount->descriptorCount * 8;
1870 }
1871 }
1872 }
1873
count_VkDescriptorSetLayoutCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkDescriptorSetLayoutCreateInfo * toCount,size_t * count)1874 void count_VkDescriptorSetLayoutCreateInfo(uint32_t featureBits, VkStructureType rootType,
1875 const VkDescriptorSetLayoutCreateInfo* toCount,
1876 size_t* count) {
1877 (void)featureBits;
1878 (void)rootType;
1879 (void)toCount;
1880 (void)count;
1881 *count += sizeof(VkStructureType);
1882 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1883 rootType = toCount->sType;
1884 }
1885 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1886 *count += sizeof(VkDescriptorSetLayoutCreateFlags);
1887 *count += sizeof(uint32_t);
1888 if (toCount) {
1889 for (uint32_t i = 0; i < (uint32_t)toCount->bindingCount; ++i) {
1890 count_VkDescriptorSetLayoutBinding(
1891 featureBits, rootType,
1892 (const VkDescriptorSetLayoutBinding*)(toCount->pBindings + i), count);
1893 }
1894 }
1895 }
1896
count_VkWriteDescriptorSet(uint32_t featureBits,VkStructureType rootType,const VkWriteDescriptorSet * toCount,size_t * count)1897 void count_VkWriteDescriptorSet(uint32_t featureBits, VkStructureType rootType,
1898 const VkWriteDescriptorSet* toCount, size_t* count) {
1899 (void)featureBits;
1900 (void)rootType;
1901 (void)toCount;
1902 (void)count;
1903 *count += sizeof(VkStructureType);
1904 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1905 rootType = toCount->sType;
1906 }
1907 count_extension_struct(featureBits, rootType, toCount->pNext, count);
1908 uint64_t cgen_var_0;
1909 *count += 1 * 8;
1910 *count += sizeof(uint32_t);
1911 *count += sizeof(uint32_t);
1912 *count += sizeof(uint32_t);
1913 *count += sizeof(VkDescriptorType);
1914 // WARNING PTR CHECK
1915 *count += 8;
1916 if (toCount->pImageInfo) {
1917 if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
1918 ((VK_DESCRIPTOR_TYPE_SAMPLER == toCount->descriptorType) ||
1919 (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == toCount->descriptorType) ||
1920 (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == toCount->descriptorType) ||
1921 (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == toCount->descriptorType) ||
1922 (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == toCount->descriptorType)))) {
1923 if (toCount) {
1924 for (uint32_t i = 0; i < (uint32_t)toCount->descriptorCount; ++i) {
1925 count_VkDescriptorImageInfo(
1926 featureBits, rootType,
1927 (const VkDescriptorImageInfo*)(toCount->pImageInfo + i), count);
1928 }
1929 }
1930 }
1931 }
1932 // WARNING PTR CHECK
1933 *count += 8;
1934 if (toCount->pBufferInfo) {
1935 if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
1936 ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == toCount->descriptorType) ||
1937 (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == toCount->descriptorType) ||
1938 (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == toCount->descriptorType) ||
1939 (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == toCount->descriptorType)))) {
1940 if (toCount) {
1941 for (uint32_t i = 0; i < (uint32_t)toCount->descriptorCount; ++i) {
1942 count_VkDescriptorBufferInfo(
1943 featureBits, rootType,
1944 (const VkDescriptorBufferInfo*)(toCount->pBufferInfo + i), count);
1945 }
1946 }
1947 }
1948 }
1949 // WARNING PTR CHECK
1950 *count += 8;
1951 if (toCount->pTexelBufferView) {
1952 if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
1953 ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == toCount->descriptorType) ||
1954 (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == toCount->descriptorType)))) {
1955 if (toCount->descriptorCount) {
1956 *count += toCount->descriptorCount * 8;
1957 }
1958 }
1959 }
1960 }
1961
count_VkAttachmentDescription(uint32_t featureBits,VkStructureType rootType,const VkAttachmentDescription * toCount,size_t * count)1962 void count_VkAttachmentDescription(uint32_t featureBits, VkStructureType rootType,
1963 const VkAttachmentDescription* toCount, size_t* count) {
1964 (void)featureBits;
1965 (void)rootType;
1966 (void)toCount;
1967 (void)count;
1968 *count += sizeof(VkAttachmentDescriptionFlags);
1969 *count += sizeof(VkFormat);
1970 *count += sizeof(VkSampleCountFlagBits);
1971 *count += sizeof(VkAttachmentLoadOp);
1972 *count += sizeof(VkAttachmentStoreOp);
1973 *count += sizeof(VkAttachmentLoadOp);
1974 *count += sizeof(VkAttachmentStoreOp);
1975 *count += sizeof(VkImageLayout);
1976 *count += sizeof(VkImageLayout);
1977 }
1978
count_VkAttachmentReference(uint32_t featureBits,VkStructureType rootType,const VkAttachmentReference * toCount,size_t * count)1979 void count_VkAttachmentReference(uint32_t featureBits, VkStructureType rootType,
1980 const VkAttachmentReference* toCount, size_t* count) {
1981 (void)featureBits;
1982 (void)rootType;
1983 (void)toCount;
1984 (void)count;
1985 *count += sizeof(uint32_t);
1986 *count += sizeof(VkImageLayout);
1987 }
1988
count_VkFramebufferCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkFramebufferCreateInfo * toCount,size_t * count)1989 void count_VkFramebufferCreateInfo(uint32_t featureBits, VkStructureType rootType,
1990 const VkFramebufferCreateInfo* toCount, size_t* count) {
1991 (void)featureBits;
1992 (void)rootType;
1993 (void)toCount;
1994 (void)count;
1995 *count += sizeof(VkStructureType);
1996 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
1997 rootType = toCount->sType;
1998 }
1999 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2000 *count += sizeof(VkFramebufferCreateFlags);
2001 uint64_t cgen_var_0;
2002 *count += 1 * 8;
2003 *count += sizeof(uint32_t);
2004 if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
2005 (((toCount->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) == 0)))) {
2006 if (toCount->attachmentCount) {
2007 *count += toCount->attachmentCount * 8;
2008 }
2009 }
2010 *count += sizeof(uint32_t);
2011 *count += sizeof(uint32_t);
2012 *count += sizeof(uint32_t);
2013 }
2014
count_VkSubpassDescription(uint32_t featureBits,VkStructureType rootType,const VkSubpassDescription * toCount,size_t * count)2015 void count_VkSubpassDescription(uint32_t featureBits, VkStructureType rootType,
2016 const VkSubpassDescription* toCount, size_t* count) {
2017 (void)featureBits;
2018 (void)rootType;
2019 (void)toCount;
2020 (void)count;
2021 *count += sizeof(VkSubpassDescriptionFlags);
2022 *count += sizeof(VkPipelineBindPoint);
2023 *count += sizeof(uint32_t);
2024 if (toCount) {
2025 for (uint32_t i = 0; i < (uint32_t)toCount->inputAttachmentCount; ++i) {
2026 count_VkAttachmentReference(
2027 featureBits, rootType,
2028 (const VkAttachmentReference*)(toCount->pInputAttachments + i), count);
2029 }
2030 }
2031 *count += sizeof(uint32_t);
2032 if (toCount) {
2033 for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i) {
2034 count_VkAttachmentReference(
2035 featureBits, rootType,
2036 (const VkAttachmentReference*)(toCount->pColorAttachments + i), count);
2037 }
2038 }
2039 // WARNING PTR CHECK
2040 *count += 8;
2041 if (toCount->pResolveAttachments) {
2042 if (toCount) {
2043 for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i) {
2044 count_VkAttachmentReference(
2045 featureBits, rootType,
2046 (const VkAttachmentReference*)(toCount->pResolveAttachments + i), count);
2047 }
2048 }
2049 }
2050 // WARNING PTR CHECK
2051 *count += 8;
2052 if (toCount->pDepthStencilAttachment) {
2053 count_VkAttachmentReference(
2054 featureBits, rootType, (const VkAttachmentReference*)(toCount->pDepthStencilAttachment),
2055 count);
2056 }
2057 *count += sizeof(uint32_t);
2058 if (toCount) {
2059 *count += toCount->preserveAttachmentCount * sizeof(const uint32_t);
2060 }
2061 }
2062
count_VkSubpassDependency(uint32_t featureBits,VkStructureType rootType,const VkSubpassDependency * toCount,size_t * count)2063 void count_VkSubpassDependency(uint32_t featureBits, VkStructureType rootType,
2064 const VkSubpassDependency* toCount, size_t* count) {
2065 (void)featureBits;
2066 (void)rootType;
2067 (void)toCount;
2068 (void)count;
2069 *count += sizeof(uint32_t);
2070 *count += sizeof(uint32_t);
2071 *count += sizeof(VkPipelineStageFlags);
2072 *count += sizeof(VkPipelineStageFlags);
2073 *count += sizeof(VkAccessFlags);
2074 *count += sizeof(VkAccessFlags);
2075 *count += sizeof(VkDependencyFlags);
2076 }
2077
count_VkRenderPassCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkRenderPassCreateInfo * toCount,size_t * count)2078 void count_VkRenderPassCreateInfo(uint32_t featureBits, VkStructureType rootType,
2079 const VkRenderPassCreateInfo* toCount, size_t* count) {
2080 (void)featureBits;
2081 (void)rootType;
2082 (void)toCount;
2083 (void)count;
2084 *count += sizeof(VkStructureType);
2085 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2086 rootType = toCount->sType;
2087 }
2088 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2089 *count += sizeof(VkRenderPassCreateFlags);
2090 *count += sizeof(uint32_t);
2091 if (toCount) {
2092 for (uint32_t i = 0; i < (uint32_t)toCount->attachmentCount; ++i) {
2093 count_VkAttachmentDescription(
2094 featureBits, rootType, (const VkAttachmentDescription*)(toCount->pAttachments + i),
2095 count);
2096 }
2097 }
2098 *count += sizeof(uint32_t);
2099 if (toCount) {
2100 for (uint32_t i = 0; i < (uint32_t)toCount->subpassCount; ++i) {
2101 count_VkSubpassDescription(featureBits, rootType,
2102 (const VkSubpassDescription*)(toCount->pSubpasses + i),
2103 count);
2104 }
2105 }
2106 *count += sizeof(uint32_t);
2107 if (toCount) {
2108 for (uint32_t i = 0; i < (uint32_t)toCount->dependencyCount; ++i) {
2109 count_VkSubpassDependency(featureBits, rootType,
2110 (const VkSubpassDependency*)(toCount->pDependencies + i),
2111 count);
2112 }
2113 }
2114 }
2115
count_VkCommandPoolCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkCommandPoolCreateInfo * toCount,size_t * count)2116 void count_VkCommandPoolCreateInfo(uint32_t featureBits, VkStructureType rootType,
2117 const VkCommandPoolCreateInfo* toCount, size_t* count) {
2118 (void)featureBits;
2119 (void)rootType;
2120 (void)toCount;
2121 (void)count;
2122 *count += sizeof(VkStructureType);
2123 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2124 rootType = toCount->sType;
2125 }
2126 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2127 *count += sizeof(VkCommandPoolCreateFlags);
2128 *count += sizeof(uint32_t);
2129 }
2130
count_VkCommandBufferAllocateInfo(uint32_t featureBits,VkStructureType rootType,const VkCommandBufferAllocateInfo * toCount,size_t * count)2131 void count_VkCommandBufferAllocateInfo(uint32_t featureBits, VkStructureType rootType,
2132 const VkCommandBufferAllocateInfo* toCount, size_t* count) {
2133 (void)featureBits;
2134 (void)rootType;
2135 (void)toCount;
2136 (void)count;
2137 *count += sizeof(VkStructureType);
2138 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2139 rootType = toCount->sType;
2140 }
2141 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2142 uint64_t cgen_var_0;
2143 *count += 1 * 8;
2144 *count += sizeof(VkCommandBufferLevel);
2145 *count += sizeof(uint32_t);
2146 }
2147
count_VkCommandBufferInheritanceInfo(uint32_t featureBits,VkStructureType rootType,const VkCommandBufferInheritanceInfo * toCount,size_t * count)2148 void count_VkCommandBufferInheritanceInfo(uint32_t featureBits, VkStructureType rootType,
2149 const VkCommandBufferInheritanceInfo* toCount,
2150 size_t* count) {
2151 (void)featureBits;
2152 (void)rootType;
2153 (void)toCount;
2154 (void)count;
2155 *count += sizeof(VkStructureType);
2156 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2157 rootType = toCount->sType;
2158 }
2159 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2160 uint64_t cgen_var_0;
2161 *count += 1 * 8;
2162 *count += sizeof(uint32_t);
2163 uint64_t cgen_var_1;
2164 *count += 1 * 8;
2165 *count += sizeof(VkBool32);
2166 *count += sizeof(VkQueryControlFlags);
2167 *count += sizeof(VkQueryPipelineStatisticFlags);
2168 }
2169
count_VkCommandBufferBeginInfo(uint32_t featureBits,VkStructureType rootType,const VkCommandBufferBeginInfo * toCount,size_t * count)2170 void count_VkCommandBufferBeginInfo(uint32_t featureBits, VkStructureType rootType,
2171 const VkCommandBufferBeginInfo* toCount, size_t* count) {
2172 (void)featureBits;
2173 (void)rootType;
2174 (void)toCount;
2175 (void)count;
2176 *count += sizeof(VkStructureType);
2177 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2178 rootType = toCount->sType;
2179 }
2180 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2181 *count += sizeof(VkCommandBufferUsageFlags);
2182 // WARNING PTR CHECK
2183 *count += 8;
2184 if (toCount->pInheritanceInfo) {
2185 count_VkCommandBufferInheritanceInfo(
2186 featureBits, rootType,
2187 (const VkCommandBufferInheritanceInfo*)(toCount->pInheritanceInfo), count);
2188 }
2189 }
2190
count_VkBufferCopy(uint32_t featureBits,VkStructureType rootType,const VkBufferCopy * toCount,size_t * count)2191 void count_VkBufferCopy(uint32_t featureBits, VkStructureType rootType, const VkBufferCopy* toCount,
2192 size_t* count) {
2193 (void)featureBits;
2194 (void)rootType;
2195 (void)toCount;
2196 (void)count;
2197 *count += sizeof(VkDeviceSize);
2198 *count += sizeof(VkDeviceSize);
2199 *count += sizeof(VkDeviceSize);
2200 }
2201
count_VkImageSubresourceLayers(uint32_t featureBits,VkStructureType rootType,const VkImageSubresourceLayers * toCount,size_t * count)2202 void count_VkImageSubresourceLayers(uint32_t featureBits, VkStructureType rootType,
2203 const VkImageSubresourceLayers* toCount, size_t* count) {
2204 (void)featureBits;
2205 (void)rootType;
2206 (void)toCount;
2207 (void)count;
2208 *count += sizeof(VkImageAspectFlags);
2209 *count += sizeof(uint32_t);
2210 *count += sizeof(uint32_t);
2211 *count += sizeof(uint32_t);
2212 }
2213
count_VkBufferImageCopy(uint32_t featureBits,VkStructureType rootType,const VkBufferImageCopy * toCount,size_t * count)2214 void count_VkBufferImageCopy(uint32_t featureBits, VkStructureType rootType,
2215 const VkBufferImageCopy* toCount, size_t* count) {
2216 (void)featureBits;
2217 (void)rootType;
2218 (void)toCount;
2219 (void)count;
2220 *count += sizeof(VkDeviceSize);
2221 *count += sizeof(uint32_t);
2222 *count += sizeof(uint32_t);
2223 count_VkImageSubresourceLayers(featureBits, rootType,
2224 (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
2225 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->imageOffset), count);
2226 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->imageExtent), count);
2227 }
2228
count_VkClearColorValue(uint32_t featureBits,VkStructureType rootType,const VkClearColorValue * toCount,size_t * count)2229 void count_VkClearColorValue(uint32_t featureBits, VkStructureType rootType,
2230 const VkClearColorValue* toCount, size_t* count) {
2231 (void)featureBits;
2232 (void)rootType;
2233 (void)toCount;
2234 (void)count;
2235 *count += 4 * sizeof(float);
2236 }
2237
count_VkClearDepthStencilValue(uint32_t featureBits,VkStructureType rootType,const VkClearDepthStencilValue * toCount,size_t * count)2238 void count_VkClearDepthStencilValue(uint32_t featureBits, VkStructureType rootType,
2239 const VkClearDepthStencilValue* toCount, size_t* count) {
2240 (void)featureBits;
2241 (void)rootType;
2242 (void)toCount;
2243 (void)count;
2244 *count += sizeof(float);
2245 *count += sizeof(uint32_t);
2246 }
2247
count_VkClearValue(uint32_t featureBits,VkStructureType rootType,const VkClearValue * toCount,size_t * count)2248 void count_VkClearValue(uint32_t featureBits, VkStructureType rootType, const VkClearValue* toCount,
2249 size_t* count) {
2250 (void)featureBits;
2251 (void)rootType;
2252 (void)toCount;
2253 (void)count;
2254 count_VkClearColorValue(featureBits, rootType, (VkClearColorValue*)(&toCount->color), count);
2255 }
2256
count_VkClearAttachment(uint32_t featureBits,VkStructureType rootType,const VkClearAttachment * toCount,size_t * count)2257 void count_VkClearAttachment(uint32_t featureBits, VkStructureType rootType,
2258 const VkClearAttachment* toCount, size_t* count) {
2259 (void)featureBits;
2260 (void)rootType;
2261 (void)toCount;
2262 (void)count;
2263 *count += sizeof(VkImageAspectFlags);
2264 *count += sizeof(uint32_t);
2265 count_VkClearValue(featureBits, rootType, (VkClearValue*)(&toCount->clearValue), count);
2266 }
2267
count_VkClearRect(uint32_t featureBits,VkStructureType rootType,const VkClearRect * toCount,size_t * count)2268 void count_VkClearRect(uint32_t featureBits, VkStructureType rootType, const VkClearRect* toCount,
2269 size_t* count) {
2270 (void)featureBits;
2271 (void)rootType;
2272 (void)toCount;
2273 (void)count;
2274 count_VkRect2D(featureBits, rootType, (VkRect2D*)(&toCount->rect), count);
2275 *count += sizeof(uint32_t);
2276 *count += sizeof(uint32_t);
2277 }
2278
count_VkImageBlit(uint32_t featureBits,VkStructureType rootType,const VkImageBlit * toCount,size_t * count)2279 void count_VkImageBlit(uint32_t featureBits, VkStructureType rootType, const VkImageBlit* toCount,
2280 size_t* count) {
2281 (void)featureBits;
2282 (void)rootType;
2283 (void)toCount;
2284 (void)count;
2285 count_VkImageSubresourceLayers(featureBits, rootType,
2286 (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
2287 for (uint32_t i = 0; i < (uint32_t)2; ++i) {
2288 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(toCount->srcOffsets + i), count);
2289 }
2290 count_VkImageSubresourceLayers(featureBits, rootType,
2291 (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
2292 for (uint32_t i = 0; i < (uint32_t)2; ++i) {
2293 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(toCount->dstOffsets + i), count);
2294 }
2295 }
2296
count_VkImageCopy(uint32_t featureBits,VkStructureType rootType,const VkImageCopy * toCount,size_t * count)2297 void count_VkImageCopy(uint32_t featureBits, VkStructureType rootType, const VkImageCopy* toCount,
2298 size_t* count) {
2299 (void)featureBits;
2300 (void)rootType;
2301 (void)toCount;
2302 (void)count;
2303 count_VkImageSubresourceLayers(featureBits, rootType,
2304 (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
2305 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->srcOffset), count);
2306 count_VkImageSubresourceLayers(featureBits, rootType,
2307 (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
2308 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->dstOffset), count);
2309 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->extent), count);
2310 }
2311
count_VkImageResolve(uint32_t featureBits,VkStructureType rootType,const VkImageResolve * toCount,size_t * count)2312 void count_VkImageResolve(uint32_t featureBits, VkStructureType rootType,
2313 const VkImageResolve* toCount, size_t* count) {
2314 (void)featureBits;
2315 (void)rootType;
2316 (void)toCount;
2317 (void)count;
2318 count_VkImageSubresourceLayers(featureBits, rootType,
2319 (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
2320 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->srcOffset), count);
2321 count_VkImageSubresourceLayers(featureBits, rootType,
2322 (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
2323 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->dstOffset), count);
2324 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->extent), count);
2325 }
2326
count_VkRenderPassBeginInfo(uint32_t featureBits,VkStructureType rootType,const VkRenderPassBeginInfo * toCount,size_t * count)2327 void count_VkRenderPassBeginInfo(uint32_t featureBits, VkStructureType rootType,
2328 const VkRenderPassBeginInfo* toCount, size_t* count) {
2329 (void)featureBits;
2330 (void)rootType;
2331 (void)toCount;
2332 (void)count;
2333 *count += sizeof(VkStructureType);
2334 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2335 rootType = toCount->sType;
2336 }
2337 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2338 uint64_t cgen_var_0;
2339 *count += 1 * 8;
2340 uint64_t cgen_var_1;
2341 *count += 1 * 8;
2342 count_VkRect2D(featureBits, rootType, (VkRect2D*)(&toCount->renderArea), count);
2343 *count += sizeof(uint32_t);
2344 // WARNING PTR CHECK
2345 *count += 8;
2346 if (toCount->pClearValues) {
2347 if (toCount) {
2348 for (uint32_t i = 0; i < (uint32_t)toCount->clearValueCount; ++i) {
2349 count_VkClearValue(featureBits, rootType,
2350 (const VkClearValue*)(toCount->pClearValues + i), count);
2351 }
2352 }
2353 }
2354 }
2355
2356 #endif
2357 #ifdef VK_VERSION_1_1
count_VkPhysicalDeviceSubgroupProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceSubgroupProperties * toCount,size_t * count)2358 void count_VkPhysicalDeviceSubgroupProperties(uint32_t featureBits, VkStructureType rootType,
2359 const VkPhysicalDeviceSubgroupProperties* toCount,
2360 size_t* count) {
2361 (void)featureBits;
2362 (void)rootType;
2363 (void)toCount;
2364 (void)count;
2365 *count += sizeof(VkStructureType);
2366 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2367 rootType = toCount->sType;
2368 }
2369 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2370 *count += sizeof(uint32_t);
2371 *count += sizeof(VkShaderStageFlags);
2372 *count += sizeof(VkSubgroupFeatureFlags);
2373 *count += sizeof(VkBool32);
2374 }
2375
count_VkBindBufferMemoryInfo(uint32_t featureBits,VkStructureType rootType,const VkBindBufferMemoryInfo * toCount,size_t * count)2376 void count_VkBindBufferMemoryInfo(uint32_t featureBits, VkStructureType rootType,
2377 const VkBindBufferMemoryInfo* toCount, size_t* count) {
2378 (void)featureBits;
2379 (void)rootType;
2380 (void)toCount;
2381 (void)count;
2382 *count += sizeof(VkStructureType);
2383 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2384 rootType = toCount->sType;
2385 }
2386 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2387 uint64_t cgen_var_0;
2388 *count += 1 * 8;
2389 uint64_t cgen_var_1;
2390 *count += 1 * 8;
2391 *count += sizeof(VkDeviceSize);
2392 }
2393
count_VkBindImageMemoryInfo(uint32_t featureBits,VkStructureType rootType,const VkBindImageMemoryInfo * toCount,size_t * count)2394 void count_VkBindImageMemoryInfo(uint32_t featureBits, VkStructureType rootType,
2395 const VkBindImageMemoryInfo* toCount, size_t* count) {
2396 (void)featureBits;
2397 (void)rootType;
2398 (void)toCount;
2399 (void)count;
2400 *count += sizeof(VkStructureType);
2401 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2402 rootType = toCount->sType;
2403 }
2404 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2405 uint64_t cgen_var_0;
2406 *count += 1 * 8;
2407 uint64_t cgen_var_1;
2408 *count += 1 * 8;
2409 *count += sizeof(VkDeviceSize);
2410 }
2411
count_VkPhysicalDevice16BitStorageFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDevice16BitStorageFeatures * toCount,size_t * count)2412 void count_VkPhysicalDevice16BitStorageFeatures(uint32_t featureBits, VkStructureType rootType,
2413 const VkPhysicalDevice16BitStorageFeatures* toCount,
2414 size_t* count) {
2415 (void)featureBits;
2416 (void)rootType;
2417 (void)toCount;
2418 (void)count;
2419 *count += sizeof(VkStructureType);
2420 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2421 rootType = toCount->sType;
2422 }
2423 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2424 *count += sizeof(VkBool32);
2425 *count += sizeof(VkBool32);
2426 *count += sizeof(VkBool32);
2427 *count += sizeof(VkBool32);
2428 }
2429
count_VkMemoryDedicatedRequirements(uint32_t featureBits,VkStructureType rootType,const VkMemoryDedicatedRequirements * toCount,size_t * count)2430 void count_VkMemoryDedicatedRequirements(uint32_t featureBits, VkStructureType rootType,
2431 const VkMemoryDedicatedRequirements* toCount,
2432 size_t* count) {
2433 (void)featureBits;
2434 (void)rootType;
2435 (void)toCount;
2436 (void)count;
2437 *count += sizeof(VkStructureType);
2438 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2439 rootType = toCount->sType;
2440 }
2441 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2442 *count += sizeof(VkBool32);
2443 *count += sizeof(VkBool32);
2444 }
2445
count_VkMemoryDedicatedAllocateInfo(uint32_t featureBits,VkStructureType rootType,const VkMemoryDedicatedAllocateInfo * toCount,size_t * count)2446 void count_VkMemoryDedicatedAllocateInfo(uint32_t featureBits, VkStructureType rootType,
2447 const VkMemoryDedicatedAllocateInfo* toCount,
2448 size_t* count) {
2449 (void)featureBits;
2450 (void)rootType;
2451 (void)toCount;
2452 (void)count;
2453 *count += sizeof(VkStructureType);
2454 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2455 rootType = toCount->sType;
2456 }
2457 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2458 uint64_t cgen_var_0;
2459 *count += 1 * 8;
2460 uint64_t cgen_var_1;
2461 *count += 1 * 8;
2462 }
2463
count_VkMemoryAllocateFlagsInfo(uint32_t featureBits,VkStructureType rootType,const VkMemoryAllocateFlagsInfo * toCount,size_t * count)2464 void count_VkMemoryAllocateFlagsInfo(uint32_t featureBits, VkStructureType rootType,
2465 const VkMemoryAllocateFlagsInfo* toCount, size_t* count) {
2466 (void)featureBits;
2467 (void)rootType;
2468 (void)toCount;
2469 (void)count;
2470 *count += sizeof(VkStructureType);
2471 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2472 rootType = toCount->sType;
2473 }
2474 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2475 *count += sizeof(VkMemoryAllocateFlags);
2476 *count += sizeof(uint32_t);
2477 }
2478
count_VkDeviceGroupRenderPassBeginInfo(uint32_t featureBits,VkStructureType rootType,const VkDeviceGroupRenderPassBeginInfo * toCount,size_t * count)2479 void count_VkDeviceGroupRenderPassBeginInfo(uint32_t featureBits, VkStructureType rootType,
2480 const VkDeviceGroupRenderPassBeginInfo* toCount,
2481 size_t* count) {
2482 (void)featureBits;
2483 (void)rootType;
2484 (void)toCount;
2485 (void)count;
2486 *count += sizeof(VkStructureType);
2487 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2488 rootType = toCount->sType;
2489 }
2490 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2491 *count += sizeof(uint32_t);
2492 *count += sizeof(uint32_t);
2493 if (toCount) {
2494 for (uint32_t i = 0; i < (uint32_t)toCount->deviceRenderAreaCount; ++i) {
2495 count_VkRect2D(featureBits, rootType,
2496 (const VkRect2D*)(toCount->pDeviceRenderAreas + i), count);
2497 }
2498 }
2499 }
2500
count_VkDeviceGroupCommandBufferBeginInfo(uint32_t featureBits,VkStructureType rootType,const VkDeviceGroupCommandBufferBeginInfo * toCount,size_t * count)2501 void count_VkDeviceGroupCommandBufferBeginInfo(uint32_t featureBits, VkStructureType rootType,
2502 const VkDeviceGroupCommandBufferBeginInfo* toCount,
2503 size_t* count) {
2504 (void)featureBits;
2505 (void)rootType;
2506 (void)toCount;
2507 (void)count;
2508 *count += sizeof(VkStructureType);
2509 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2510 rootType = toCount->sType;
2511 }
2512 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2513 *count += sizeof(uint32_t);
2514 }
2515
count_VkDeviceGroupSubmitInfo(uint32_t featureBits,VkStructureType rootType,const VkDeviceGroupSubmitInfo * toCount,size_t * count)2516 void count_VkDeviceGroupSubmitInfo(uint32_t featureBits, VkStructureType rootType,
2517 const VkDeviceGroupSubmitInfo* toCount, size_t* count) {
2518 (void)featureBits;
2519 (void)rootType;
2520 (void)toCount;
2521 (void)count;
2522 *count += sizeof(VkStructureType);
2523 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2524 rootType = toCount->sType;
2525 }
2526 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2527 *count += sizeof(uint32_t);
2528 if (toCount) {
2529 *count += toCount->waitSemaphoreCount * sizeof(const uint32_t);
2530 }
2531 *count += sizeof(uint32_t);
2532 if (toCount) {
2533 *count += toCount->commandBufferCount * sizeof(const uint32_t);
2534 }
2535 *count += sizeof(uint32_t);
2536 if (toCount) {
2537 *count += toCount->signalSemaphoreCount * sizeof(const uint32_t);
2538 }
2539 }
2540
count_VkDeviceGroupBindSparseInfo(uint32_t featureBits,VkStructureType rootType,const VkDeviceGroupBindSparseInfo * toCount,size_t * count)2541 void count_VkDeviceGroupBindSparseInfo(uint32_t featureBits, VkStructureType rootType,
2542 const VkDeviceGroupBindSparseInfo* toCount, size_t* count) {
2543 (void)featureBits;
2544 (void)rootType;
2545 (void)toCount;
2546 (void)count;
2547 *count += sizeof(VkStructureType);
2548 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2549 rootType = toCount->sType;
2550 }
2551 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2552 *count += sizeof(uint32_t);
2553 *count += sizeof(uint32_t);
2554 }
2555
count_VkBindBufferMemoryDeviceGroupInfo(uint32_t featureBits,VkStructureType rootType,const VkBindBufferMemoryDeviceGroupInfo * toCount,size_t * count)2556 void count_VkBindBufferMemoryDeviceGroupInfo(uint32_t featureBits, VkStructureType rootType,
2557 const VkBindBufferMemoryDeviceGroupInfo* toCount,
2558 size_t* count) {
2559 (void)featureBits;
2560 (void)rootType;
2561 (void)toCount;
2562 (void)count;
2563 *count += sizeof(VkStructureType);
2564 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2565 rootType = toCount->sType;
2566 }
2567 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2568 *count += sizeof(uint32_t);
2569 if (toCount) {
2570 *count += toCount->deviceIndexCount * sizeof(const uint32_t);
2571 }
2572 }
2573
count_VkBindImageMemoryDeviceGroupInfo(uint32_t featureBits,VkStructureType rootType,const VkBindImageMemoryDeviceGroupInfo * toCount,size_t * count)2574 void count_VkBindImageMemoryDeviceGroupInfo(uint32_t featureBits, VkStructureType rootType,
2575 const VkBindImageMemoryDeviceGroupInfo* toCount,
2576 size_t* count) {
2577 (void)featureBits;
2578 (void)rootType;
2579 (void)toCount;
2580 (void)count;
2581 *count += sizeof(VkStructureType);
2582 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2583 rootType = toCount->sType;
2584 }
2585 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2586 *count += sizeof(uint32_t);
2587 if (toCount) {
2588 *count += toCount->deviceIndexCount * sizeof(const uint32_t);
2589 }
2590 *count += sizeof(uint32_t);
2591 if (toCount) {
2592 for (uint32_t i = 0; i < (uint32_t)toCount->splitInstanceBindRegionCount; ++i) {
2593 count_VkRect2D(featureBits, rootType,
2594 (const VkRect2D*)(toCount->pSplitInstanceBindRegions + i), count);
2595 }
2596 }
2597 }
2598
count_VkPhysicalDeviceGroupProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceGroupProperties * toCount,size_t * count)2599 void count_VkPhysicalDeviceGroupProperties(uint32_t featureBits, VkStructureType rootType,
2600 const VkPhysicalDeviceGroupProperties* toCount,
2601 size_t* count) {
2602 (void)featureBits;
2603 (void)rootType;
2604 (void)toCount;
2605 (void)count;
2606 *count += sizeof(VkStructureType);
2607 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2608 rootType = toCount->sType;
2609 }
2610 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2611 *count += sizeof(uint32_t);
2612 *count += VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice);
2613 *count += sizeof(VkBool32);
2614 }
2615
count_VkDeviceGroupDeviceCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkDeviceGroupDeviceCreateInfo * toCount,size_t * count)2616 void count_VkDeviceGroupDeviceCreateInfo(uint32_t featureBits, VkStructureType rootType,
2617 const VkDeviceGroupDeviceCreateInfo* toCount,
2618 size_t* count) {
2619 (void)featureBits;
2620 (void)rootType;
2621 (void)toCount;
2622 (void)count;
2623 *count += sizeof(VkStructureType);
2624 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2625 rootType = toCount->sType;
2626 }
2627 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2628 *count += sizeof(uint32_t);
2629 if (toCount->physicalDeviceCount) {
2630 *count += toCount->physicalDeviceCount * 8;
2631 }
2632 }
2633
count_VkBufferMemoryRequirementsInfo2(uint32_t featureBits,VkStructureType rootType,const VkBufferMemoryRequirementsInfo2 * toCount,size_t * count)2634 void count_VkBufferMemoryRequirementsInfo2(uint32_t featureBits, VkStructureType rootType,
2635 const VkBufferMemoryRequirementsInfo2* toCount,
2636 size_t* count) {
2637 (void)featureBits;
2638 (void)rootType;
2639 (void)toCount;
2640 (void)count;
2641 *count += sizeof(VkStructureType);
2642 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2643 rootType = toCount->sType;
2644 }
2645 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2646 uint64_t cgen_var_0;
2647 *count += 1 * 8;
2648 }
2649
count_VkImageMemoryRequirementsInfo2(uint32_t featureBits,VkStructureType rootType,const VkImageMemoryRequirementsInfo2 * toCount,size_t * count)2650 void count_VkImageMemoryRequirementsInfo2(uint32_t featureBits, VkStructureType rootType,
2651 const VkImageMemoryRequirementsInfo2* toCount,
2652 size_t* count) {
2653 (void)featureBits;
2654 (void)rootType;
2655 (void)toCount;
2656 (void)count;
2657 *count += sizeof(VkStructureType);
2658 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2659 rootType = toCount->sType;
2660 }
2661 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2662 uint64_t cgen_var_0;
2663 *count += 1 * 8;
2664 }
2665
count_VkImageSparseMemoryRequirementsInfo2(uint32_t featureBits,VkStructureType rootType,const VkImageSparseMemoryRequirementsInfo2 * toCount,size_t * count)2666 void count_VkImageSparseMemoryRequirementsInfo2(uint32_t featureBits, VkStructureType rootType,
2667 const VkImageSparseMemoryRequirementsInfo2* toCount,
2668 size_t* count) {
2669 (void)featureBits;
2670 (void)rootType;
2671 (void)toCount;
2672 (void)count;
2673 *count += sizeof(VkStructureType);
2674 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2675 rootType = toCount->sType;
2676 }
2677 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2678 uint64_t cgen_var_0;
2679 *count += 1 * 8;
2680 }
2681
count_VkMemoryRequirements2(uint32_t featureBits,VkStructureType rootType,const VkMemoryRequirements2 * toCount,size_t * count)2682 void count_VkMemoryRequirements2(uint32_t featureBits, VkStructureType rootType,
2683 const VkMemoryRequirements2* toCount, size_t* count) {
2684 (void)featureBits;
2685 (void)rootType;
2686 (void)toCount;
2687 (void)count;
2688 *count += sizeof(VkStructureType);
2689 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2690 rootType = toCount->sType;
2691 }
2692 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2693 count_VkMemoryRequirements(featureBits, rootType,
2694 (VkMemoryRequirements*)(&toCount->memoryRequirements), count);
2695 }
2696
count_VkSparseImageMemoryRequirements2(uint32_t featureBits,VkStructureType rootType,const VkSparseImageMemoryRequirements2 * toCount,size_t * count)2697 void count_VkSparseImageMemoryRequirements2(uint32_t featureBits, VkStructureType rootType,
2698 const VkSparseImageMemoryRequirements2* toCount,
2699 size_t* count) {
2700 (void)featureBits;
2701 (void)rootType;
2702 (void)toCount;
2703 (void)count;
2704 *count += sizeof(VkStructureType);
2705 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2706 rootType = toCount->sType;
2707 }
2708 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2709 count_VkSparseImageMemoryRequirements(
2710 featureBits, rootType, (VkSparseImageMemoryRequirements*)(&toCount->memoryRequirements),
2711 count);
2712 }
2713
count_VkPhysicalDeviceFeatures2(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceFeatures2 * toCount,size_t * count)2714 void count_VkPhysicalDeviceFeatures2(uint32_t featureBits, VkStructureType rootType,
2715 const VkPhysicalDeviceFeatures2* toCount, size_t* count) {
2716 (void)featureBits;
2717 (void)rootType;
2718 (void)toCount;
2719 (void)count;
2720 *count += sizeof(VkStructureType);
2721 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2722 rootType = toCount->sType;
2723 }
2724 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2725 count_VkPhysicalDeviceFeatures(featureBits, rootType,
2726 (VkPhysicalDeviceFeatures*)(&toCount->features), count);
2727 }
2728
count_VkPhysicalDeviceProperties2(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceProperties2 * toCount,size_t * count)2729 void count_VkPhysicalDeviceProperties2(uint32_t featureBits, VkStructureType rootType,
2730 const VkPhysicalDeviceProperties2* toCount, size_t* count) {
2731 (void)featureBits;
2732 (void)rootType;
2733 (void)toCount;
2734 (void)count;
2735 *count += sizeof(VkStructureType);
2736 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2737 rootType = toCount->sType;
2738 }
2739 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2740 count_VkPhysicalDeviceProperties(featureBits, rootType,
2741 (VkPhysicalDeviceProperties*)(&toCount->properties), count);
2742 }
2743
count_VkFormatProperties2(uint32_t featureBits,VkStructureType rootType,const VkFormatProperties2 * toCount,size_t * count)2744 void count_VkFormatProperties2(uint32_t featureBits, VkStructureType rootType,
2745 const VkFormatProperties2* toCount, size_t* count) {
2746 (void)featureBits;
2747 (void)rootType;
2748 (void)toCount;
2749 (void)count;
2750 *count += sizeof(VkStructureType);
2751 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2752 rootType = toCount->sType;
2753 }
2754 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2755 count_VkFormatProperties(featureBits, rootType,
2756 (VkFormatProperties*)(&toCount->formatProperties), count);
2757 }
2758
count_VkImageFormatProperties2(uint32_t featureBits,VkStructureType rootType,const VkImageFormatProperties2 * toCount,size_t * count)2759 void count_VkImageFormatProperties2(uint32_t featureBits, VkStructureType rootType,
2760 const VkImageFormatProperties2* toCount, size_t* count) {
2761 (void)featureBits;
2762 (void)rootType;
2763 (void)toCount;
2764 (void)count;
2765 *count += sizeof(VkStructureType);
2766 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2767 rootType = toCount->sType;
2768 }
2769 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2770 count_VkImageFormatProperties(
2771 featureBits, rootType, (VkImageFormatProperties*)(&toCount->imageFormatProperties), count);
2772 }
2773
count_VkPhysicalDeviceImageFormatInfo2(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceImageFormatInfo2 * toCount,size_t * count)2774 void count_VkPhysicalDeviceImageFormatInfo2(uint32_t featureBits, VkStructureType rootType,
2775 const VkPhysicalDeviceImageFormatInfo2* toCount,
2776 size_t* count) {
2777 (void)featureBits;
2778 (void)rootType;
2779 (void)toCount;
2780 (void)count;
2781 *count += sizeof(VkStructureType);
2782 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2783 rootType = toCount->sType;
2784 }
2785 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2786 *count += sizeof(VkFormat);
2787 *count += sizeof(VkImageType);
2788 *count += sizeof(VkImageTiling);
2789 *count += sizeof(VkImageUsageFlags);
2790 *count += sizeof(VkImageCreateFlags);
2791 }
2792
count_VkQueueFamilyProperties2(uint32_t featureBits,VkStructureType rootType,const VkQueueFamilyProperties2 * toCount,size_t * count)2793 void count_VkQueueFamilyProperties2(uint32_t featureBits, VkStructureType rootType,
2794 const VkQueueFamilyProperties2* toCount, size_t* count) {
2795 (void)featureBits;
2796 (void)rootType;
2797 (void)toCount;
2798 (void)count;
2799 *count += sizeof(VkStructureType);
2800 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2801 rootType = toCount->sType;
2802 }
2803 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2804 count_VkQueueFamilyProperties(
2805 featureBits, rootType, (VkQueueFamilyProperties*)(&toCount->queueFamilyProperties), count);
2806 }
2807
count_VkPhysicalDeviceMemoryProperties2(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceMemoryProperties2 * toCount,size_t * count)2808 void count_VkPhysicalDeviceMemoryProperties2(uint32_t featureBits, VkStructureType rootType,
2809 const VkPhysicalDeviceMemoryProperties2* toCount,
2810 size_t* count) {
2811 (void)featureBits;
2812 (void)rootType;
2813 (void)toCount;
2814 (void)count;
2815 *count += sizeof(VkStructureType);
2816 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2817 rootType = toCount->sType;
2818 }
2819 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2820 count_VkPhysicalDeviceMemoryProperties(
2821 featureBits, rootType, (VkPhysicalDeviceMemoryProperties*)(&toCount->memoryProperties),
2822 count);
2823 }
2824
count_VkSparseImageFormatProperties2(uint32_t featureBits,VkStructureType rootType,const VkSparseImageFormatProperties2 * toCount,size_t * count)2825 void count_VkSparseImageFormatProperties2(uint32_t featureBits, VkStructureType rootType,
2826 const VkSparseImageFormatProperties2* toCount,
2827 size_t* count) {
2828 (void)featureBits;
2829 (void)rootType;
2830 (void)toCount;
2831 (void)count;
2832 *count += sizeof(VkStructureType);
2833 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2834 rootType = toCount->sType;
2835 }
2836 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2837 count_VkSparseImageFormatProperties(
2838 featureBits, rootType, (VkSparseImageFormatProperties*)(&toCount->properties), count);
2839 }
2840
count_VkPhysicalDeviceSparseImageFormatInfo2(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceSparseImageFormatInfo2 * toCount,size_t * count)2841 void count_VkPhysicalDeviceSparseImageFormatInfo2(
2842 uint32_t featureBits, VkStructureType rootType,
2843 const VkPhysicalDeviceSparseImageFormatInfo2* toCount, size_t* count) {
2844 (void)featureBits;
2845 (void)rootType;
2846 (void)toCount;
2847 (void)count;
2848 *count += sizeof(VkStructureType);
2849 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2850 rootType = toCount->sType;
2851 }
2852 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2853 *count += sizeof(VkFormat);
2854 *count += sizeof(VkImageType);
2855 *count += sizeof(VkSampleCountFlagBits);
2856 *count += sizeof(VkImageUsageFlags);
2857 *count += sizeof(VkImageTiling);
2858 }
2859
count_VkPhysicalDevicePointClippingProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDevicePointClippingProperties * toCount,size_t * count)2860 void count_VkPhysicalDevicePointClippingProperties(
2861 uint32_t featureBits, VkStructureType rootType,
2862 const VkPhysicalDevicePointClippingProperties* toCount, size_t* count) {
2863 (void)featureBits;
2864 (void)rootType;
2865 (void)toCount;
2866 (void)count;
2867 *count += sizeof(VkStructureType);
2868 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2869 rootType = toCount->sType;
2870 }
2871 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2872 *count += sizeof(VkPointClippingBehavior);
2873 }
2874
count_VkInputAttachmentAspectReference(uint32_t featureBits,VkStructureType rootType,const VkInputAttachmentAspectReference * toCount,size_t * count)2875 void count_VkInputAttachmentAspectReference(uint32_t featureBits, VkStructureType rootType,
2876 const VkInputAttachmentAspectReference* toCount,
2877 size_t* count) {
2878 (void)featureBits;
2879 (void)rootType;
2880 (void)toCount;
2881 (void)count;
2882 *count += sizeof(uint32_t);
2883 *count += sizeof(uint32_t);
2884 *count += sizeof(VkImageAspectFlags);
2885 }
2886
count_VkRenderPassInputAttachmentAspectCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkRenderPassInputAttachmentAspectCreateInfo * toCount,size_t * count)2887 void count_VkRenderPassInputAttachmentAspectCreateInfo(
2888 uint32_t featureBits, VkStructureType rootType,
2889 const VkRenderPassInputAttachmentAspectCreateInfo* toCount, size_t* count) {
2890 (void)featureBits;
2891 (void)rootType;
2892 (void)toCount;
2893 (void)count;
2894 *count += sizeof(VkStructureType);
2895 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2896 rootType = toCount->sType;
2897 }
2898 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2899 *count += sizeof(uint32_t);
2900 if (toCount) {
2901 for (uint32_t i = 0; i < (uint32_t)toCount->aspectReferenceCount; ++i) {
2902 count_VkInputAttachmentAspectReference(
2903 featureBits, rootType,
2904 (const VkInputAttachmentAspectReference*)(toCount->pAspectReferences + i), count);
2905 }
2906 }
2907 }
2908
count_VkImageViewUsageCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkImageViewUsageCreateInfo * toCount,size_t * count)2909 void count_VkImageViewUsageCreateInfo(uint32_t featureBits, VkStructureType rootType,
2910 const VkImageViewUsageCreateInfo* toCount, size_t* count) {
2911 (void)featureBits;
2912 (void)rootType;
2913 (void)toCount;
2914 (void)count;
2915 *count += sizeof(VkStructureType);
2916 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2917 rootType = toCount->sType;
2918 }
2919 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2920 *count += sizeof(VkImageUsageFlags);
2921 }
2922
count_VkPipelineTessellationDomainOriginStateCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineTessellationDomainOriginStateCreateInfo * toCount,size_t * count)2923 void count_VkPipelineTessellationDomainOriginStateCreateInfo(
2924 uint32_t featureBits, VkStructureType rootType,
2925 const VkPipelineTessellationDomainOriginStateCreateInfo* toCount, size_t* count) {
2926 (void)featureBits;
2927 (void)rootType;
2928 (void)toCount;
2929 (void)count;
2930 *count += sizeof(VkStructureType);
2931 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2932 rootType = toCount->sType;
2933 }
2934 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2935 *count += sizeof(VkTessellationDomainOrigin);
2936 }
2937
count_VkRenderPassMultiviewCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkRenderPassMultiviewCreateInfo * toCount,size_t * count)2938 void count_VkRenderPassMultiviewCreateInfo(uint32_t featureBits, VkStructureType rootType,
2939 const VkRenderPassMultiviewCreateInfo* toCount,
2940 size_t* count) {
2941 (void)featureBits;
2942 (void)rootType;
2943 (void)toCount;
2944 (void)count;
2945 *count += sizeof(VkStructureType);
2946 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2947 rootType = toCount->sType;
2948 }
2949 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2950 *count += sizeof(uint32_t);
2951 if (toCount) {
2952 *count += toCount->subpassCount * sizeof(const uint32_t);
2953 }
2954 *count += sizeof(uint32_t);
2955 if (toCount) {
2956 *count += toCount->dependencyCount * sizeof(const int32_t);
2957 }
2958 *count += sizeof(uint32_t);
2959 if (toCount) {
2960 *count += toCount->correlationMaskCount * sizeof(const uint32_t);
2961 }
2962 }
2963
count_VkPhysicalDeviceMultiviewFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceMultiviewFeatures * toCount,size_t * count)2964 void count_VkPhysicalDeviceMultiviewFeatures(uint32_t featureBits, VkStructureType rootType,
2965 const VkPhysicalDeviceMultiviewFeatures* toCount,
2966 size_t* count) {
2967 (void)featureBits;
2968 (void)rootType;
2969 (void)toCount;
2970 (void)count;
2971 *count += sizeof(VkStructureType);
2972 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2973 rootType = toCount->sType;
2974 }
2975 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2976 *count += sizeof(VkBool32);
2977 *count += sizeof(VkBool32);
2978 *count += sizeof(VkBool32);
2979 }
2980
count_VkPhysicalDeviceMultiviewProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceMultiviewProperties * toCount,size_t * count)2981 void count_VkPhysicalDeviceMultiviewProperties(uint32_t featureBits, VkStructureType rootType,
2982 const VkPhysicalDeviceMultiviewProperties* toCount,
2983 size_t* count) {
2984 (void)featureBits;
2985 (void)rootType;
2986 (void)toCount;
2987 (void)count;
2988 *count += sizeof(VkStructureType);
2989 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
2990 rootType = toCount->sType;
2991 }
2992 count_extension_struct(featureBits, rootType, toCount->pNext, count);
2993 *count += sizeof(uint32_t);
2994 *count += sizeof(uint32_t);
2995 }
2996
count_VkPhysicalDeviceVariablePointersFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceVariablePointersFeatures * toCount,size_t * count)2997 void count_VkPhysicalDeviceVariablePointersFeatures(
2998 uint32_t featureBits, VkStructureType rootType,
2999 const VkPhysicalDeviceVariablePointersFeatures* toCount, size_t* count) {
3000 (void)featureBits;
3001 (void)rootType;
3002 (void)toCount;
3003 (void)count;
3004 *count += sizeof(VkStructureType);
3005 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3006 rootType = toCount->sType;
3007 }
3008 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3009 *count += sizeof(VkBool32);
3010 *count += sizeof(VkBool32);
3011 }
3012
count_VkPhysicalDeviceProtectedMemoryFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceProtectedMemoryFeatures * toCount,size_t * count)3013 void count_VkPhysicalDeviceProtectedMemoryFeatures(
3014 uint32_t featureBits, VkStructureType rootType,
3015 const VkPhysicalDeviceProtectedMemoryFeatures* toCount, size_t* count) {
3016 (void)featureBits;
3017 (void)rootType;
3018 (void)toCount;
3019 (void)count;
3020 *count += sizeof(VkStructureType);
3021 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3022 rootType = toCount->sType;
3023 }
3024 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3025 *count += sizeof(VkBool32);
3026 }
3027
count_VkPhysicalDeviceProtectedMemoryProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceProtectedMemoryProperties * toCount,size_t * count)3028 void count_VkPhysicalDeviceProtectedMemoryProperties(
3029 uint32_t featureBits, VkStructureType rootType,
3030 const VkPhysicalDeviceProtectedMemoryProperties* toCount, size_t* count) {
3031 (void)featureBits;
3032 (void)rootType;
3033 (void)toCount;
3034 (void)count;
3035 *count += sizeof(VkStructureType);
3036 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3037 rootType = toCount->sType;
3038 }
3039 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3040 *count += sizeof(VkBool32);
3041 }
3042
count_VkDeviceQueueInfo2(uint32_t featureBits,VkStructureType rootType,const VkDeviceQueueInfo2 * toCount,size_t * count)3043 void count_VkDeviceQueueInfo2(uint32_t featureBits, VkStructureType rootType,
3044 const VkDeviceQueueInfo2* toCount, size_t* count) {
3045 (void)featureBits;
3046 (void)rootType;
3047 (void)toCount;
3048 (void)count;
3049 *count += sizeof(VkStructureType);
3050 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3051 rootType = toCount->sType;
3052 }
3053 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3054 *count += sizeof(VkDeviceQueueCreateFlags);
3055 *count += sizeof(uint32_t);
3056 *count += sizeof(uint32_t);
3057 }
3058
count_VkProtectedSubmitInfo(uint32_t featureBits,VkStructureType rootType,const VkProtectedSubmitInfo * toCount,size_t * count)3059 void count_VkProtectedSubmitInfo(uint32_t featureBits, VkStructureType rootType,
3060 const VkProtectedSubmitInfo* toCount, size_t* count) {
3061 (void)featureBits;
3062 (void)rootType;
3063 (void)toCount;
3064 (void)count;
3065 *count += sizeof(VkStructureType);
3066 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3067 rootType = toCount->sType;
3068 }
3069 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3070 *count += sizeof(VkBool32);
3071 }
3072
count_VkSamplerYcbcrConversionCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkSamplerYcbcrConversionCreateInfo * toCount,size_t * count)3073 void count_VkSamplerYcbcrConversionCreateInfo(uint32_t featureBits, VkStructureType rootType,
3074 const VkSamplerYcbcrConversionCreateInfo* toCount,
3075 size_t* count) {
3076 (void)featureBits;
3077 (void)rootType;
3078 (void)toCount;
3079 (void)count;
3080 *count += sizeof(VkStructureType);
3081 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3082 rootType = toCount->sType;
3083 }
3084 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3085 *count += sizeof(VkFormat);
3086 *count += sizeof(VkSamplerYcbcrModelConversion);
3087 *count += sizeof(VkSamplerYcbcrRange);
3088 count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->components),
3089 count);
3090 *count += sizeof(VkChromaLocation);
3091 *count += sizeof(VkChromaLocation);
3092 *count += sizeof(VkFilter);
3093 *count += sizeof(VkBool32);
3094 }
3095
count_VkSamplerYcbcrConversionInfo(uint32_t featureBits,VkStructureType rootType,const VkSamplerYcbcrConversionInfo * toCount,size_t * count)3096 void count_VkSamplerYcbcrConversionInfo(uint32_t featureBits, VkStructureType rootType,
3097 const VkSamplerYcbcrConversionInfo* toCount,
3098 size_t* count) {
3099 (void)featureBits;
3100 (void)rootType;
3101 (void)toCount;
3102 (void)count;
3103 *count += sizeof(VkStructureType);
3104 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3105 rootType = toCount->sType;
3106 }
3107 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3108 uint64_t cgen_var_0;
3109 *count += 1 * 8;
3110 }
3111
count_VkBindImagePlaneMemoryInfo(uint32_t featureBits,VkStructureType rootType,const VkBindImagePlaneMemoryInfo * toCount,size_t * count)3112 void count_VkBindImagePlaneMemoryInfo(uint32_t featureBits, VkStructureType rootType,
3113 const VkBindImagePlaneMemoryInfo* toCount, size_t* count) {
3114 (void)featureBits;
3115 (void)rootType;
3116 (void)toCount;
3117 (void)count;
3118 *count += sizeof(VkStructureType);
3119 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3120 rootType = toCount->sType;
3121 }
3122 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3123 *count += sizeof(VkImageAspectFlagBits);
3124 }
3125
count_VkImagePlaneMemoryRequirementsInfo(uint32_t featureBits,VkStructureType rootType,const VkImagePlaneMemoryRequirementsInfo * toCount,size_t * count)3126 void count_VkImagePlaneMemoryRequirementsInfo(uint32_t featureBits, VkStructureType rootType,
3127 const VkImagePlaneMemoryRequirementsInfo* toCount,
3128 size_t* count) {
3129 (void)featureBits;
3130 (void)rootType;
3131 (void)toCount;
3132 (void)count;
3133 *count += sizeof(VkStructureType);
3134 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3135 rootType = toCount->sType;
3136 }
3137 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3138 *count += sizeof(VkImageAspectFlagBits);
3139 }
3140
count_VkPhysicalDeviceSamplerYcbcrConversionFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * toCount,size_t * count)3141 void count_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
3142 uint32_t featureBits, VkStructureType rootType,
3143 const VkPhysicalDeviceSamplerYcbcrConversionFeatures* toCount, size_t* count) {
3144 (void)featureBits;
3145 (void)rootType;
3146 (void)toCount;
3147 (void)count;
3148 *count += sizeof(VkStructureType);
3149 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3150 rootType = toCount->sType;
3151 }
3152 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3153 *count += sizeof(VkBool32);
3154 }
3155
count_VkSamplerYcbcrConversionImageFormatProperties(uint32_t featureBits,VkStructureType rootType,const VkSamplerYcbcrConversionImageFormatProperties * toCount,size_t * count)3156 void count_VkSamplerYcbcrConversionImageFormatProperties(
3157 uint32_t featureBits, VkStructureType rootType,
3158 const VkSamplerYcbcrConversionImageFormatProperties* toCount, size_t* count) {
3159 (void)featureBits;
3160 (void)rootType;
3161 (void)toCount;
3162 (void)count;
3163 *count += sizeof(VkStructureType);
3164 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3165 rootType = toCount->sType;
3166 }
3167 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3168 *count += sizeof(uint32_t);
3169 }
3170
count_VkDescriptorUpdateTemplateEntry(uint32_t featureBits,VkStructureType rootType,const VkDescriptorUpdateTemplateEntry * toCount,size_t * count)3171 void count_VkDescriptorUpdateTemplateEntry(uint32_t featureBits, VkStructureType rootType,
3172 const VkDescriptorUpdateTemplateEntry* toCount,
3173 size_t* count) {
3174 (void)featureBits;
3175 (void)rootType;
3176 (void)toCount;
3177 (void)count;
3178 *count += sizeof(uint32_t);
3179 *count += sizeof(uint32_t);
3180 *count += sizeof(uint32_t);
3181 *count += sizeof(VkDescriptorType);
3182 *count += 8;
3183 *count += 8;
3184 }
3185
count_VkDescriptorUpdateTemplateCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkDescriptorUpdateTemplateCreateInfo * toCount,size_t * count)3186 void count_VkDescriptorUpdateTemplateCreateInfo(uint32_t featureBits, VkStructureType rootType,
3187 const VkDescriptorUpdateTemplateCreateInfo* toCount,
3188 size_t* count) {
3189 (void)featureBits;
3190 (void)rootType;
3191 (void)toCount;
3192 (void)count;
3193 *count += sizeof(VkStructureType);
3194 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3195 rootType = toCount->sType;
3196 }
3197 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3198 *count += sizeof(VkDescriptorUpdateTemplateCreateFlags);
3199 *count += sizeof(uint32_t);
3200 if (toCount) {
3201 for (uint32_t i = 0; i < (uint32_t)toCount->descriptorUpdateEntryCount; ++i) {
3202 count_VkDescriptorUpdateTemplateEntry(
3203 featureBits, rootType,
3204 (const VkDescriptorUpdateTemplateEntry*)(toCount->pDescriptorUpdateEntries + i),
3205 count);
3206 }
3207 }
3208 *count += sizeof(VkDescriptorUpdateTemplateType);
3209 uint64_t cgen_var_0;
3210 *count += 1 * 8;
3211 *count += sizeof(VkPipelineBindPoint);
3212 uint64_t cgen_var_1;
3213 *count += 1 * 8;
3214 *count += sizeof(uint32_t);
3215 }
3216
count_VkExternalMemoryProperties(uint32_t featureBits,VkStructureType rootType,const VkExternalMemoryProperties * toCount,size_t * count)3217 void count_VkExternalMemoryProperties(uint32_t featureBits, VkStructureType rootType,
3218 const VkExternalMemoryProperties* toCount, size_t* count) {
3219 (void)featureBits;
3220 (void)rootType;
3221 (void)toCount;
3222 (void)count;
3223 *count += sizeof(VkExternalMemoryFeatureFlags);
3224 *count += sizeof(VkExternalMemoryHandleTypeFlags);
3225 *count += sizeof(VkExternalMemoryHandleTypeFlags);
3226 }
3227
count_VkPhysicalDeviceExternalImageFormatInfo(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceExternalImageFormatInfo * toCount,size_t * count)3228 void count_VkPhysicalDeviceExternalImageFormatInfo(
3229 uint32_t featureBits, VkStructureType rootType,
3230 const VkPhysicalDeviceExternalImageFormatInfo* toCount, size_t* count) {
3231 (void)featureBits;
3232 (void)rootType;
3233 (void)toCount;
3234 (void)count;
3235 *count += sizeof(VkStructureType);
3236 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3237 rootType = toCount->sType;
3238 }
3239 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3240 *count += sizeof(VkExternalMemoryHandleTypeFlagBits);
3241 }
3242
count_VkExternalImageFormatProperties(uint32_t featureBits,VkStructureType rootType,const VkExternalImageFormatProperties * toCount,size_t * count)3243 void count_VkExternalImageFormatProperties(uint32_t featureBits, VkStructureType rootType,
3244 const VkExternalImageFormatProperties* toCount,
3245 size_t* count) {
3246 (void)featureBits;
3247 (void)rootType;
3248 (void)toCount;
3249 (void)count;
3250 *count += sizeof(VkStructureType);
3251 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3252 rootType = toCount->sType;
3253 }
3254 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3255 count_VkExternalMemoryProperties(
3256 featureBits, rootType, (VkExternalMemoryProperties*)(&toCount->externalMemoryProperties),
3257 count);
3258 }
3259
count_VkPhysicalDeviceExternalBufferInfo(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceExternalBufferInfo * toCount,size_t * count)3260 void count_VkPhysicalDeviceExternalBufferInfo(uint32_t featureBits, VkStructureType rootType,
3261 const VkPhysicalDeviceExternalBufferInfo* toCount,
3262 size_t* count) {
3263 (void)featureBits;
3264 (void)rootType;
3265 (void)toCount;
3266 (void)count;
3267 *count += sizeof(VkStructureType);
3268 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3269 rootType = toCount->sType;
3270 }
3271 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3272 *count += sizeof(VkBufferCreateFlags);
3273 *count += sizeof(VkBufferUsageFlags);
3274 *count += sizeof(VkExternalMemoryHandleTypeFlagBits);
3275 }
3276
count_VkExternalBufferProperties(uint32_t featureBits,VkStructureType rootType,const VkExternalBufferProperties * toCount,size_t * count)3277 void count_VkExternalBufferProperties(uint32_t featureBits, VkStructureType rootType,
3278 const VkExternalBufferProperties* toCount, size_t* count) {
3279 (void)featureBits;
3280 (void)rootType;
3281 (void)toCount;
3282 (void)count;
3283 *count += sizeof(VkStructureType);
3284 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3285 rootType = toCount->sType;
3286 }
3287 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3288 count_VkExternalMemoryProperties(
3289 featureBits, rootType, (VkExternalMemoryProperties*)(&toCount->externalMemoryProperties),
3290 count);
3291 }
3292
count_VkPhysicalDeviceIDProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceIDProperties * toCount,size_t * count)3293 void count_VkPhysicalDeviceIDProperties(uint32_t featureBits, VkStructureType rootType,
3294 const VkPhysicalDeviceIDProperties* toCount,
3295 size_t* count) {
3296 (void)featureBits;
3297 (void)rootType;
3298 (void)toCount;
3299 (void)count;
3300 *count += sizeof(VkStructureType);
3301 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3302 rootType = toCount->sType;
3303 }
3304 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3305 *count += VK_UUID_SIZE * sizeof(uint8_t);
3306 *count += VK_UUID_SIZE * sizeof(uint8_t);
3307 *count += VK_LUID_SIZE * sizeof(uint8_t);
3308 *count += sizeof(uint32_t);
3309 *count += sizeof(VkBool32);
3310 }
3311
count_VkExternalMemoryImageCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkExternalMemoryImageCreateInfo * toCount,size_t * count)3312 void count_VkExternalMemoryImageCreateInfo(uint32_t featureBits, VkStructureType rootType,
3313 const VkExternalMemoryImageCreateInfo* toCount,
3314 size_t* count) {
3315 (void)featureBits;
3316 (void)rootType;
3317 (void)toCount;
3318 (void)count;
3319 *count += sizeof(VkStructureType);
3320 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3321 rootType = toCount->sType;
3322 }
3323 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3324 *count += sizeof(VkExternalMemoryHandleTypeFlags);
3325 }
3326
count_VkExternalMemoryBufferCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkExternalMemoryBufferCreateInfo * toCount,size_t * count)3327 void count_VkExternalMemoryBufferCreateInfo(uint32_t featureBits, VkStructureType rootType,
3328 const VkExternalMemoryBufferCreateInfo* toCount,
3329 size_t* count) {
3330 (void)featureBits;
3331 (void)rootType;
3332 (void)toCount;
3333 (void)count;
3334 *count += sizeof(VkStructureType);
3335 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3336 rootType = toCount->sType;
3337 }
3338 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3339 *count += sizeof(VkExternalMemoryHandleTypeFlags);
3340 }
3341
count_VkExportMemoryAllocateInfo(uint32_t featureBits,VkStructureType rootType,const VkExportMemoryAllocateInfo * toCount,size_t * count)3342 void count_VkExportMemoryAllocateInfo(uint32_t featureBits, VkStructureType rootType,
3343 const VkExportMemoryAllocateInfo* toCount, size_t* count) {
3344 (void)featureBits;
3345 (void)rootType;
3346 (void)toCount;
3347 (void)count;
3348 *count += sizeof(VkStructureType);
3349 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3350 rootType = toCount->sType;
3351 }
3352 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3353 *count += sizeof(VkExternalMemoryHandleTypeFlags);
3354 }
3355
count_VkPhysicalDeviceExternalFenceInfo(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceExternalFenceInfo * toCount,size_t * count)3356 void count_VkPhysicalDeviceExternalFenceInfo(uint32_t featureBits, VkStructureType rootType,
3357 const VkPhysicalDeviceExternalFenceInfo* toCount,
3358 size_t* count) {
3359 (void)featureBits;
3360 (void)rootType;
3361 (void)toCount;
3362 (void)count;
3363 *count += sizeof(VkStructureType);
3364 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3365 rootType = toCount->sType;
3366 }
3367 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3368 *count += sizeof(VkExternalFenceHandleTypeFlagBits);
3369 }
3370
count_VkExternalFenceProperties(uint32_t featureBits,VkStructureType rootType,const VkExternalFenceProperties * toCount,size_t * count)3371 void count_VkExternalFenceProperties(uint32_t featureBits, VkStructureType rootType,
3372 const VkExternalFenceProperties* toCount, size_t* count) {
3373 (void)featureBits;
3374 (void)rootType;
3375 (void)toCount;
3376 (void)count;
3377 *count += sizeof(VkStructureType);
3378 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3379 rootType = toCount->sType;
3380 }
3381 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3382 *count += sizeof(VkExternalFenceHandleTypeFlags);
3383 *count += sizeof(VkExternalFenceHandleTypeFlags);
3384 *count += sizeof(VkExternalFenceFeatureFlags);
3385 }
3386
count_VkExportFenceCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkExportFenceCreateInfo * toCount,size_t * count)3387 void count_VkExportFenceCreateInfo(uint32_t featureBits, VkStructureType rootType,
3388 const VkExportFenceCreateInfo* toCount, size_t* count) {
3389 (void)featureBits;
3390 (void)rootType;
3391 (void)toCount;
3392 (void)count;
3393 *count += sizeof(VkStructureType);
3394 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3395 rootType = toCount->sType;
3396 }
3397 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3398 *count += sizeof(VkExternalFenceHandleTypeFlags);
3399 }
3400
count_VkExportSemaphoreCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkExportSemaphoreCreateInfo * toCount,size_t * count)3401 void count_VkExportSemaphoreCreateInfo(uint32_t featureBits, VkStructureType rootType,
3402 const VkExportSemaphoreCreateInfo* toCount, size_t* count) {
3403 (void)featureBits;
3404 (void)rootType;
3405 (void)toCount;
3406 (void)count;
3407 *count += sizeof(VkStructureType);
3408 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3409 rootType = toCount->sType;
3410 }
3411 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3412 *count += sizeof(VkExternalSemaphoreHandleTypeFlags);
3413 }
3414
count_VkPhysicalDeviceExternalSemaphoreInfo(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceExternalSemaphoreInfo * toCount,size_t * count)3415 void count_VkPhysicalDeviceExternalSemaphoreInfo(
3416 uint32_t featureBits, VkStructureType rootType,
3417 const VkPhysicalDeviceExternalSemaphoreInfo* toCount, size_t* count) {
3418 (void)featureBits;
3419 (void)rootType;
3420 (void)toCount;
3421 (void)count;
3422 *count += sizeof(VkStructureType);
3423 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3424 rootType = toCount->sType;
3425 }
3426 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3427 *count += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
3428 }
3429
count_VkExternalSemaphoreProperties(uint32_t featureBits,VkStructureType rootType,const VkExternalSemaphoreProperties * toCount,size_t * count)3430 void count_VkExternalSemaphoreProperties(uint32_t featureBits, VkStructureType rootType,
3431 const VkExternalSemaphoreProperties* toCount,
3432 size_t* count) {
3433 (void)featureBits;
3434 (void)rootType;
3435 (void)toCount;
3436 (void)count;
3437 *count += sizeof(VkStructureType);
3438 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3439 rootType = toCount->sType;
3440 }
3441 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3442 *count += sizeof(VkExternalSemaphoreHandleTypeFlags);
3443 *count += sizeof(VkExternalSemaphoreHandleTypeFlags);
3444 *count += sizeof(VkExternalSemaphoreFeatureFlags);
3445 }
3446
count_VkPhysicalDeviceMaintenance3Properties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceMaintenance3Properties * toCount,size_t * count)3447 void count_VkPhysicalDeviceMaintenance3Properties(
3448 uint32_t featureBits, VkStructureType rootType,
3449 const VkPhysicalDeviceMaintenance3Properties* toCount, size_t* count) {
3450 (void)featureBits;
3451 (void)rootType;
3452 (void)toCount;
3453 (void)count;
3454 *count += sizeof(VkStructureType);
3455 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3456 rootType = toCount->sType;
3457 }
3458 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3459 *count += sizeof(uint32_t);
3460 *count += sizeof(VkDeviceSize);
3461 }
3462
count_VkDescriptorSetLayoutSupport(uint32_t featureBits,VkStructureType rootType,const VkDescriptorSetLayoutSupport * toCount,size_t * count)3463 void count_VkDescriptorSetLayoutSupport(uint32_t featureBits, VkStructureType rootType,
3464 const VkDescriptorSetLayoutSupport* toCount,
3465 size_t* count) {
3466 (void)featureBits;
3467 (void)rootType;
3468 (void)toCount;
3469 (void)count;
3470 *count += sizeof(VkStructureType);
3471 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3472 rootType = toCount->sType;
3473 }
3474 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3475 *count += sizeof(VkBool32);
3476 }
3477
count_VkPhysicalDeviceShaderDrawParametersFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceShaderDrawParametersFeatures * toCount,size_t * count)3478 void count_VkPhysicalDeviceShaderDrawParametersFeatures(
3479 uint32_t featureBits, VkStructureType rootType,
3480 const VkPhysicalDeviceShaderDrawParametersFeatures* toCount, size_t* count) {
3481 (void)featureBits;
3482 (void)rootType;
3483 (void)toCount;
3484 (void)count;
3485 *count += sizeof(VkStructureType);
3486 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3487 rootType = toCount->sType;
3488 }
3489 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3490 *count += sizeof(VkBool32);
3491 }
3492
3493 #endif
3494 #ifdef VK_VERSION_1_2
count_VkPhysicalDeviceVulkan11Features(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceVulkan11Features * toCount,size_t * count)3495 void count_VkPhysicalDeviceVulkan11Features(uint32_t featureBits, VkStructureType rootType,
3496 const VkPhysicalDeviceVulkan11Features* toCount,
3497 size_t* count) {
3498 (void)featureBits;
3499 (void)rootType;
3500 (void)toCount;
3501 (void)count;
3502 *count += sizeof(VkStructureType);
3503 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3504 rootType = toCount->sType;
3505 }
3506 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3507 *count += sizeof(VkBool32);
3508 *count += sizeof(VkBool32);
3509 *count += sizeof(VkBool32);
3510 *count += sizeof(VkBool32);
3511 *count += sizeof(VkBool32);
3512 *count += sizeof(VkBool32);
3513 *count += sizeof(VkBool32);
3514 *count += sizeof(VkBool32);
3515 *count += sizeof(VkBool32);
3516 *count += sizeof(VkBool32);
3517 *count += sizeof(VkBool32);
3518 *count += sizeof(VkBool32);
3519 }
3520
count_VkPhysicalDeviceVulkan11Properties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceVulkan11Properties * toCount,size_t * count)3521 void count_VkPhysicalDeviceVulkan11Properties(uint32_t featureBits, VkStructureType rootType,
3522 const VkPhysicalDeviceVulkan11Properties* toCount,
3523 size_t* count) {
3524 (void)featureBits;
3525 (void)rootType;
3526 (void)toCount;
3527 (void)count;
3528 *count += sizeof(VkStructureType);
3529 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3530 rootType = toCount->sType;
3531 }
3532 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3533 *count += VK_UUID_SIZE * sizeof(uint8_t);
3534 *count += VK_UUID_SIZE * sizeof(uint8_t);
3535 *count += VK_LUID_SIZE * sizeof(uint8_t);
3536 *count += sizeof(uint32_t);
3537 *count += sizeof(VkBool32);
3538 *count += sizeof(uint32_t);
3539 *count += sizeof(VkShaderStageFlags);
3540 *count += sizeof(VkSubgroupFeatureFlags);
3541 *count += sizeof(VkBool32);
3542 *count += sizeof(VkPointClippingBehavior);
3543 *count += sizeof(uint32_t);
3544 *count += sizeof(uint32_t);
3545 *count += sizeof(VkBool32);
3546 *count += sizeof(uint32_t);
3547 *count += sizeof(VkDeviceSize);
3548 }
3549
count_VkPhysicalDeviceVulkan12Features(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceVulkan12Features * toCount,size_t * count)3550 void count_VkPhysicalDeviceVulkan12Features(uint32_t featureBits, VkStructureType rootType,
3551 const VkPhysicalDeviceVulkan12Features* toCount,
3552 size_t* count) {
3553 (void)featureBits;
3554 (void)rootType;
3555 (void)toCount;
3556 (void)count;
3557 *count += sizeof(VkStructureType);
3558 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3559 rootType = toCount->sType;
3560 }
3561 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3562 *count += sizeof(VkBool32);
3563 *count += sizeof(VkBool32);
3564 *count += sizeof(VkBool32);
3565 *count += sizeof(VkBool32);
3566 *count += sizeof(VkBool32);
3567 *count += sizeof(VkBool32);
3568 *count += sizeof(VkBool32);
3569 *count += sizeof(VkBool32);
3570 *count += sizeof(VkBool32);
3571 *count += sizeof(VkBool32);
3572 *count += sizeof(VkBool32);
3573 *count += sizeof(VkBool32);
3574 *count += sizeof(VkBool32);
3575 *count += sizeof(VkBool32);
3576 *count += sizeof(VkBool32);
3577 *count += sizeof(VkBool32);
3578 *count += sizeof(VkBool32);
3579 *count += sizeof(VkBool32);
3580 *count += sizeof(VkBool32);
3581 *count += sizeof(VkBool32);
3582 *count += sizeof(VkBool32);
3583 *count += sizeof(VkBool32);
3584 *count += sizeof(VkBool32);
3585 *count += sizeof(VkBool32);
3586 *count += sizeof(VkBool32);
3587 *count += sizeof(VkBool32);
3588 *count += sizeof(VkBool32);
3589 *count += sizeof(VkBool32);
3590 *count += sizeof(VkBool32);
3591 *count += sizeof(VkBool32);
3592 *count += sizeof(VkBool32);
3593 *count += sizeof(VkBool32);
3594 *count += sizeof(VkBool32);
3595 *count += sizeof(VkBool32);
3596 *count += sizeof(VkBool32);
3597 *count += sizeof(VkBool32);
3598 *count += sizeof(VkBool32);
3599 *count += sizeof(VkBool32);
3600 *count += sizeof(VkBool32);
3601 *count += sizeof(VkBool32);
3602 *count += sizeof(VkBool32);
3603 *count += sizeof(VkBool32);
3604 *count += sizeof(VkBool32);
3605 *count += sizeof(VkBool32);
3606 *count += sizeof(VkBool32);
3607 *count += sizeof(VkBool32);
3608 *count += sizeof(VkBool32);
3609 }
3610
count_VkConformanceVersion(uint32_t featureBits,VkStructureType rootType,const VkConformanceVersion * toCount,size_t * count)3611 void count_VkConformanceVersion(uint32_t featureBits, VkStructureType rootType,
3612 const VkConformanceVersion* toCount, size_t* count) {
3613 (void)featureBits;
3614 (void)rootType;
3615 (void)toCount;
3616 (void)count;
3617 *count += sizeof(uint8_t);
3618 *count += sizeof(uint8_t);
3619 *count += sizeof(uint8_t);
3620 *count += sizeof(uint8_t);
3621 }
3622
count_VkPhysicalDeviceVulkan12Properties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceVulkan12Properties * toCount,size_t * count)3623 void count_VkPhysicalDeviceVulkan12Properties(uint32_t featureBits, VkStructureType rootType,
3624 const VkPhysicalDeviceVulkan12Properties* toCount,
3625 size_t* count) {
3626 (void)featureBits;
3627 (void)rootType;
3628 (void)toCount;
3629 (void)count;
3630 *count += sizeof(VkStructureType);
3631 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3632 rootType = toCount->sType;
3633 }
3634 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3635 *count += sizeof(VkDriverId);
3636 *count += VK_MAX_DRIVER_NAME_SIZE * sizeof(char);
3637 *count += VK_MAX_DRIVER_INFO_SIZE * sizeof(char);
3638 count_VkConformanceVersion(featureBits, rootType,
3639 (VkConformanceVersion*)(&toCount->conformanceVersion), count);
3640 *count += sizeof(VkShaderFloatControlsIndependence);
3641 *count += sizeof(VkShaderFloatControlsIndependence);
3642 *count += sizeof(VkBool32);
3643 *count += sizeof(VkBool32);
3644 *count += sizeof(VkBool32);
3645 *count += sizeof(VkBool32);
3646 *count += sizeof(VkBool32);
3647 *count += sizeof(VkBool32);
3648 *count += sizeof(VkBool32);
3649 *count += sizeof(VkBool32);
3650 *count += sizeof(VkBool32);
3651 *count += sizeof(VkBool32);
3652 *count += sizeof(VkBool32);
3653 *count += sizeof(VkBool32);
3654 *count += sizeof(VkBool32);
3655 *count += sizeof(VkBool32);
3656 *count += sizeof(VkBool32);
3657 *count += sizeof(uint32_t);
3658 *count += sizeof(VkBool32);
3659 *count += sizeof(VkBool32);
3660 *count += sizeof(VkBool32);
3661 *count += sizeof(VkBool32);
3662 *count += sizeof(VkBool32);
3663 *count += sizeof(VkBool32);
3664 *count += sizeof(VkBool32);
3665 *count += sizeof(uint32_t);
3666 *count += sizeof(uint32_t);
3667 *count += sizeof(uint32_t);
3668 *count += sizeof(uint32_t);
3669 *count += sizeof(uint32_t);
3670 *count += sizeof(uint32_t);
3671 *count += sizeof(uint32_t);
3672 *count += sizeof(uint32_t);
3673 *count += sizeof(uint32_t);
3674 *count += sizeof(uint32_t);
3675 *count += sizeof(uint32_t);
3676 *count += sizeof(uint32_t);
3677 *count += sizeof(uint32_t);
3678 *count += sizeof(uint32_t);
3679 *count += sizeof(uint32_t);
3680 *count += sizeof(VkResolveModeFlags);
3681 *count += sizeof(VkResolveModeFlags);
3682 *count += sizeof(VkBool32);
3683 *count += sizeof(VkBool32);
3684 *count += sizeof(VkBool32);
3685 *count += sizeof(VkBool32);
3686 *count += sizeof(uint64_t);
3687 *count += sizeof(VkSampleCountFlags);
3688 }
3689
count_VkImageFormatListCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkImageFormatListCreateInfo * toCount,size_t * count)3690 void count_VkImageFormatListCreateInfo(uint32_t featureBits, VkStructureType rootType,
3691 const VkImageFormatListCreateInfo* toCount, size_t* count) {
3692 (void)featureBits;
3693 (void)rootType;
3694 (void)toCount;
3695 (void)count;
3696 *count += sizeof(VkStructureType);
3697 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3698 rootType = toCount->sType;
3699 }
3700 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3701 *count += sizeof(uint32_t);
3702 if (toCount) {
3703 *count += toCount->viewFormatCount * sizeof(const VkFormat);
3704 }
3705 }
3706
count_VkAttachmentDescription2(uint32_t featureBits,VkStructureType rootType,const VkAttachmentDescription2 * toCount,size_t * count)3707 void count_VkAttachmentDescription2(uint32_t featureBits, VkStructureType rootType,
3708 const VkAttachmentDescription2* toCount, size_t* count) {
3709 (void)featureBits;
3710 (void)rootType;
3711 (void)toCount;
3712 (void)count;
3713 *count += sizeof(VkStructureType);
3714 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3715 rootType = toCount->sType;
3716 }
3717 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3718 *count += sizeof(VkAttachmentDescriptionFlags);
3719 *count += sizeof(VkFormat);
3720 *count += sizeof(VkSampleCountFlagBits);
3721 *count += sizeof(VkAttachmentLoadOp);
3722 *count += sizeof(VkAttachmentStoreOp);
3723 *count += sizeof(VkAttachmentLoadOp);
3724 *count += sizeof(VkAttachmentStoreOp);
3725 *count += sizeof(VkImageLayout);
3726 *count += sizeof(VkImageLayout);
3727 }
3728
count_VkAttachmentReference2(uint32_t featureBits,VkStructureType rootType,const VkAttachmentReference2 * toCount,size_t * count)3729 void count_VkAttachmentReference2(uint32_t featureBits, VkStructureType rootType,
3730 const VkAttachmentReference2* toCount, size_t* count) {
3731 (void)featureBits;
3732 (void)rootType;
3733 (void)toCount;
3734 (void)count;
3735 *count += sizeof(VkStructureType);
3736 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3737 rootType = toCount->sType;
3738 }
3739 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3740 *count += sizeof(uint32_t);
3741 *count += sizeof(VkImageLayout);
3742 *count += sizeof(VkImageAspectFlags);
3743 }
3744
count_VkSubpassDescription2(uint32_t featureBits,VkStructureType rootType,const VkSubpassDescription2 * toCount,size_t * count)3745 void count_VkSubpassDescription2(uint32_t featureBits, VkStructureType rootType,
3746 const VkSubpassDescription2* toCount, size_t* count) {
3747 (void)featureBits;
3748 (void)rootType;
3749 (void)toCount;
3750 (void)count;
3751 *count += sizeof(VkStructureType);
3752 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3753 rootType = toCount->sType;
3754 }
3755 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3756 *count += sizeof(VkSubpassDescriptionFlags);
3757 *count += sizeof(VkPipelineBindPoint);
3758 *count += sizeof(uint32_t);
3759 *count += sizeof(uint32_t);
3760 if (toCount) {
3761 for (uint32_t i = 0; i < (uint32_t)toCount->inputAttachmentCount; ++i) {
3762 count_VkAttachmentReference2(
3763 featureBits, rootType,
3764 (const VkAttachmentReference2*)(toCount->pInputAttachments + i), count);
3765 }
3766 }
3767 *count += sizeof(uint32_t);
3768 if (toCount) {
3769 for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i) {
3770 count_VkAttachmentReference2(
3771 featureBits, rootType,
3772 (const VkAttachmentReference2*)(toCount->pColorAttachments + i), count);
3773 }
3774 }
3775 // WARNING PTR CHECK
3776 *count += 8;
3777 if (toCount->pResolveAttachments) {
3778 if (toCount) {
3779 for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i) {
3780 count_VkAttachmentReference2(
3781 featureBits, rootType,
3782 (const VkAttachmentReference2*)(toCount->pResolveAttachments + i), count);
3783 }
3784 }
3785 }
3786 // WARNING PTR CHECK
3787 *count += 8;
3788 if (toCount->pDepthStencilAttachment) {
3789 count_VkAttachmentReference2(
3790 featureBits, rootType,
3791 (const VkAttachmentReference2*)(toCount->pDepthStencilAttachment), count);
3792 }
3793 *count += sizeof(uint32_t);
3794 if (toCount) {
3795 *count += toCount->preserveAttachmentCount * sizeof(const uint32_t);
3796 }
3797 }
3798
count_VkSubpassDependency2(uint32_t featureBits,VkStructureType rootType,const VkSubpassDependency2 * toCount,size_t * count)3799 void count_VkSubpassDependency2(uint32_t featureBits, VkStructureType rootType,
3800 const VkSubpassDependency2* toCount, size_t* count) {
3801 (void)featureBits;
3802 (void)rootType;
3803 (void)toCount;
3804 (void)count;
3805 *count += sizeof(VkStructureType);
3806 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3807 rootType = toCount->sType;
3808 }
3809 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3810 *count += sizeof(uint32_t);
3811 *count += sizeof(uint32_t);
3812 *count += sizeof(VkPipelineStageFlags);
3813 *count += sizeof(VkPipelineStageFlags);
3814 *count += sizeof(VkAccessFlags);
3815 *count += sizeof(VkAccessFlags);
3816 *count += sizeof(VkDependencyFlags);
3817 *count += sizeof(int32_t);
3818 }
3819
count_VkRenderPassCreateInfo2(uint32_t featureBits,VkStructureType rootType,const VkRenderPassCreateInfo2 * toCount,size_t * count)3820 void count_VkRenderPassCreateInfo2(uint32_t featureBits, VkStructureType rootType,
3821 const VkRenderPassCreateInfo2* toCount, size_t* count) {
3822 (void)featureBits;
3823 (void)rootType;
3824 (void)toCount;
3825 (void)count;
3826 *count += sizeof(VkStructureType);
3827 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3828 rootType = toCount->sType;
3829 }
3830 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3831 *count += sizeof(VkRenderPassCreateFlags);
3832 *count += sizeof(uint32_t);
3833 if (toCount) {
3834 for (uint32_t i = 0; i < (uint32_t)toCount->attachmentCount; ++i) {
3835 count_VkAttachmentDescription2(
3836 featureBits, rootType, (const VkAttachmentDescription2*)(toCount->pAttachments + i),
3837 count);
3838 }
3839 }
3840 *count += sizeof(uint32_t);
3841 if (toCount) {
3842 for (uint32_t i = 0; i < (uint32_t)toCount->subpassCount; ++i) {
3843 count_VkSubpassDescription2(featureBits, rootType,
3844 (const VkSubpassDescription2*)(toCount->pSubpasses + i),
3845 count);
3846 }
3847 }
3848 *count += sizeof(uint32_t);
3849 if (toCount) {
3850 for (uint32_t i = 0; i < (uint32_t)toCount->dependencyCount; ++i) {
3851 count_VkSubpassDependency2(featureBits, rootType,
3852 (const VkSubpassDependency2*)(toCount->pDependencies + i),
3853 count);
3854 }
3855 }
3856 *count += sizeof(uint32_t);
3857 if (toCount) {
3858 *count += toCount->correlatedViewMaskCount * sizeof(const uint32_t);
3859 }
3860 }
3861
count_VkSubpassBeginInfo(uint32_t featureBits,VkStructureType rootType,const VkSubpassBeginInfo * toCount,size_t * count)3862 void count_VkSubpassBeginInfo(uint32_t featureBits, VkStructureType rootType,
3863 const VkSubpassBeginInfo* toCount, size_t* count) {
3864 (void)featureBits;
3865 (void)rootType;
3866 (void)toCount;
3867 (void)count;
3868 *count += sizeof(VkStructureType);
3869 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3870 rootType = toCount->sType;
3871 }
3872 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3873 *count += sizeof(VkSubpassContents);
3874 }
3875
count_VkSubpassEndInfo(uint32_t featureBits,VkStructureType rootType,const VkSubpassEndInfo * toCount,size_t * count)3876 void count_VkSubpassEndInfo(uint32_t featureBits, VkStructureType rootType,
3877 const VkSubpassEndInfo* toCount, size_t* count) {
3878 (void)featureBits;
3879 (void)rootType;
3880 (void)toCount;
3881 (void)count;
3882 *count += sizeof(VkStructureType);
3883 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3884 rootType = toCount->sType;
3885 }
3886 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3887 }
3888
count_VkPhysicalDevice8BitStorageFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDevice8BitStorageFeatures * toCount,size_t * count)3889 void count_VkPhysicalDevice8BitStorageFeatures(uint32_t featureBits, VkStructureType rootType,
3890 const VkPhysicalDevice8BitStorageFeatures* toCount,
3891 size_t* count) {
3892 (void)featureBits;
3893 (void)rootType;
3894 (void)toCount;
3895 (void)count;
3896 *count += sizeof(VkStructureType);
3897 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3898 rootType = toCount->sType;
3899 }
3900 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3901 *count += sizeof(VkBool32);
3902 *count += sizeof(VkBool32);
3903 *count += sizeof(VkBool32);
3904 }
3905
count_VkPhysicalDeviceDriverProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceDriverProperties * toCount,size_t * count)3906 void count_VkPhysicalDeviceDriverProperties(uint32_t featureBits, VkStructureType rootType,
3907 const VkPhysicalDeviceDriverProperties* toCount,
3908 size_t* count) {
3909 (void)featureBits;
3910 (void)rootType;
3911 (void)toCount;
3912 (void)count;
3913 *count += sizeof(VkStructureType);
3914 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3915 rootType = toCount->sType;
3916 }
3917 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3918 *count += sizeof(VkDriverId);
3919 *count += VK_MAX_DRIVER_NAME_SIZE * sizeof(char);
3920 *count += VK_MAX_DRIVER_INFO_SIZE * sizeof(char);
3921 count_VkConformanceVersion(featureBits, rootType,
3922 (VkConformanceVersion*)(&toCount->conformanceVersion), count);
3923 }
3924
count_VkPhysicalDeviceShaderAtomicInt64Features(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceShaderAtomicInt64Features * toCount,size_t * count)3925 void count_VkPhysicalDeviceShaderAtomicInt64Features(
3926 uint32_t featureBits, VkStructureType rootType,
3927 const VkPhysicalDeviceShaderAtomicInt64Features* toCount, size_t* count) {
3928 (void)featureBits;
3929 (void)rootType;
3930 (void)toCount;
3931 (void)count;
3932 *count += sizeof(VkStructureType);
3933 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3934 rootType = toCount->sType;
3935 }
3936 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3937 *count += sizeof(VkBool32);
3938 *count += sizeof(VkBool32);
3939 }
3940
count_VkPhysicalDeviceShaderFloat16Int8Features(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceShaderFloat16Int8Features * toCount,size_t * count)3941 void count_VkPhysicalDeviceShaderFloat16Int8Features(
3942 uint32_t featureBits, VkStructureType rootType,
3943 const VkPhysicalDeviceShaderFloat16Int8Features* toCount, size_t* count) {
3944 (void)featureBits;
3945 (void)rootType;
3946 (void)toCount;
3947 (void)count;
3948 *count += sizeof(VkStructureType);
3949 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3950 rootType = toCount->sType;
3951 }
3952 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3953 *count += sizeof(VkBool32);
3954 *count += sizeof(VkBool32);
3955 }
3956
count_VkPhysicalDeviceFloatControlsProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceFloatControlsProperties * toCount,size_t * count)3957 void count_VkPhysicalDeviceFloatControlsProperties(
3958 uint32_t featureBits, VkStructureType rootType,
3959 const VkPhysicalDeviceFloatControlsProperties* toCount, size_t* count) {
3960 (void)featureBits;
3961 (void)rootType;
3962 (void)toCount;
3963 (void)count;
3964 *count += sizeof(VkStructureType);
3965 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3966 rootType = toCount->sType;
3967 }
3968 count_extension_struct(featureBits, rootType, toCount->pNext, count);
3969 *count += sizeof(VkShaderFloatControlsIndependence);
3970 *count += sizeof(VkShaderFloatControlsIndependence);
3971 *count += sizeof(VkBool32);
3972 *count += sizeof(VkBool32);
3973 *count += sizeof(VkBool32);
3974 *count += sizeof(VkBool32);
3975 *count += sizeof(VkBool32);
3976 *count += sizeof(VkBool32);
3977 *count += sizeof(VkBool32);
3978 *count += sizeof(VkBool32);
3979 *count += sizeof(VkBool32);
3980 *count += sizeof(VkBool32);
3981 *count += sizeof(VkBool32);
3982 *count += sizeof(VkBool32);
3983 *count += sizeof(VkBool32);
3984 *count += sizeof(VkBool32);
3985 *count += sizeof(VkBool32);
3986 }
3987
count_VkDescriptorSetLayoutBindingFlagsCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkDescriptorSetLayoutBindingFlagsCreateInfo * toCount,size_t * count)3988 void count_VkDescriptorSetLayoutBindingFlagsCreateInfo(
3989 uint32_t featureBits, VkStructureType rootType,
3990 const VkDescriptorSetLayoutBindingFlagsCreateInfo* toCount, size_t* count) {
3991 (void)featureBits;
3992 (void)rootType;
3993 (void)toCount;
3994 (void)count;
3995 *count += sizeof(VkStructureType);
3996 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
3997 rootType = toCount->sType;
3998 }
3999 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4000 *count += sizeof(uint32_t);
4001 // WARNING PTR CHECK
4002 *count += 8;
4003 if (toCount->pBindingFlags) {
4004 if (toCount) {
4005 *count += toCount->bindingCount * sizeof(const VkDescriptorBindingFlags);
4006 }
4007 }
4008 }
4009
count_VkPhysicalDeviceDescriptorIndexingFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceDescriptorIndexingFeatures * toCount,size_t * count)4010 void count_VkPhysicalDeviceDescriptorIndexingFeatures(
4011 uint32_t featureBits, VkStructureType rootType,
4012 const VkPhysicalDeviceDescriptorIndexingFeatures* toCount, size_t* count) {
4013 (void)featureBits;
4014 (void)rootType;
4015 (void)toCount;
4016 (void)count;
4017 *count += sizeof(VkStructureType);
4018 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4019 rootType = toCount->sType;
4020 }
4021 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4022 *count += sizeof(VkBool32);
4023 *count += sizeof(VkBool32);
4024 *count += sizeof(VkBool32);
4025 *count += sizeof(VkBool32);
4026 *count += sizeof(VkBool32);
4027 *count += sizeof(VkBool32);
4028 *count += sizeof(VkBool32);
4029 *count += sizeof(VkBool32);
4030 *count += sizeof(VkBool32);
4031 *count += sizeof(VkBool32);
4032 *count += sizeof(VkBool32);
4033 *count += sizeof(VkBool32);
4034 *count += sizeof(VkBool32);
4035 *count += sizeof(VkBool32);
4036 *count += sizeof(VkBool32);
4037 *count += sizeof(VkBool32);
4038 *count += sizeof(VkBool32);
4039 *count += sizeof(VkBool32);
4040 *count += sizeof(VkBool32);
4041 *count += sizeof(VkBool32);
4042 }
4043
count_VkPhysicalDeviceDescriptorIndexingProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceDescriptorIndexingProperties * toCount,size_t * count)4044 void count_VkPhysicalDeviceDescriptorIndexingProperties(
4045 uint32_t featureBits, VkStructureType rootType,
4046 const VkPhysicalDeviceDescriptorIndexingProperties* toCount, size_t* count) {
4047 (void)featureBits;
4048 (void)rootType;
4049 (void)toCount;
4050 (void)count;
4051 *count += sizeof(VkStructureType);
4052 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4053 rootType = toCount->sType;
4054 }
4055 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4056 *count += sizeof(uint32_t);
4057 *count += sizeof(VkBool32);
4058 *count += sizeof(VkBool32);
4059 *count += sizeof(VkBool32);
4060 *count += sizeof(VkBool32);
4061 *count += sizeof(VkBool32);
4062 *count += sizeof(VkBool32);
4063 *count += sizeof(VkBool32);
4064 *count += sizeof(uint32_t);
4065 *count += sizeof(uint32_t);
4066 *count += sizeof(uint32_t);
4067 *count += sizeof(uint32_t);
4068 *count += sizeof(uint32_t);
4069 *count += sizeof(uint32_t);
4070 *count += sizeof(uint32_t);
4071 *count += sizeof(uint32_t);
4072 *count += sizeof(uint32_t);
4073 *count += sizeof(uint32_t);
4074 *count += sizeof(uint32_t);
4075 *count += sizeof(uint32_t);
4076 *count += sizeof(uint32_t);
4077 *count += sizeof(uint32_t);
4078 *count += sizeof(uint32_t);
4079 }
4080
count_VkDescriptorSetVariableDescriptorCountAllocateInfo(uint32_t featureBits,VkStructureType rootType,const VkDescriptorSetVariableDescriptorCountAllocateInfo * toCount,size_t * count)4081 void count_VkDescriptorSetVariableDescriptorCountAllocateInfo(
4082 uint32_t featureBits, VkStructureType rootType,
4083 const VkDescriptorSetVariableDescriptorCountAllocateInfo* toCount, size_t* count) {
4084 (void)featureBits;
4085 (void)rootType;
4086 (void)toCount;
4087 (void)count;
4088 *count += sizeof(VkStructureType);
4089 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4090 rootType = toCount->sType;
4091 }
4092 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4093 *count += sizeof(uint32_t);
4094 if (toCount) {
4095 *count += toCount->descriptorSetCount * sizeof(const uint32_t);
4096 }
4097 }
4098
count_VkDescriptorSetVariableDescriptorCountLayoutSupport(uint32_t featureBits,VkStructureType rootType,const VkDescriptorSetVariableDescriptorCountLayoutSupport * toCount,size_t * count)4099 void count_VkDescriptorSetVariableDescriptorCountLayoutSupport(
4100 uint32_t featureBits, VkStructureType rootType,
4101 const VkDescriptorSetVariableDescriptorCountLayoutSupport* toCount, size_t* count) {
4102 (void)featureBits;
4103 (void)rootType;
4104 (void)toCount;
4105 (void)count;
4106 *count += sizeof(VkStructureType);
4107 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4108 rootType = toCount->sType;
4109 }
4110 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4111 *count += sizeof(uint32_t);
4112 }
4113
count_VkSubpassDescriptionDepthStencilResolve(uint32_t featureBits,VkStructureType rootType,const VkSubpassDescriptionDepthStencilResolve * toCount,size_t * count)4114 void count_VkSubpassDescriptionDepthStencilResolve(
4115 uint32_t featureBits, VkStructureType rootType,
4116 const VkSubpassDescriptionDepthStencilResolve* toCount, size_t* count) {
4117 (void)featureBits;
4118 (void)rootType;
4119 (void)toCount;
4120 (void)count;
4121 *count += sizeof(VkStructureType);
4122 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4123 rootType = toCount->sType;
4124 }
4125 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4126 *count += sizeof(VkResolveModeFlagBits);
4127 *count += sizeof(VkResolveModeFlagBits);
4128 // WARNING PTR CHECK
4129 *count += 8;
4130 if (toCount->pDepthStencilResolveAttachment) {
4131 count_VkAttachmentReference2(
4132 featureBits, rootType,
4133 (const VkAttachmentReference2*)(toCount->pDepthStencilResolveAttachment), count);
4134 }
4135 }
4136
count_VkPhysicalDeviceDepthStencilResolveProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceDepthStencilResolveProperties * toCount,size_t * count)4137 void count_VkPhysicalDeviceDepthStencilResolveProperties(
4138 uint32_t featureBits, VkStructureType rootType,
4139 const VkPhysicalDeviceDepthStencilResolveProperties* toCount, size_t* count) {
4140 (void)featureBits;
4141 (void)rootType;
4142 (void)toCount;
4143 (void)count;
4144 *count += sizeof(VkStructureType);
4145 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4146 rootType = toCount->sType;
4147 }
4148 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4149 *count += sizeof(VkResolveModeFlags);
4150 *count += sizeof(VkResolveModeFlags);
4151 *count += sizeof(VkBool32);
4152 *count += sizeof(VkBool32);
4153 }
4154
count_VkPhysicalDeviceScalarBlockLayoutFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceScalarBlockLayoutFeatures * toCount,size_t * count)4155 void count_VkPhysicalDeviceScalarBlockLayoutFeatures(
4156 uint32_t featureBits, VkStructureType rootType,
4157 const VkPhysicalDeviceScalarBlockLayoutFeatures* toCount, size_t* count) {
4158 (void)featureBits;
4159 (void)rootType;
4160 (void)toCount;
4161 (void)count;
4162 *count += sizeof(VkStructureType);
4163 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4164 rootType = toCount->sType;
4165 }
4166 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4167 *count += sizeof(VkBool32);
4168 }
4169
count_VkImageStencilUsageCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkImageStencilUsageCreateInfo * toCount,size_t * count)4170 void count_VkImageStencilUsageCreateInfo(uint32_t featureBits, VkStructureType rootType,
4171 const VkImageStencilUsageCreateInfo* toCount,
4172 size_t* count) {
4173 (void)featureBits;
4174 (void)rootType;
4175 (void)toCount;
4176 (void)count;
4177 *count += sizeof(VkStructureType);
4178 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4179 rootType = toCount->sType;
4180 }
4181 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4182 *count += sizeof(VkImageUsageFlags);
4183 }
4184
count_VkSamplerReductionModeCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkSamplerReductionModeCreateInfo * toCount,size_t * count)4185 void count_VkSamplerReductionModeCreateInfo(uint32_t featureBits, VkStructureType rootType,
4186 const VkSamplerReductionModeCreateInfo* toCount,
4187 size_t* count) {
4188 (void)featureBits;
4189 (void)rootType;
4190 (void)toCount;
4191 (void)count;
4192 *count += sizeof(VkStructureType);
4193 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4194 rootType = toCount->sType;
4195 }
4196 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4197 *count += sizeof(VkSamplerReductionMode);
4198 }
4199
count_VkPhysicalDeviceSamplerFilterMinmaxProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceSamplerFilterMinmaxProperties * toCount,size_t * count)4200 void count_VkPhysicalDeviceSamplerFilterMinmaxProperties(
4201 uint32_t featureBits, VkStructureType rootType,
4202 const VkPhysicalDeviceSamplerFilterMinmaxProperties* toCount, size_t* count) {
4203 (void)featureBits;
4204 (void)rootType;
4205 (void)toCount;
4206 (void)count;
4207 *count += sizeof(VkStructureType);
4208 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4209 rootType = toCount->sType;
4210 }
4211 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4212 *count += sizeof(VkBool32);
4213 *count += sizeof(VkBool32);
4214 }
4215
count_VkPhysicalDeviceVulkanMemoryModelFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceVulkanMemoryModelFeatures * toCount,size_t * count)4216 void count_VkPhysicalDeviceVulkanMemoryModelFeatures(
4217 uint32_t featureBits, VkStructureType rootType,
4218 const VkPhysicalDeviceVulkanMemoryModelFeatures* toCount, size_t* count) {
4219 (void)featureBits;
4220 (void)rootType;
4221 (void)toCount;
4222 (void)count;
4223 *count += sizeof(VkStructureType);
4224 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4225 rootType = toCount->sType;
4226 }
4227 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4228 *count += sizeof(VkBool32);
4229 *count += sizeof(VkBool32);
4230 *count += sizeof(VkBool32);
4231 }
4232
count_VkPhysicalDeviceImagelessFramebufferFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceImagelessFramebufferFeatures * toCount,size_t * count)4233 void count_VkPhysicalDeviceImagelessFramebufferFeatures(
4234 uint32_t featureBits, VkStructureType rootType,
4235 const VkPhysicalDeviceImagelessFramebufferFeatures* toCount, size_t* count) {
4236 (void)featureBits;
4237 (void)rootType;
4238 (void)toCount;
4239 (void)count;
4240 *count += sizeof(VkStructureType);
4241 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4242 rootType = toCount->sType;
4243 }
4244 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4245 *count += sizeof(VkBool32);
4246 }
4247
count_VkFramebufferAttachmentImageInfo(uint32_t featureBits,VkStructureType rootType,const VkFramebufferAttachmentImageInfo * toCount,size_t * count)4248 void count_VkFramebufferAttachmentImageInfo(uint32_t featureBits, VkStructureType rootType,
4249 const VkFramebufferAttachmentImageInfo* toCount,
4250 size_t* count) {
4251 (void)featureBits;
4252 (void)rootType;
4253 (void)toCount;
4254 (void)count;
4255 *count += sizeof(VkStructureType);
4256 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4257 rootType = toCount->sType;
4258 }
4259 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4260 *count += sizeof(VkImageCreateFlags);
4261 *count += sizeof(VkImageUsageFlags);
4262 *count += sizeof(uint32_t);
4263 *count += sizeof(uint32_t);
4264 *count += sizeof(uint32_t);
4265 *count += sizeof(uint32_t);
4266 if (toCount) {
4267 *count += toCount->viewFormatCount * sizeof(const VkFormat);
4268 }
4269 }
4270
count_VkFramebufferAttachmentsCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkFramebufferAttachmentsCreateInfo * toCount,size_t * count)4271 void count_VkFramebufferAttachmentsCreateInfo(uint32_t featureBits, VkStructureType rootType,
4272 const VkFramebufferAttachmentsCreateInfo* toCount,
4273 size_t* count) {
4274 (void)featureBits;
4275 (void)rootType;
4276 (void)toCount;
4277 (void)count;
4278 *count += sizeof(VkStructureType);
4279 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4280 rootType = toCount->sType;
4281 }
4282 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4283 *count += sizeof(uint32_t);
4284 if (toCount) {
4285 for (uint32_t i = 0; i < (uint32_t)toCount->attachmentImageInfoCount; ++i) {
4286 count_VkFramebufferAttachmentImageInfo(
4287 featureBits, rootType,
4288 (const VkFramebufferAttachmentImageInfo*)(toCount->pAttachmentImageInfos + i),
4289 count);
4290 }
4291 }
4292 }
4293
count_VkRenderPassAttachmentBeginInfo(uint32_t featureBits,VkStructureType rootType,const VkRenderPassAttachmentBeginInfo * toCount,size_t * count)4294 void count_VkRenderPassAttachmentBeginInfo(uint32_t featureBits, VkStructureType rootType,
4295 const VkRenderPassAttachmentBeginInfo* toCount,
4296 size_t* count) {
4297 (void)featureBits;
4298 (void)rootType;
4299 (void)toCount;
4300 (void)count;
4301 *count += sizeof(VkStructureType);
4302 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4303 rootType = toCount->sType;
4304 }
4305 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4306 *count += sizeof(uint32_t);
4307 if (toCount->attachmentCount) {
4308 *count += toCount->attachmentCount * 8;
4309 }
4310 }
4311
count_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * toCount,size_t * count)4312 void count_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
4313 uint32_t featureBits, VkStructureType rootType,
4314 const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toCount, size_t* count) {
4315 (void)featureBits;
4316 (void)rootType;
4317 (void)toCount;
4318 (void)count;
4319 *count += sizeof(VkStructureType);
4320 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4321 rootType = toCount->sType;
4322 }
4323 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4324 *count += sizeof(VkBool32);
4325 }
4326
count_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * toCount,size_t * count)4327 void count_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
4328 uint32_t featureBits, VkStructureType rootType,
4329 const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toCount, size_t* count) {
4330 (void)featureBits;
4331 (void)rootType;
4332 (void)toCount;
4333 (void)count;
4334 *count += sizeof(VkStructureType);
4335 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4336 rootType = toCount->sType;
4337 }
4338 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4339 *count += sizeof(VkBool32);
4340 }
4341
count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * toCount,size_t * count)4342 void count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
4343 uint32_t featureBits, VkStructureType rootType,
4344 const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toCount, size_t* count) {
4345 (void)featureBits;
4346 (void)rootType;
4347 (void)toCount;
4348 (void)count;
4349 *count += sizeof(VkStructureType);
4350 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4351 rootType = toCount->sType;
4352 }
4353 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4354 *count += sizeof(VkBool32);
4355 }
4356
count_VkAttachmentReferenceStencilLayout(uint32_t featureBits,VkStructureType rootType,const VkAttachmentReferenceStencilLayout * toCount,size_t * count)4357 void count_VkAttachmentReferenceStencilLayout(uint32_t featureBits, VkStructureType rootType,
4358 const VkAttachmentReferenceStencilLayout* toCount,
4359 size_t* count) {
4360 (void)featureBits;
4361 (void)rootType;
4362 (void)toCount;
4363 (void)count;
4364 *count += sizeof(VkStructureType);
4365 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4366 rootType = toCount->sType;
4367 }
4368 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4369 *count += sizeof(VkImageLayout);
4370 }
4371
count_VkAttachmentDescriptionStencilLayout(uint32_t featureBits,VkStructureType rootType,const VkAttachmentDescriptionStencilLayout * toCount,size_t * count)4372 void count_VkAttachmentDescriptionStencilLayout(uint32_t featureBits, VkStructureType rootType,
4373 const VkAttachmentDescriptionStencilLayout* toCount,
4374 size_t* count) {
4375 (void)featureBits;
4376 (void)rootType;
4377 (void)toCount;
4378 (void)count;
4379 *count += sizeof(VkStructureType);
4380 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4381 rootType = toCount->sType;
4382 }
4383 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4384 *count += sizeof(VkImageLayout);
4385 *count += sizeof(VkImageLayout);
4386 }
4387
count_VkPhysicalDeviceHostQueryResetFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceHostQueryResetFeatures * toCount,size_t * count)4388 void count_VkPhysicalDeviceHostQueryResetFeatures(
4389 uint32_t featureBits, VkStructureType rootType,
4390 const VkPhysicalDeviceHostQueryResetFeatures* toCount, size_t* count) {
4391 (void)featureBits;
4392 (void)rootType;
4393 (void)toCount;
4394 (void)count;
4395 *count += sizeof(VkStructureType);
4396 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4397 rootType = toCount->sType;
4398 }
4399 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4400 *count += sizeof(VkBool32);
4401 }
4402
count_VkPhysicalDeviceTimelineSemaphoreFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceTimelineSemaphoreFeatures * toCount,size_t * count)4403 void count_VkPhysicalDeviceTimelineSemaphoreFeatures(
4404 uint32_t featureBits, VkStructureType rootType,
4405 const VkPhysicalDeviceTimelineSemaphoreFeatures* toCount, size_t* count) {
4406 (void)featureBits;
4407 (void)rootType;
4408 (void)toCount;
4409 (void)count;
4410 *count += sizeof(VkStructureType);
4411 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4412 rootType = toCount->sType;
4413 }
4414 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4415 *count += sizeof(VkBool32);
4416 }
4417
count_VkPhysicalDeviceTimelineSemaphoreProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceTimelineSemaphoreProperties * toCount,size_t * count)4418 void count_VkPhysicalDeviceTimelineSemaphoreProperties(
4419 uint32_t featureBits, VkStructureType rootType,
4420 const VkPhysicalDeviceTimelineSemaphoreProperties* toCount, size_t* count) {
4421 (void)featureBits;
4422 (void)rootType;
4423 (void)toCount;
4424 (void)count;
4425 *count += sizeof(VkStructureType);
4426 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4427 rootType = toCount->sType;
4428 }
4429 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4430 *count += sizeof(uint64_t);
4431 }
4432
count_VkSemaphoreTypeCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkSemaphoreTypeCreateInfo * toCount,size_t * count)4433 void count_VkSemaphoreTypeCreateInfo(uint32_t featureBits, VkStructureType rootType,
4434 const VkSemaphoreTypeCreateInfo* toCount, size_t* count) {
4435 (void)featureBits;
4436 (void)rootType;
4437 (void)toCount;
4438 (void)count;
4439 *count += sizeof(VkStructureType);
4440 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4441 rootType = toCount->sType;
4442 }
4443 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4444 *count += sizeof(VkSemaphoreType);
4445 *count += sizeof(uint64_t);
4446 }
4447
count_VkTimelineSemaphoreSubmitInfo(uint32_t featureBits,VkStructureType rootType,const VkTimelineSemaphoreSubmitInfo * toCount,size_t * count)4448 void count_VkTimelineSemaphoreSubmitInfo(uint32_t featureBits, VkStructureType rootType,
4449 const VkTimelineSemaphoreSubmitInfo* toCount,
4450 size_t* count) {
4451 (void)featureBits;
4452 (void)rootType;
4453 (void)toCount;
4454 (void)count;
4455 *count += sizeof(VkStructureType);
4456 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4457 rootType = toCount->sType;
4458 }
4459 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4460 *count += sizeof(uint32_t);
4461 // WARNING PTR CHECK
4462 *count += 8;
4463 if (toCount->pWaitSemaphoreValues) {
4464 if (toCount) {
4465 *count += toCount->waitSemaphoreValueCount * sizeof(const uint64_t);
4466 }
4467 }
4468 *count += sizeof(uint32_t);
4469 // WARNING PTR CHECK
4470 *count += 8;
4471 if (toCount->pSignalSemaphoreValues) {
4472 if (toCount) {
4473 *count += toCount->signalSemaphoreValueCount * sizeof(const uint64_t);
4474 }
4475 }
4476 }
4477
count_VkSemaphoreWaitInfo(uint32_t featureBits,VkStructureType rootType,const VkSemaphoreWaitInfo * toCount,size_t * count)4478 void count_VkSemaphoreWaitInfo(uint32_t featureBits, VkStructureType rootType,
4479 const VkSemaphoreWaitInfo* toCount, size_t* count) {
4480 (void)featureBits;
4481 (void)rootType;
4482 (void)toCount;
4483 (void)count;
4484 *count += sizeof(VkStructureType);
4485 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4486 rootType = toCount->sType;
4487 }
4488 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4489 *count += sizeof(VkSemaphoreWaitFlags);
4490 *count += sizeof(uint32_t);
4491 if (toCount->semaphoreCount) {
4492 *count += toCount->semaphoreCount * 8;
4493 }
4494 if (toCount) {
4495 *count += toCount->semaphoreCount * sizeof(const uint64_t);
4496 }
4497 }
4498
count_VkSemaphoreSignalInfo(uint32_t featureBits,VkStructureType rootType,const VkSemaphoreSignalInfo * toCount,size_t * count)4499 void count_VkSemaphoreSignalInfo(uint32_t featureBits, VkStructureType rootType,
4500 const VkSemaphoreSignalInfo* toCount, size_t* count) {
4501 (void)featureBits;
4502 (void)rootType;
4503 (void)toCount;
4504 (void)count;
4505 *count += sizeof(VkStructureType);
4506 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4507 rootType = toCount->sType;
4508 }
4509 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4510 uint64_t cgen_var_0;
4511 *count += 1 * 8;
4512 *count += sizeof(uint64_t);
4513 }
4514
count_VkPhysicalDeviceBufferDeviceAddressFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceBufferDeviceAddressFeatures * toCount,size_t * count)4515 void count_VkPhysicalDeviceBufferDeviceAddressFeatures(
4516 uint32_t featureBits, VkStructureType rootType,
4517 const VkPhysicalDeviceBufferDeviceAddressFeatures* toCount, size_t* count) {
4518 (void)featureBits;
4519 (void)rootType;
4520 (void)toCount;
4521 (void)count;
4522 *count += sizeof(VkStructureType);
4523 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4524 rootType = toCount->sType;
4525 }
4526 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4527 *count += sizeof(VkBool32);
4528 *count += sizeof(VkBool32);
4529 *count += sizeof(VkBool32);
4530 }
4531
count_VkBufferDeviceAddressInfo(uint32_t featureBits,VkStructureType rootType,const VkBufferDeviceAddressInfo * toCount,size_t * count)4532 void count_VkBufferDeviceAddressInfo(uint32_t featureBits, VkStructureType rootType,
4533 const VkBufferDeviceAddressInfo* toCount, size_t* count) {
4534 (void)featureBits;
4535 (void)rootType;
4536 (void)toCount;
4537 (void)count;
4538 *count += sizeof(VkStructureType);
4539 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4540 rootType = toCount->sType;
4541 }
4542 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4543 uint64_t cgen_var_0;
4544 *count += 1 * 8;
4545 }
4546
count_VkBufferOpaqueCaptureAddressCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkBufferOpaqueCaptureAddressCreateInfo * toCount,size_t * count)4547 void count_VkBufferOpaqueCaptureAddressCreateInfo(
4548 uint32_t featureBits, VkStructureType rootType,
4549 const VkBufferOpaqueCaptureAddressCreateInfo* toCount, size_t* count) {
4550 (void)featureBits;
4551 (void)rootType;
4552 (void)toCount;
4553 (void)count;
4554 *count += sizeof(VkStructureType);
4555 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4556 rootType = toCount->sType;
4557 }
4558 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4559 *count += sizeof(uint64_t);
4560 }
4561
count_VkMemoryOpaqueCaptureAddressAllocateInfo(uint32_t featureBits,VkStructureType rootType,const VkMemoryOpaqueCaptureAddressAllocateInfo * toCount,size_t * count)4562 void count_VkMemoryOpaqueCaptureAddressAllocateInfo(
4563 uint32_t featureBits, VkStructureType rootType,
4564 const VkMemoryOpaqueCaptureAddressAllocateInfo* toCount, size_t* count) {
4565 (void)featureBits;
4566 (void)rootType;
4567 (void)toCount;
4568 (void)count;
4569 *count += sizeof(VkStructureType);
4570 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4571 rootType = toCount->sType;
4572 }
4573 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4574 *count += sizeof(uint64_t);
4575 }
4576
count_VkDeviceMemoryOpaqueCaptureAddressInfo(uint32_t featureBits,VkStructureType rootType,const VkDeviceMemoryOpaqueCaptureAddressInfo * toCount,size_t * count)4577 void count_VkDeviceMemoryOpaqueCaptureAddressInfo(
4578 uint32_t featureBits, VkStructureType rootType,
4579 const VkDeviceMemoryOpaqueCaptureAddressInfo* toCount, size_t* count) {
4580 (void)featureBits;
4581 (void)rootType;
4582 (void)toCount;
4583 (void)count;
4584 *count += sizeof(VkStructureType);
4585 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4586 rootType = toCount->sType;
4587 }
4588 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4589 uint64_t cgen_var_0;
4590 *count += 1 * 8;
4591 }
4592
4593 #endif
4594 #ifdef VK_VERSION_1_3
count_VkPhysicalDeviceVulkan13Features(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceVulkan13Features * toCount,size_t * count)4595 void count_VkPhysicalDeviceVulkan13Features(uint32_t featureBits, VkStructureType rootType,
4596 const VkPhysicalDeviceVulkan13Features* toCount,
4597 size_t* count) {
4598 (void)featureBits;
4599 (void)rootType;
4600 (void)toCount;
4601 (void)count;
4602 *count += sizeof(VkStructureType);
4603 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4604 rootType = toCount->sType;
4605 }
4606 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4607 *count += sizeof(VkBool32);
4608 *count += sizeof(VkBool32);
4609 *count += sizeof(VkBool32);
4610 *count += sizeof(VkBool32);
4611 *count += sizeof(VkBool32);
4612 *count += sizeof(VkBool32);
4613 *count += sizeof(VkBool32);
4614 *count += sizeof(VkBool32);
4615 *count += sizeof(VkBool32);
4616 *count += sizeof(VkBool32);
4617 *count += sizeof(VkBool32);
4618 *count += sizeof(VkBool32);
4619 *count += sizeof(VkBool32);
4620 *count += sizeof(VkBool32);
4621 *count += sizeof(VkBool32);
4622 }
4623
count_VkPhysicalDeviceVulkan13Properties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceVulkan13Properties * toCount,size_t * count)4624 void count_VkPhysicalDeviceVulkan13Properties(uint32_t featureBits, VkStructureType rootType,
4625 const VkPhysicalDeviceVulkan13Properties* toCount,
4626 size_t* count) {
4627 (void)featureBits;
4628 (void)rootType;
4629 (void)toCount;
4630 (void)count;
4631 *count += sizeof(VkStructureType);
4632 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4633 rootType = toCount->sType;
4634 }
4635 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4636 *count += sizeof(uint32_t);
4637 *count += sizeof(uint32_t);
4638 *count += sizeof(uint32_t);
4639 *count += sizeof(VkShaderStageFlags);
4640 *count += sizeof(uint32_t);
4641 *count += sizeof(uint32_t);
4642 *count += sizeof(uint32_t);
4643 *count += sizeof(uint32_t);
4644 *count += sizeof(uint32_t);
4645 *count += sizeof(uint32_t);
4646 *count += sizeof(VkBool32);
4647 *count += sizeof(VkBool32);
4648 *count += sizeof(VkBool32);
4649 *count += sizeof(VkBool32);
4650 *count += sizeof(VkBool32);
4651 *count += sizeof(VkBool32);
4652 *count += sizeof(VkBool32);
4653 *count += sizeof(VkBool32);
4654 *count += sizeof(VkBool32);
4655 *count += sizeof(VkBool32);
4656 *count += sizeof(VkBool32);
4657 *count += sizeof(VkBool32);
4658 *count += sizeof(VkBool32);
4659 *count += sizeof(VkBool32);
4660 *count += sizeof(VkBool32);
4661 *count += sizeof(VkBool32);
4662 *count += sizeof(VkBool32);
4663 *count += sizeof(VkBool32);
4664 *count += sizeof(VkBool32);
4665 *count += sizeof(VkBool32);
4666 *count += sizeof(VkBool32);
4667 *count += sizeof(VkBool32);
4668 *count += sizeof(VkBool32);
4669 *count += sizeof(VkBool32);
4670 *count += sizeof(VkBool32);
4671 *count += sizeof(VkBool32);
4672 *count += sizeof(VkBool32);
4673 *count += sizeof(VkBool32);
4674 *count += sizeof(VkBool32);
4675 *count += sizeof(VkBool32);
4676 *count += sizeof(VkDeviceSize);
4677 *count += sizeof(VkBool32);
4678 *count += sizeof(VkDeviceSize);
4679 *count += sizeof(VkBool32);
4680 *count += sizeof(VkDeviceSize);
4681 }
4682
count_VkPipelineCreationFeedback(uint32_t featureBits,VkStructureType rootType,const VkPipelineCreationFeedback * toCount,size_t * count)4683 void count_VkPipelineCreationFeedback(uint32_t featureBits, VkStructureType rootType,
4684 const VkPipelineCreationFeedback* toCount, size_t* count) {
4685 (void)featureBits;
4686 (void)rootType;
4687 (void)toCount;
4688 (void)count;
4689 *count += sizeof(VkPipelineCreationFeedbackFlags);
4690 *count += sizeof(uint64_t);
4691 }
4692
count_VkPipelineCreationFeedbackCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineCreationFeedbackCreateInfo * toCount,size_t * count)4693 void count_VkPipelineCreationFeedbackCreateInfo(uint32_t featureBits, VkStructureType rootType,
4694 const VkPipelineCreationFeedbackCreateInfo* toCount,
4695 size_t* count) {
4696 (void)featureBits;
4697 (void)rootType;
4698 (void)toCount;
4699 (void)count;
4700 *count += sizeof(VkStructureType);
4701 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4702 rootType = toCount->sType;
4703 }
4704 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4705 count_VkPipelineCreationFeedback(
4706 featureBits, rootType, (VkPipelineCreationFeedback*)(toCount->pPipelineCreationFeedback),
4707 count);
4708 *count += sizeof(uint32_t);
4709 if (toCount) {
4710 for (uint32_t i = 0; i < (uint32_t)toCount->pipelineStageCreationFeedbackCount; ++i) {
4711 count_VkPipelineCreationFeedback(
4712 featureBits, rootType,
4713 (VkPipelineCreationFeedback*)(toCount->pPipelineStageCreationFeedbacks + i), count);
4714 }
4715 }
4716 }
4717
count_VkPhysicalDeviceShaderTerminateInvocationFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceShaderTerminateInvocationFeatures * toCount,size_t * count)4718 void count_VkPhysicalDeviceShaderTerminateInvocationFeatures(
4719 uint32_t featureBits, VkStructureType rootType,
4720 const VkPhysicalDeviceShaderTerminateInvocationFeatures* toCount, size_t* count) {
4721 (void)featureBits;
4722 (void)rootType;
4723 (void)toCount;
4724 (void)count;
4725 *count += sizeof(VkStructureType);
4726 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4727 rootType = toCount->sType;
4728 }
4729 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4730 *count += sizeof(VkBool32);
4731 }
4732
count_VkPhysicalDeviceToolProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceToolProperties * toCount,size_t * count)4733 void count_VkPhysicalDeviceToolProperties(uint32_t featureBits, VkStructureType rootType,
4734 const VkPhysicalDeviceToolProperties* toCount,
4735 size_t* count) {
4736 (void)featureBits;
4737 (void)rootType;
4738 (void)toCount;
4739 (void)count;
4740 *count += sizeof(VkStructureType);
4741 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4742 rootType = toCount->sType;
4743 }
4744 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4745 *count += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
4746 *count += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
4747 *count += sizeof(VkToolPurposeFlags);
4748 *count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
4749 *count += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
4750 }
4751
count_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * toCount,size_t * count)4752 void count_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
4753 uint32_t featureBits, VkStructureType rootType,
4754 const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* toCount, size_t* count) {
4755 (void)featureBits;
4756 (void)rootType;
4757 (void)toCount;
4758 (void)count;
4759 *count += sizeof(VkStructureType);
4760 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4761 rootType = toCount->sType;
4762 }
4763 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4764 *count += sizeof(VkBool32);
4765 }
4766
count_VkPhysicalDevicePrivateDataFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDevicePrivateDataFeatures * toCount,size_t * count)4767 void count_VkPhysicalDevicePrivateDataFeatures(uint32_t featureBits, VkStructureType rootType,
4768 const VkPhysicalDevicePrivateDataFeatures* toCount,
4769 size_t* count) {
4770 (void)featureBits;
4771 (void)rootType;
4772 (void)toCount;
4773 (void)count;
4774 *count += sizeof(VkStructureType);
4775 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4776 rootType = toCount->sType;
4777 }
4778 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4779 *count += sizeof(VkBool32);
4780 }
4781
count_VkDevicePrivateDataCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkDevicePrivateDataCreateInfo * toCount,size_t * count)4782 void count_VkDevicePrivateDataCreateInfo(uint32_t featureBits, VkStructureType rootType,
4783 const VkDevicePrivateDataCreateInfo* toCount,
4784 size_t* count) {
4785 (void)featureBits;
4786 (void)rootType;
4787 (void)toCount;
4788 (void)count;
4789 *count += sizeof(VkStructureType);
4790 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4791 rootType = toCount->sType;
4792 }
4793 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4794 *count += sizeof(uint32_t);
4795 }
4796
count_VkPrivateDataSlotCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPrivateDataSlotCreateInfo * toCount,size_t * count)4797 void count_VkPrivateDataSlotCreateInfo(uint32_t featureBits, VkStructureType rootType,
4798 const VkPrivateDataSlotCreateInfo* toCount, size_t* count) {
4799 (void)featureBits;
4800 (void)rootType;
4801 (void)toCount;
4802 (void)count;
4803 *count += sizeof(VkStructureType);
4804 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4805 rootType = toCount->sType;
4806 }
4807 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4808 *count += sizeof(VkPrivateDataSlotCreateFlags);
4809 }
4810
count_VkPhysicalDevicePipelineCreationCacheControlFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDevicePipelineCreationCacheControlFeatures * toCount,size_t * count)4811 void count_VkPhysicalDevicePipelineCreationCacheControlFeatures(
4812 uint32_t featureBits, VkStructureType rootType,
4813 const VkPhysicalDevicePipelineCreationCacheControlFeatures* toCount, size_t* count) {
4814 (void)featureBits;
4815 (void)rootType;
4816 (void)toCount;
4817 (void)count;
4818 *count += sizeof(VkStructureType);
4819 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4820 rootType = toCount->sType;
4821 }
4822 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4823 *count += sizeof(VkBool32);
4824 }
4825
count_VkMemoryBarrier2(uint32_t featureBits,VkStructureType rootType,const VkMemoryBarrier2 * toCount,size_t * count)4826 void count_VkMemoryBarrier2(uint32_t featureBits, VkStructureType rootType,
4827 const VkMemoryBarrier2* toCount, size_t* count) {
4828 (void)featureBits;
4829 (void)rootType;
4830 (void)toCount;
4831 (void)count;
4832 *count += sizeof(VkStructureType);
4833 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4834 rootType = toCount->sType;
4835 }
4836 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4837 *count += sizeof(VkPipelineStageFlags2);
4838 *count += sizeof(VkAccessFlags2);
4839 *count += sizeof(VkPipelineStageFlags2);
4840 *count += sizeof(VkAccessFlags2);
4841 }
4842
count_VkBufferMemoryBarrier2(uint32_t featureBits,VkStructureType rootType,const VkBufferMemoryBarrier2 * toCount,size_t * count)4843 void count_VkBufferMemoryBarrier2(uint32_t featureBits, VkStructureType rootType,
4844 const VkBufferMemoryBarrier2* toCount, size_t* count) {
4845 (void)featureBits;
4846 (void)rootType;
4847 (void)toCount;
4848 (void)count;
4849 *count += sizeof(VkStructureType);
4850 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4851 rootType = toCount->sType;
4852 }
4853 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4854 *count += sizeof(VkPipelineStageFlags2);
4855 *count += sizeof(VkAccessFlags2);
4856 *count += sizeof(VkPipelineStageFlags2);
4857 *count += sizeof(VkAccessFlags2);
4858 *count += sizeof(uint32_t);
4859 *count += sizeof(uint32_t);
4860 uint64_t cgen_var_0;
4861 *count += 1 * 8;
4862 *count += sizeof(VkDeviceSize);
4863 *count += sizeof(VkDeviceSize);
4864 }
4865
count_VkImageMemoryBarrier2(uint32_t featureBits,VkStructureType rootType,const VkImageMemoryBarrier2 * toCount,size_t * count)4866 void count_VkImageMemoryBarrier2(uint32_t featureBits, VkStructureType rootType,
4867 const VkImageMemoryBarrier2* toCount, size_t* count) {
4868 (void)featureBits;
4869 (void)rootType;
4870 (void)toCount;
4871 (void)count;
4872 *count += sizeof(VkStructureType);
4873 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4874 rootType = toCount->sType;
4875 }
4876 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4877 *count += sizeof(VkPipelineStageFlags2);
4878 *count += sizeof(VkAccessFlags2);
4879 *count += sizeof(VkPipelineStageFlags2);
4880 *count += sizeof(VkAccessFlags2);
4881 *count += sizeof(VkImageLayout);
4882 *count += sizeof(VkImageLayout);
4883 *count += sizeof(uint32_t);
4884 *count += sizeof(uint32_t);
4885 uint64_t cgen_var_0;
4886 *count += 1 * 8;
4887 count_VkImageSubresourceRange(featureBits, rootType,
4888 (VkImageSubresourceRange*)(&toCount->subresourceRange), count);
4889 }
4890
count_VkDependencyInfo(uint32_t featureBits,VkStructureType rootType,const VkDependencyInfo * toCount,size_t * count)4891 void count_VkDependencyInfo(uint32_t featureBits, VkStructureType rootType,
4892 const VkDependencyInfo* toCount, size_t* count) {
4893 (void)featureBits;
4894 (void)rootType;
4895 (void)toCount;
4896 (void)count;
4897 *count += sizeof(VkStructureType);
4898 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4899 rootType = toCount->sType;
4900 }
4901 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4902 *count += sizeof(VkDependencyFlags);
4903 *count += sizeof(uint32_t);
4904 if (toCount) {
4905 for (uint32_t i = 0; i < (uint32_t)toCount->memoryBarrierCount; ++i) {
4906 count_VkMemoryBarrier2(featureBits, rootType,
4907 (const VkMemoryBarrier2*)(toCount->pMemoryBarriers + i), count);
4908 }
4909 }
4910 *count += sizeof(uint32_t);
4911 if (toCount) {
4912 for (uint32_t i = 0; i < (uint32_t)toCount->bufferMemoryBarrierCount; ++i) {
4913 count_VkBufferMemoryBarrier2(
4914 featureBits, rootType,
4915 (const VkBufferMemoryBarrier2*)(toCount->pBufferMemoryBarriers + i), count);
4916 }
4917 }
4918 *count += sizeof(uint32_t);
4919 if (toCount) {
4920 for (uint32_t i = 0; i < (uint32_t)toCount->imageMemoryBarrierCount; ++i) {
4921 count_VkImageMemoryBarrier2(
4922 featureBits, rootType,
4923 (const VkImageMemoryBarrier2*)(toCount->pImageMemoryBarriers + i), count);
4924 }
4925 }
4926 }
4927
count_VkSemaphoreSubmitInfo(uint32_t featureBits,VkStructureType rootType,const VkSemaphoreSubmitInfo * toCount,size_t * count)4928 void count_VkSemaphoreSubmitInfo(uint32_t featureBits, VkStructureType rootType,
4929 const VkSemaphoreSubmitInfo* toCount, size_t* count) {
4930 (void)featureBits;
4931 (void)rootType;
4932 (void)toCount;
4933 (void)count;
4934 *count += sizeof(VkStructureType);
4935 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4936 rootType = toCount->sType;
4937 }
4938 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4939 uint64_t cgen_var_0;
4940 *count += 1 * 8;
4941 *count += sizeof(uint64_t);
4942 *count += sizeof(VkPipelineStageFlags2);
4943 *count += sizeof(uint32_t);
4944 }
4945
count_VkCommandBufferSubmitInfo(uint32_t featureBits,VkStructureType rootType,const VkCommandBufferSubmitInfo * toCount,size_t * count)4946 void count_VkCommandBufferSubmitInfo(uint32_t featureBits, VkStructureType rootType,
4947 const VkCommandBufferSubmitInfo* toCount, size_t* count) {
4948 (void)featureBits;
4949 (void)rootType;
4950 (void)toCount;
4951 (void)count;
4952 *count += sizeof(VkStructureType);
4953 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4954 rootType = toCount->sType;
4955 }
4956 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4957 uint64_t cgen_var_0;
4958 *count += 1 * 8;
4959 *count += sizeof(uint32_t);
4960 }
4961
count_VkSubmitInfo2(uint32_t featureBits,VkStructureType rootType,const VkSubmitInfo2 * toCount,size_t * count)4962 void count_VkSubmitInfo2(uint32_t featureBits, VkStructureType rootType,
4963 const VkSubmitInfo2* toCount, size_t* count) {
4964 (void)featureBits;
4965 (void)rootType;
4966 (void)toCount;
4967 (void)count;
4968 *count += sizeof(VkStructureType);
4969 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
4970 rootType = toCount->sType;
4971 }
4972 count_extension_struct(featureBits, rootType, toCount->pNext, count);
4973 *count += sizeof(VkSubmitFlags);
4974 *count += sizeof(uint32_t);
4975 if (toCount) {
4976 for (uint32_t i = 0; i < (uint32_t)toCount->waitSemaphoreInfoCount; ++i) {
4977 count_VkSemaphoreSubmitInfo(
4978 featureBits, rootType,
4979 (const VkSemaphoreSubmitInfo*)(toCount->pWaitSemaphoreInfos + i), count);
4980 }
4981 }
4982 *count += sizeof(uint32_t);
4983 if (toCount) {
4984 for (uint32_t i = 0; i < (uint32_t)toCount->commandBufferInfoCount; ++i) {
4985 count_VkCommandBufferSubmitInfo(
4986 featureBits, rootType,
4987 (const VkCommandBufferSubmitInfo*)(toCount->pCommandBufferInfos + i), count);
4988 }
4989 }
4990 *count += sizeof(uint32_t);
4991 if (toCount) {
4992 for (uint32_t i = 0; i < (uint32_t)toCount->signalSemaphoreInfoCount; ++i) {
4993 count_VkSemaphoreSubmitInfo(
4994 featureBits, rootType,
4995 (const VkSemaphoreSubmitInfo*)(toCount->pSignalSemaphoreInfos + i), count);
4996 }
4997 }
4998 }
4999
count_VkPhysicalDeviceSynchronization2Features(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceSynchronization2Features * toCount,size_t * count)5000 void count_VkPhysicalDeviceSynchronization2Features(
5001 uint32_t featureBits, VkStructureType rootType,
5002 const VkPhysicalDeviceSynchronization2Features* toCount, size_t* count) {
5003 (void)featureBits;
5004 (void)rootType;
5005 (void)toCount;
5006 (void)count;
5007 *count += sizeof(VkStructureType);
5008 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5009 rootType = toCount->sType;
5010 }
5011 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5012 *count += sizeof(VkBool32);
5013 }
5014
count_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * toCount,size_t * count)5015 void count_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
5016 uint32_t featureBits, VkStructureType rootType,
5017 const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* toCount, size_t* count) {
5018 (void)featureBits;
5019 (void)rootType;
5020 (void)toCount;
5021 (void)count;
5022 *count += sizeof(VkStructureType);
5023 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5024 rootType = toCount->sType;
5025 }
5026 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5027 *count += sizeof(VkBool32);
5028 }
5029
count_VkPhysicalDeviceImageRobustnessFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceImageRobustnessFeatures * toCount,size_t * count)5030 void count_VkPhysicalDeviceImageRobustnessFeatures(
5031 uint32_t featureBits, VkStructureType rootType,
5032 const VkPhysicalDeviceImageRobustnessFeatures* toCount, size_t* count) {
5033 (void)featureBits;
5034 (void)rootType;
5035 (void)toCount;
5036 (void)count;
5037 *count += sizeof(VkStructureType);
5038 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5039 rootType = toCount->sType;
5040 }
5041 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5042 *count += sizeof(VkBool32);
5043 }
5044
count_VkBufferCopy2(uint32_t featureBits,VkStructureType rootType,const VkBufferCopy2 * toCount,size_t * count)5045 void count_VkBufferCopy2(uint32_t featureBits, VkStructureType rootType,
5046 const VkBufferCopy2* toCount, size_t* count) {
5047 (void)featureBits;
5048 (void)rootType;
5049 (void)toCount;
5050 (void)count;
5051 *count += sizeof(VkStructureType);
5052 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5053 rootType = toCount->sType;
5054 }
5055 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5056 *count += sizeof(VkDeviceSize);
5057 *count += sizeof(VkDeviceSize);
5058 *count += sizeof(VkDeviceSize);
5059 }
5060
count_VkCopyBufferInfo2(uint32_t featureBits,VkStructureType rootType,const VkCopyBufferInfo2 * toCount,size_t * count)5061 void count_VkCopyBufferInfo2(uint32_t featureBits, VkStructureType rootType,
5062 const VkCopyBufferInfo2* toCount, size_t* count) {
5063 (void)featureBits;
5064 (void)rootType;
5065 (void)toCount;
5066 (void)count;
5067 *count += sizeof(VkStructureType);
5068 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5069 rootType = toCount->sType;
5070 }
5071 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5072 uint64_t cgen_var_0;
5073 *count += 1 * 8;
5074 uint64_t cgen_var_1;
5075 *count += 1 * 8;
5076 *count += sizeof(uint32_t);
5077 if (toCount) {
5078 for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
5079 count_VkBufferCopy2(featureBits, rootType,
5080 (const VkBufferCopy2*)(toCount->pRegions + i), count);
5081 }
5082 }
5083 }
5084
count_VkImageCopy2(uint32_t featureBits,VkStructureType rootType,const VkImageCopy2 * toCount,size_t * count)5085 void count_VkImageCopy2(uint32_t featureBits, VkStructureType rootType, const VkImageCopy2* toCount,
5086 size_t* count) {
5087 (void)featureBits;
5088 (void)rootType;
5089 (void)toCount;
5090 (void)count;
5091 *count += sizeof(VkStructureType);
5092 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5093 rootType = toCount->sType;
5094 }
5095 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5096 count_VkImageSubresourceLayers(featureBits, rootType,
5097 (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
5098 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->srcOffset), count);
5099 count_VkImageSubresourceLayers(featureBits, rootType,
5100 (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
5101 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->dstOffset), count);
5102 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->extent), count);
5103 }
5104
count_VkCopyImageInfo2(uint32_t featureBits,VkStructureType rootType,const VkCopyImageInfo2 * toCount,size_t * count)5105 void count_VkCopyImageInfo2(uint32_t featureBits, VkStructureType rootType,
5106 const VkCopyImageInfo2* toCount, size_t* count) {
5107 (void)featureBits;
5108 (void)rootType;
5109 (void)toCount;
5110 (void)count;
5111 *count += sizeof(VkStructureType);
5112 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5113 rootType = toCount->sType;
5114 }
5115 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5116 uint64_t cgen_var_0;
5117 *count += 1 * 8;
5118 *count += sizeof(VkImageLayout);
5119 uint64_t cgen_var_1;
5120 *count += 1 * 8;
5121 *count += sizeof(VkImageLayout);
5122 *count += sizeof(uint32_t);
5123 if (toCount) {
5124 for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
5125 count_VkImageCopy2(featureBits, rootType, (const VkImageCopy2*)(toCount->pRegions + i),
5126 count);
5127 }
5128 }
5129 }
5130
count_VkBufferImageCopy2(uint32_t featureBits,VkStructureType rootType,const VkBufferImageCopy2 * toCount,size_t * count)5131 void count_VkBufferImageCopy2(uint32_t featureBits, VkStructureType rootType,
5132 const VkBufferImageCopy2* toCount, size_t* count) {
5133 (void)featureBits;
5134 (void)rootType;
5135 (void)toCount;
5136 (void)count;
5137 *count += sizeof(VkStructureType);
5138 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5139 rootType = toCount->sType;
5140 }
5141 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5142 *count += sizeof(VkDeviceSize);
5143 *count += sizeof(uint32_t);
5144 *count += sizeof(uint32_t);
5145 count_VkImageSubresourceLayers(featureBits, rootType,
5146 (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
5147 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->imageOffset), count);
5148 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->imageExtent), count);
5149 }
5150
count_VkCopyBufferToImageInfo2(uint32_t featureBits,VkStructureType rootType,const VkCopyBufferToImageInfo2 * toCount,size_t * count)5151 void count_VkCopyBufferToImageInfo2(uint32_t featureBits, VkStructureType rootType,
5152 const VkCopyBufferToImageInfo2* toCount, size_t* count) {
5153 (void)featureBits;
5154 (void)rootType;
5155 (void)toCount;
5156 (void)count;
5157 *count += sizeof(VkStructureType);
5158 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5159 rootType = toCount->sType;
5160 }
5161 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5162 uint64_t cgen_var_0;
5163 *count += 1 * 8;
5164 uint64_t cgen_var_1;
5165 *count += 1 * 8;
5166 *count += sizeof(VkImageLayout);
5167 *count += sizeof(uint32_t);
5168 if (toCount) {
5169 for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
5170 count_VkBufferImageCopy2(featureBits, rootType,
5171 (const VkBufferImageCopy2*)(toCount->pRegions + i), count);
5172 }
5173 }
5174 }
5175
count_VkCopyImageToBufferInfo2(uint32_t featureBits,VkStructureType rootType,const VkCopyImageToBufferInfo2 * toCount,size_t * count)5176 void count_VkCopyImageToBufferInfo2(uint32_t featureBits, VkStructureType rootType,
5177 const VkCopyImageToBufferInfo2* toCount, size_t* count) {
5178 (void)featureBits;
5179 (void)rootType;
5180 (void)toCount;
5181 (void)count;
5182 *count += sizeof(VkStructureType);
5183 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5184 rootType = toCount->sType;
5185 }
5186 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5187 uint64_t cgen_var_0;
5188 *count += 1 * 8;
5189 *count += sizeof(VkImageLayout);
5190 uint64_t cgen_var_1;
5191 *count += 1 * 8;
5192 *count += sizeof(uint32_t);
5193 if (toCount) {
5194 for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
5195 count_VkBufferImageCopy2(featureBits, rootType,
5196 (const VkBufferImageCopy2*)(toCount->pRegions + i), count);
5197 }
5198 }
5199 }
5200
count_VkImageBlit2(uint32_t featureBits,VkStructureType rootType,const VkImageBlit2 * toCount,size_t * count)5201 void count_VkImageBlit2(uint32_t featureBits, VkStructureType rootType, const VkImageBlit2* toCount,
5202 size_t* count) {
5203 (void)featureBits;
5204 (void)rootType;
5205 (void)toCount;
5206 (void)count;
5207 *count += sizeof(VkStructureType);
5208 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5209 rootType = toCount->sType;
5210 }
5211 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5212 count_VkImageSubresourceLayers(featureBits, rootType,
5213 (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
5214 for (uint32_t i = 0; i < (uint32_t)2; ++i) {
5215 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(toCount->srcOffsets + i), count);
5216 }
5217 count_VkImageSubresourceLayers(featureBits, rootType,
5218 (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
5219 for (uint32_t i = 0; i < (uint32_t)2; ++i) {
5220 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(toCount->dstOffsets + i), count);
5221 }
5222 }
5223
count_VkBlitImageInfo2(uint32_t featureBits,VkStructureType rootType,const VkBlitImageInfo2 * toCount,size_t * count)5224 void count_VkBlitImageInfo2(uint32_t featureBits, VkStructureType rootType,
5225 const VkBlitImageInfo2* toCount, size_t* count) {
5226 (void)featureBits;
5227 (void)rootType;
5228 (void)toCount;
5229 (void)count;
5230 *count += sizeof(VkStructureType);
5231 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5232 rootType = toCount->sType;
5233 }
5234 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5235 uint64_t cgen_var_0;
5236 *count += 1 * 8;
5237 *count += sizeof(VkImageLayout);
5238 uint64_t cgen_var_1;
5239 *count += 1 * 8;
5240 *count += sizeof(VkImageLayout);
5241 *count += sizeof(uint32_t);
5242 if (toCount) {
5243 for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
5244 count_VkImageBlit2(featureBits, rootType, (const VkImageBlit2*)(toCount->pRegions + i),
5245 count);
5246 }
5247 }
5248 *count += sizeof(VkFilter);
5249 }
5250
count_VkImageResolve2(uint32_t featureBits,VkStructureType rootType,const VkImageResolve2 * toCount,size_t * count)5251 void count_VkImageResolve2(uint32_t featureBits, VkStructureType rootType,
5252 const VkImageResolve2* toCount, size_t* count) {
5253 (void)featureBits;
5254 (void)rootType;
5255 (void)toCount;
5256 (void)count;
5257 *count += sizeof(VkStructureType);
5258 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5259 rootType = toCount->sType;
5260 }
5261 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5262 count_VkImageSubresourceLayers(featureBits, rootType,
5263 (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
5264 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->srcOffset), count);
5265 count_VkImageSubresourceLayers(featureBits, rootType,
5266 (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
5267 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->dstOffset), count);
5268 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->extent), count);
5269 }
5270
count_VkResolveImageInfo2(uint32_t featureBits,VkStructureType rootType,const VkResolveImageInfo2 * toCount,size_t * count)5271 void count_VkResolveImageInfo2(uint32_t featureBits, VkStructureType rootType,
5272 const VkResolveImageInfo2* toCount, size_t* count) {
5273 (void)featureBits;
5274 (void)rootType;
5275 (void)toCount;
5276 (void)count;
5277 *count += sizeof(VkStructureType);
5278 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5279 rootType = toCount->sType;
5280 }
5281 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5282 uint64_t cgen_var_0;
5283 *count += 1 * 8;
5284 *count += sizeof(VkImageLayout);
5285 uint64_t cgen_var_1;
5286 *count += 1 * 8;
5287 *count += sizeof(VkImageLayout);
5288 *count += sizeof(uint32_t);
5289 if (toCount) {
5290 for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
5291 count_VkImageResolve2(featureBits, rootType,
5292 (const VkImageResolve2*)(toCount->pRegions + i), count);
5293 }
5294 }
5295 }
5296
count_VkPhysicalDeviceSubgroupSizeControlFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceSubgroupSizeControlFeatures * toCount,size_t * count)5297 void count_VkPhysicalDeviceSubgroupSizeControlFeatures(
5298 uint32_t featureBits, VkStructureType rootType,
5299 const VkPhysicalDeviceSubgroupSizeControlFeatures* toCount, size_t* count) {
5300 (void)featureBits;
5301 (void)rootType;
5302 (void)toCount;
5303 (void)count;
5304 *count += sizeof(VkStructureType);
5305 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5306 rootType = toCount->sType;
5307 }
5308 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5309 *count += sizeof(VkBool32);
5310 *count += sizeof(VkBool32);
5311 }
5312
count_VkPhysicalDeviceSubgroupSizeControlProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceSubgroupSizeControlProperties * toCount,size_t * count)5313 void count_VkPhysicalDeviceSubgroupSizeControlProperties(
5314 uint32_t featureBits, VkStructureType rootType,
5315 const VkPhysicalDeviceSubgroupSizeControlProperties* toCount, size_t* count) {
5316 (void)featureBits;
5317 (void)rootType;
5318 (void)toCount;
5319 (void)count;
5320 *count += sizeof(VkStructureType);
5321 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5322 rootType = toCount->sType;
5323 }
5324 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5325 *count += sizeof(uint32_t);
5326 *count += sizeof(uint32_t);
5327 *count += sizeof(uint32_t);
5328 *count += sizeof(VkShaderStageFlags);
5329 }
5330
count_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo * toCount,size_t * count)5331 void count_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
5332 uint32_t featureBits, VkStructureType rootType,
5333 const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* toCount, size_t* count) {
5334 (void)featureBits;
5335 (void)rootType;
5336 (void)toCount;
5337 (void)count;
5338 *count += sizeof(VkStructureType);
5339 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5340 rootType = toCount->sType;
5341 }
5342 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5343 *count += sizeof(uint32_t);
5344 }
5345
count_VkPhysicalDeviceInlineUniformBlockFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceInlineUniformBlockFeatures * toCount,size_t * count)5346 void count_VkPhysicalDeviceInlineUniformBlockFeatures(
5347 uint32_t featureBits, VkStructureType rootType,
5348 const VkPhysicalDeviceInlineUniformBlockFeatures* toCount, size_t* count) {
5349 (void)featureBits;
5350 (void)rootType;
5351 (void)toCount;
5352 (void)count;
5353 *count += sizeof(VkStructureType);
5354 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5355 rootType = toCount->sType;
5356 }
5357 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5358 *count += sizeof(VkBool32);
5359 *count += sizeof(VkBool32);
5360 }
5361
count_VkPhysicalDeviceInlineUniformBlockProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceInlineUniformBlockProperties * toCount,size_t * count)5362 void count_VkPhysicalDeviceInlineUniformBlockProperties(
5363 uint32_t featureBits, VkStructureType rootType,
5364 const VkPhysicalDeviceInlineUniformBlockProperties* toCount, size_t* count) {
5365 (void)featureBits;
5366 (void)rootType;
5367 (void)toCount;
5368 (void)count;
5369 *count += sizeof(VkStructureType);
5370 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5371 rootType = toCount->sType;
5372 }
5373 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5374 *count += sizeof(uint32_t);
5375 *count += sizeof(uint32_t);
5376 *count += sizeof(uint32_t);
5377 *count += sizeof(uint32_t);
5378 *count += sizeof(uint32_t);
5379 }
5380
count_VkWriteDescriptorSetInlineUniformBlock(uint32_t featureBits,VkStructureType rootType,const VkWriteDescriptorSetInlineUniformBlock * toCount,size_t * count)5381 void count_VkWriteDescriptorSetInlineUniformBlock(
5382 uint32_t featureBits, VkStructureType rootType,
5383 const VkWriteDescriptorSetInlineUniformBlock* toCount, size_t* count) {
5384 (void)featureBits;
5385 (void)rootType;
5386 (void)toCount;
5387 (void)count;
5388 *count += sizeof(VkStructureType);
5389 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5390 rootType = toCount->sType;
5391 }
5392 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5393 *count += sizeof(uint32_t);
5394 if (toCount) {
5395 *count += toCount->dataSize * sizeof(const uint8_t);
5396 }
5397 }
5398
count_VkDescriptorPoolInlineUniformBlockCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkDescriptorPoolInlineUniformBlockCreateInfo * toCount,size_t * count)5399 void count_VkDescriptorPoolInlineUniformBlockCreateInfo(
5400 uint32_t featureBits, VkStructureType rootType,
5401 const VkDescriptorPoolInlineUniformBlockCreateInfo* toCount, size_t* count) {
5402 (void)featureBits;
5403 (void)rootType;
5404 (void)toCount;
5405 (void)count;
5406 *count += sizeof(VkStructureType);
5407 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5408 rootType = toCount->sType;
5409 }
5410 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5411 *count += sizeof(uint32_t);
5412 }
5413
count_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * toCount,size_t * count)5414 void count_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
5415 uint32_t featureBits, VkStructureType rootType,
5416 const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* toCount, size_t* count) {
5417 (void)featureBits;
5418 (void)rootType;
5419 (void)toCount;
5420 (void)count;
5421 *count += sizeof(VkStructureType);
5422 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5423 rootType = toCount->sType;
5424 }
5425 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5426 *count += sizeof(VkBool32);
5427 }
5428
count_VkRenderingAttachmentInfo(uint32_t featureBits,VkStructureType rootType,const VkRenderingAttachmentInfo * toCount,size_t * count)5429 void count_VkRenderingAttachmentInfo(uint32_t featureBits, VkStructureType rootType,
5430 const VkRenderingAttachmentInfo* toCount, size_t* count) {
5431 (void)featureBits;
5432 (void)rootType;
5433 (void)toCount;
5434 (void)count;
5435 *count += sizeof(VkStructureType);
5436 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5437 rootType = toCount->sType;
5438 }
5439 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5440 uint64_t cgen_var_0;
5441 *count += 1 * 8;
5442 *count += sizeof(VkImageLayout);
5443 *count += sizeof(VkResolveModeFlagBits);
5444 uint64_t cgen_var_1;
5445 *count += 1 * 8;
5446 *count += sizeof(VkImageLayout);
5447 *count += sizeof(VkAttachmentLoadOp);
5448 *count += sizeof(VkAttachmentStoreOp);
5449 count_VkClearValue(featureBits, rootType, (VkClearValue*)(&toCount->clearValue), count);
5450 }
5451
count_VkRenderingInfo(uint32_t featureBits,VkStructureType rootType,const VkRenderingInfo * toCount,size_t * count)5452 void count_VkRenderingInfo(uint32_t featureBits, VkStructureType rootType,
5453 const VkRenderingInfo* toCount, size_t* count) {
5454 (void)featureBits;
5455 (void)rootType;
5456 (void)toCount;
5457 (void)count;
5458 *count += sizeof(VkStructureType);
5459 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5460 rootType = toCount->sType;
5461 }
5462 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5463 *count += sizeof(VkRenderingFlags);
5464 count_VkRect2D(featureBits, rootType, (VkRect2D*)(&toCount->renderArea), count);
5465 *count += sizeof(uint32_t);
5466 *count += sizeof(uint32_t);
5467 *count += sizeof(uint32_t);
5468 if (toCount) {
5469 for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i) {
5470 count_VkRenderingAttachmentInfo(
5471 featureBits, rootType,
5472 (const VkRenderingAttachmentInfo*)(toCount->pColorAttachments + i), count);
5473 }
5474 }
5475 // WARNING PTR CHECK
5476 *count += 8;
5477 if (toCount->pDepthAttachment) {
5478 count_VkRenderingAttachmentInfo(
5479 featureBits, rootType, (const VkRenderingAttachmentInfo*)(toCount->pDepthAttachment),
5480 count);
5481 }
5482 // WARNING PTR CHECK
5483 *count += 8;
5484 if (toCount->pStencilAttachment) {
5485 count_VkRenderingAttachmentInfo(
5486 featureBits, rootType, (const VkRenderingAttachmentInfo*)(toCount->pStencilAttachment),
5487 count);
5488 }
5489 }
5490
count_VkPipelineRenderingCreateInfo(uint32_t featureBits,VkStructureType rootType,const VkPipelineRenderingCreateInfo * toCount,size_t * count)5491 void count_VkPipelineRenderingCreateInfo(uint32_t featureBits, VkStructureType rootType,
5492 const VkPipelineRenderingCreateInfo* toCount,
5493 size_t* count) {
5494 (void)featureBits;
5495 (void)rootType;
5496 (void)toCount;
5497 (void)count;
5498 *count += sizeof(VkStructureType);
5499 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5500 rootType = toCount->sType;
5501 }
5502 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5503 *count += sizeof(uint32_t);
5504 *count += sizeof(uint32_t);
5505 // WARNING PTR CHECK
5506 *count += 8;
5507 if (toCount->pColorAttachmentFormats) {
5508 if (toCount) {
5509 *count += toCount->colorAttachmentCount * sizeof(const VkFormat);
5510 }
5511 }
5512 *count += sizeof(VkFormat);
5513 *count += sizeof(VkFormat);
5514 }
5515
count_VkPhysicalDeviceDynamicRenderingFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceDynamicRenderingFeatures * toCount,size_t * count)5516 void count_VkPhysicalDeviceDynamicRenderingFeatures(
5517 uint32_t featureBits, VkStructureType rootType,
5518 const VkPhysicalDeviceDynamicRenderingFeatures* toCount, size_t* count) {
5519 (void)featureBits;
5520 (void)rootType;
5521 (void)toCount;
5522 (void)count;
5523 *count += sizeof(VkStructureType);
5524 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5525 rootType = toCount->sType;
5526 }
5527 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5528 *count += sizeof(VkBool32);
5529 }
5530
count_VkCommandBufferInheritanceRenderingInfo(uint32_t featureBits,VkStructureType rootType,const VkCommandBufferInheritanceRenderingInfo * toCount,size_t * count)5531 void count_VkCommandBufferInheritanceRenderingInfo(
5532 uint32_t featureBits, VkStructureType rootType,
5533 const VkCommandBufferInheritanceRenderingInfo* toCount, size_t* count) {
5534 (void)featureBits;
5535 (void)rootType;
5536 (void)toCount;
5537 (void)count;
5538 *count += sizeof(VkStructureType);
5539 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5540 rootType = toCount->sType;
5541 }
5542 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5543 *count += sizeof(VkRenderingFlags);
5544 *count += sizeof(uint32_t);
5545 *count += sizeof(uint32_t);
5546 if (toCount) {
5547 *count += toCount->colorAttachmentCount * sizeof(const VkFormat);
5548 }
5549 *count += sizeof(VkFormat);
5550 *count += sizeof(VkFormat);
5551 *count += sizeof(VkSampleCountFlagBits);
5552 }
5553
count_VkPhysicalDeviceShaderIntegerDotProductFeatures(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceShaderIntegerDotProductFeatures * toCount,size_t * count)5554 void count_VkPhysicalDeviceShaderIntegerDotProductFeatures(
5555 uint32_t featureBits, VkStructureType rootType,
5556 const VkPhysicalDeviceShaderIntegerDotProductFeatures* toCount, size_t* count) {
5557 (void)featureBits;
5558 (void)rootType;
5559 (void)toCount;
5560 (void)count;
5561 *count += sizeof(VkStructureType);
5562 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5563 rootType = toCount->sType;
5564 }
5565 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5566 *count += sizeof(VkBool32);
5567 }
5568
count_VkPhysicalDeviceShaderIntegerDotProductProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceShaderIntegerDotProductProperties * toCount,size_t * count)5569 void count_VkPhysicalDeviceShaderIntegerDotProductProperties(
5570 uint32_t featureBits, VkStructureType rootType,
5571 const VkPhysicalDeviceShaderIntegerDotProductProperties* toCount, size_t* count) {
5572 (void)featureBits;
5573 (void)rootType;
5574 (void)toCount;
5575 (void)count;
5576 *count += sizeof(VkStructureType);
5577 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5578 rootType = toCount->sType;
5579 }
5580 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5581 *count += sizeof(VkBool32);
5582 *count += sizeof(VkBool32);
5583 *count += sizeof(VkBool32);
5584 *count += sizeof(VkBool32);
5585 *count += sizeof(VkBool32);
5586 *count += sizeof(VkBool32);
5587 *count += sizeof(VkBool32);
5588 *count += sizeof(VkBool32);
5589 *count += sizeof(VkBool32);
5590 *count += sizeof(VkBool32);
5591 *count += sizeof(VkBool32);
5592 *count += sizeof(VkBool32);
5593 *count += sizeof(VkBool32);
5594 *count += sizeof(VkBool32);
5595 *count += sizeof(VkBool32);
5596 *count += sizeof(VkBool32);
5597 *count += sizeof(VkBool32);
5598 *count += sizeof(VkBool32);
5599 *count += sizeof(VkBool32);
5600 *count += sizeof(VkBool32);
5601 *count += sizeof(VkBool32);
5602 *count += sizeof(VkBool32);
5603 *count += sizeof(VkBool32);
5604 *count += sizeof(VkBool32);
5605 *count += sizeof(VkBool32);
5606 *count += sizeof(VkBool32);
5607 *count += sizeof(VkBool32);
5608 *count += sizeof(VkBool32);
5609 *count += sizeof(VkBool32);
5610 *count += sizeof(VkBool32);
5611 }
5612
count_VkPhysicalDeviceTexelBufferAlignmentProperties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceTexelBufferAlignmentProperties * toCount,size_t * count)5613 void count_VkPhysicalDeviceTexelBufferAlignmentProperties(
5614 uint32_t featureBits, VkStructureType rootType,
5615 const VkPhysicalDeviceTexelBufferAlignmentProperties* toCount, size_t* count) {
5616 (void)featureBits;
5617 (void)rootType;
5618 (void)toCount;
5619 (void)count;
5620 *count += sizeof(VkStructureType);
5621 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5622 rootType = toCount->sType;
5623 }
5624 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5625 *count += sizeof(VkDeviceSize);
5626 *count += sizeof(VkBool32);
5627 *count += sizeof(VkDeviceSize);
5628 *count += sizeof(VkBool32);
5629 }
5630
count_VkFormatProperties3(uint32_t featureBits,VkStructureType rootType,const VkFormatProperties3 * toCount,size_t * count)5631 void count_VkFormatProperties3(uint32_t featureBits, VkStructureType rootType,
5632 const VkFormatProperties3* toCount, size_t* count) {
5633 (void)featureBits;
5634 (void)rootType;
5635 (void)toCount;
5636 (void)count;
5637 *count += sizeof(VkStructureType);
5638 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5639 rootType = toCount->sType;
5640 }
5641 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5642 *count += sizeof(VkFormatFeatureFlags2);
5643 *count += sizeof(VkFormatFeatureFlags2);
5644 *count += sizeof(VkFormatFeatureFlags2);
5645 }
5646
count_VkPhysicalDeviceMaintenance4Features(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceMaintenance4Features * toCount,size_t * count)5647 void count_VkPhysicalDeviceMaintenance4Features(uint32_t featureBits, VkStructureType rootType,
5648 const VkPhysicalDeviceMaintenance4Features* toCount,
5649 size_t* count) {
5650 (void)featureBits;
5651 (void)rootType;
5652 (void)toCount;
5653 (void)count;
5654 *count += sizeof(VkStructureType);
5655 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5656 rootType = toCount->sType;
5657 }
5658 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5659 *count += sizeof(VkBool32);
5660 }
5661
count_VkPhysicalDeviceMaintenance4Properties(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceMaintenance4Properties * toCount,size_t * count)5662 void count_VkPhysicalDeviceMaintenance4Properties(
5663 uint32_t featureBits, VkStructureType rootType,
5664 const VkPhysicalDeviceMaintenance4Properties* toCount, size_t* count) {
5665 (void)featureBits;
5666 (void)rootType;
5667 (void)toCount;
5668 (void)count;
5669 *count += sizeof(VkStructureType);
5670 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5671 rootType = toCount->sType;
5672 }
5673 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5674 *count += sizeof(VkDeviceSize);
5675 }
5676
count_VkDeviceBufferMemoryRequirements(uint32_t featureBits,VkStructureType rootType,const VkDeviceBufferMemoryRequirements * toCount,size_t * count)5677 void count_VkDeviceBufferMemoryRequirements(uint32_t featureBits, VkStructureType rootType,
5678 const VkDeviceBufferMemoryRequirements* toCount,
5679 size_t* count) {
5680 (void)featureBits;
5681 (void)rootType;
5682 (void)toCount;
5683 (void)count;
5684 *count += sizeof(VkStructureType);
5685 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5686 rootType = toCount->sType;
5687 }
5688 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5689 count_VkBufferCreateInfo(featureBits, rootType,
5690 (const VkBufferCreateInfo*)(toCount->pCreateInfo), count);
5691 }
5692
count_VkDeviceImageMemoryRequirements(uint32_t featureBits,VkStructureType rootType,const VkDeviceImageMemoryRequirements * toCount,size_t * count)5693 void count_VkDeviceImageMemoryRequirements(uint32_t featureBits, VkStructureType rootType,
5694 const VkDeviceImageMemoryRequirements* toCount,
5695 size_t* count) {
5696 (void)featureBits;
5697 (void)rootType;
5698 (void)toCount;
5699 (void)count;
5700 *count += sizeof(VkStructureType);
5701 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5702 rootType = toCount->sType;
5703 }
5704 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5705 count_VkImageCreateInfo(featureBits, rootType, (const VkImageCreateInfo*)(toCount->pCreateInfo),
5706 count);
5707 *count += sizeof(VkImageAspectFlagBits);
5708 }
5709
5710 #endif
5711 #ifdef VK_KHR_surface
5712 #endif
5713 #ifdef VK_KHR_swapchain
5714 #endif
5715 #ifdef VK_KHR_xcb_surface
5716 #endif
5717 #ifdef VK_KHR_android_surface
5718 #endif
5719 #ifdef VK_KHR_win32_surface
5720 #endif
5721 #ifdef VK_KHR_dynamic_rendering
count_VkRenderingFragmentShadingRateAttachmentInfoKHR(uint32_t featureBits,VkStructureType rootType,const VkRenderingFragmentShadingRateAttachmentInfoKHR * toCount,size_t * count)5722 void count_VkRenderingFragmentShadingRateAttachmentInfoKHR(
5723 uint32_t featureBits, VkStructureType rootType,
5724 const VkRenderingFragmentShadingRateAttachmentInfoKHR* toCount, size_t* count) {
5725 (void)featureBits;
5726 (void)rootType;
5727 (void)toCount;
5728 (void)count;
5729 *count += sizeof(VkStructureType);
5730 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5731 rootType = toCount->sType;
5732 }
5733 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5734 uint64_t cgen_var_0;
5735 *count += 1 * 8;
5736 *count += sizeof(VkImageLayout);
5737 count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->shadingRateAttachmentTexelSize),
5738 count);
5739 }
5740
count_VkRenderingFragmentDensityMapAttachmentInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkRenderingFragmentDensityMapAttachmentInfoEXT * toCount,size_t * count)5741 void count_VkRenderingFragmentDensityMapAttachmentInfoEXT(
5742 uint32_t featureBits, VkStructureType rootType,
5743 const VkRenderingFragmentDensityMapAttachmentInfoEXT* toCount, size_t* count) {
5744 (void)featureBits;
5745 (void)rootType;
5746 (void)toCount;
5747 (void)count;
5748 *count += sizeof(VkStructureType);
5749 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5750 rootType = toCount->sType;
5751 }
5752 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5753 uint64_t cgen_var_0;
5754 *count += 1 * 8;
5755 *count += sizeof(VkImageLayout);
5756 }
5757
count_VkAttachmentSampleCountInfoAMD(uint32_t featureBits,VkStructureType rootType,const VkAttachmentSampleCountInfoAMD * toCount,size_t * count)5758 void count_VkAttachmentSampleCountInfoAMD(uint32_t featureBits, VkStructureType rootType,
5759 const VkAttachmentSampleCountInfoAMD* toCount,
5760 size_t* count) {
5761 (void)featureBits;
5762 (void)rootType;
5763 (void)toCount;
5764 (void)count;
5765 *count += sizeof(VkStructureType);
5766 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5767 rootType = toCount->sType;
5768 }
5769 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5770 *count += sizeof(uint32_t);
5771 // WARNING PTR CHECK
5772 *count += 8;
5773 if (toCount->pColorAttachmentSamples) {
5774 if (toCount) {
5775 *count += toCount->colorAttachmentCount * sizeof(const VkSampleCountFlagBits);
5776 }
5777 }
5778 *count += sizeof(VkSampleCountFlagBits);
5779 }
5780
count_VkMultiviewPerViewAttributesInfoNVX(uint32_t featureBits,VkStructureType rootType,const VkMultiviewPerViewAttributesInfoNVX * toCount,size_t * count)5781 void count_VkMultiviewPerViewAttributesInfoNVX(uint32_t featureBits, VkStructureType rootType,
5782 const VkMultiviewPerViewAttributesInfoNVX* toCount,
5783 size_t* count) {
5784 (void)featureBits;
5785 (void)rootType;
5786 (void)toCount;
5787 (void)count;
5788 *count += sizeof(VkStructureType);
5789 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5790 rootType = toCount->sType;
5791 }
5792 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5793 *count += sizeof(VkBool32);
5794 *count += sizeof(VkBool32);
5795 }
5796
5797 #endif
5798 #ifdef VK_KHR_get_physical_device_properties2
5799 #endif
5800 #ifdef VK_KHR_maintenance1
5801 #endif
5802 #ifdef VK_KHR_external_memory_capabilities
5803 #endif
5804 #ifdef VK_KHR_external_memory
5805 #endif
5806 #ifdef VK_KHR_external_memory_win32
5807 #endif
5808 #ifdef VK_KHR_external_memory_fd
5809 #endif
5810 #ifdef VK_KHR_external_semaphore_capabilities
5811 #endif
5812 #ifdef VK_KHR_external_semaphore
5813 #endif
5814 #ifdef VK_KHR_external_semaphore_win32
5815 #endif
5816 #ifdef VK_KHR_external_semaphore_fd
count_VkImportSemaphoreFdInfoKHR(uint32_t featureBits,VkStructureType rootType,const VkImportSemaphoreFdInfoKHR * toCount,size_t * count)5817 void count_VkImportSemaphoreFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
5818 const VkImportSemaphoreFdInfoKHR* toCount, size_t* count) {
5819 (void)featureBits;
5820 (void)rootType;
5821 (void)toCount;
5822 (void)count;
5823 *count += sizeof(VkStructureType);
5824 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5825 rootType = toCount->sType;
5826 }
5827 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5828 uint64_t cgen_var_0;
5829 *count += 1 * 8;
5830 *count += sizeof(VkSemaphoreImportFlags);
5831 *count += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
5832 *count += sizeof(int);
5833 }
5834
count_VkSemaphoreGetFdInfoKHR(uint32_t featureBits,VkStructureType rootType,const VkSemaphoreGetFdInfoKHR * toCount,size_t * count)5835 void count_VkSemaphoreGetFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
5836 const VkSemaphoreGetFdInfoKHR* toCount, size_t* count) {
5837 (void)featureBits;
5838 (void)rootType;
5839 (void)toCount;
5840 (void)count;
5841 *count += sizeof(VkStructureType);
5842 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5843 rootType = toCount->sType;
5844 }
5845 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5846 uint64_t cgen_var_0;
5847 *count += 1 * 8;
5848 *count += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
5849 }
5850
5851 #endif
5852 #ifdef VK_KHR_shader_float16_int8
5853 #endif
5854 #ifdef VK_KHR_incremental_present
count_VkRectLayerKHR(uint32_t featureBits,VkStructureType rootType,const VkRectLayerKHR * toCount,size_t * count)5855 void count_VkRectLayerKHR(uint32_t featureBits, VkStructureType rootType,
5856 const VkRectLayerKHR* toCount, size_t* count) {
5857 (void)featureBits;
5858 (void)rootType;
5859 (void)toCount;
5860 (void)count;
5861 count_VkOffset2D(featureBits, rootType, (VkOffset2D*)(&toCount->offset), count);
5862 count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->extent), count);
5863 *count += sizeof(uint32_t);
5864 }
5865
count_VkPresentRegionKHR(uint32_t featureBits,VkStructureType rootType,const VkPresentRegionKHR * toCount,size_t * count)5866 void count_VkPresentRegionKHR(uint32_t featureBits, VkStructureType rootType,
5867 const VkPresentRegionKHR* toCount, size_t* count) {
5868 (void)featureBits;
5869 (void)rootType;
5870 (void)toCount;
5871 (void)count;
5872 *count += sizeof(uint32_t);
5873 // WARNING PTR CHECK
5874 *count += 8;
5875 if (toCount->pRectangles) {
5876 if (toCount) {
5877 for (uint32_t i = 0; i < (uint32_t)toCount->rectangleCount; ++i) {
5878 count_VkRectLayerKHR(featureBits, rootType,
5879 (const VkRectLayerKHR*)(toCount->pRectangles + i), count);
5880 }
5881 }
5882 }
5883 }
5884
count_VkPresentRegionsKHR(uint32_t featureBits,VkStructureType rootType,const VkPresentRegionsKHR * toCount,size_t * count)5885 void count_VkPresentRegionsKHR(uint32_t featureBits, VkStructureType rootType,
5886 const VkPresentRegionsKHR* toCount, size_t* count) {
5887 (void)featureBits;
5888 (void)rootType;
5889 (void)toCount;
5890 (void)count;
5891 *count += sizeof(VkStructureType);
5892 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5893 rootType = toCount->sType;
5894 }
5895 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5896 *count += sizeof(uint32_t);
5897 // WARNING PTR CHECK
5898 *count += 8;
5899 if (toCount->pRegions) {
5900 if (toCount) {
5901 for (uint32_t i = 0; i < (uint32_t)toCount->swapchainCount; ++i) {
5902 count_VkPresentRegionKHR(featureBits, rootType,
5903 (const VkPresentRegionKHR*)(toCount->pRegions + i), count);
5904 }
5905 }
5906 }
5907 }
5908
5909 #endif
5910 #ifdef VK_KHR_descriptor_update_template
5911 #endif
5912 #ifdef VK_KHR_imageless_framebuffer
5913 #endif
5914 #ifdef VK_KHR_create_renderpass2
5915 #endif
5916 #ifdef VK_KHR_external_fence_capabilities
5917 #endif
5918 #ifdef VK_KHR_external_fence
5919 #endif
5920 #ifdef VK_KHR_external_fence_fd
count_VkImportFenceFdInfoKHR(uint32_t featureBits,VkStructureType rootType,const VkImportFenceFdInfoKHR * toCount,size_t * count)5921 void count_VkImportFenceFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
5922 const VkImportFenceFdInfoKHR* toCount, size_t* count) {
5923 (void)featureBits;
5924 (void)rootType;
5925 (void)toCount;
5926 (void)count;
5927 *count += sizeof(VkStructureType);
5928 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5929 rootType = toCount->sType;
5930 }
5931 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5932 uint64_t cgen_var_0;
5933 *count += 1 * 8;
5934 *count += sizeof(VkFenceImportFlags);
5935 *count += sizeof(VkExternalFenceHandleTypeFlagBits);
5936 *count += sizeof(int);
5937 }
5938
count_VkFenceGetFdInfoKHR(uint32_t featureBits,VkStructureType rootType,const VkFenceGetFdInfoKHR * toCount,size_t * count)5939 void count_VkFenceGetFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
5940 const VkFenceGetFdInfoKHR* toCount, size_t* count) {
5941 (void)featureBits;
5942 (void)rootType;
5943 (void)toCount;
5944 (void)count;
5945 *count += sizeof(VkStructureType);
5946 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5947 rootType = toCount->sType;
5948 }
5949 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5950 uint64_t cgen_var_0;
5951 *count += 1 * 8;
5952 *count += sizeof(VkExternalFenceHandleTypeFlagBits);
5953 }
5954
5955 #endif
5956 #ifdef VK_KHR_maintenance2
5957 #endif
5958 #ifdef VK_KHR_dedicated_allocation
5959 #endif
5960 #ifdef VK_KHR_storage_buffer_storage_class
5961 #endif
5962 #ifdef VK_KHR_get_memory_requirements2
5963 #endif
5964 #ifdef VK_KHR_image_format_list
5965 #endif
5966 #ifdef VK_KHR_sampler_ycbcr_conversion
5967 #endif
5968 #ifdef VK_KHR_bind_memory2
5969 #endif
5970 #ifdef VK_KHR_maintenance3
5971 #endif
5972 #ifdef VK_KHR_shader_subgroup_extended_types
5973 #endif
5974 #ifdef VK_KHR_vulkan_memory_model
5975 #endif
5976 #ifdef VK_KHR_shader_terminate_invocation
5977 #endif
5978 #ifdef VK_KHR_buffer_device_address
5979 #endif
5980 #ifdef VK_KHR_pipeline_executable_properties
count_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR * toCount,size_t * count)5981 void count_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
5982 uint32_t featureBits, VkStructureType rootType,
5983 const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toCount, size_t* count) {
5984 (void)featureBits;
5985 (void)rootType;
5986 (void)toCount;
5987 (void)count;
5988 *count += sizeof(VkStructureType);
5989 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
5990 rootType = toCount->sType;
5991 }
5992 count_extension_struct(featureBits, rootType, toCount->pNext, count);
5993 *count += sizeof(VkBool32);
5994 }
5995
count_VkPipelineInfoKHR(uint32_t featureBits,VkStructureType rootType,const VkPipelineInfoKHR * toCount,size_t * count)5996 void count_VkPipelineInfoKHR(uint32_t featureBits, VkStructureType rootType,
5997 const VkPipelineInfoKHR* toCount, size_t* count) {
5998 (void)featureBits;
5999 (void)rootType;
6000 (void)toCount;
6001 (void)count;
6002 *count += sizeof(VkStructureType);
6003 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6004 rootType = toCount->sType;
6005 }
6006 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6007 uint64_t cgen_var_0;
6008 *count += 1 * 8;
6009 }
6010
count_VkPipelineExecutablePropertiesKHR(uint32_t featureBits,VkStructureType rootType,const VkPipelineExecutablePropertiesKHR * toCount,size_t * count)6011 void count_VkPipelineExecutablePropertiesKHR(uint32_t featureBits, VkStructureType rootType,
6012 const VkPipelineExecutablePropertiesKHR* toCount,
6013 size_t* count) {
6014 (void)featureBits;
6015 (void)rootType;
6016 (void)toCount;
6017 (void)count;
6018 *count += sizeof(VkStructureType);
6019 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6020 rootType = toCount->sType;
6021 }
6022 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6023 *count += sizeof(VkShaderStageFlags);
6024 *count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
6025 *count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
6026 *count += sizeof(uint32_t);
6027 }
6028
count_VkPipelineExecutableInfoKHR(uint32_t featureBits,VkStructureType rootType,const VkPipelineExecutableInfoKHR * toCount,size_t * count)6029 void count_VkPipelineExecutableInfoKHR(uint32_t featureBits, VkStructureType rootType,
6030 const VkPipelineExecutableInfoKHR* toCount, size_t* count) {
6031 (void)featureBits;
6032 (void)rootType;
6033 (void)toCount;
6034 (void)count;
6035 *count += sizeof(VkStructureType);
6036 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6037 rootType = toCount->sType;
6038 }
6039 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6040 uint64_t cgen_var_0;
6041 *count += 1 * 8;
6042 *count += sizeof(uint32_t);
6043 }
6044
count_VkPipelineExecutableStatisticValueKHR(uint32_t featureBits,VkStructureType rootType,const VkPipelineExecutableStatisticValueKHR * toCount,size_t * count)6045 void count_VkPipelineExecutableStatisticValueKHR(
6046 uint32_t featureBits, VkStructureType rootType,
6047 const VkPipelineExecutableStatisticValueKHR* toCount, size_t* count) {
6048 (void)featureBits;
6049 (void)rootType;
6050 (void)toCount;
6051 (void)count;
6052 *count += sizeof(VkBool32);
6053 }
6054
count_VkPipelineExecutableStatisticKHR(uint32_t featureBits,VkStructureType rootType,const VkPipelineExecutableStatisticKHR * toCount,size_t * count)6055 void count_VkPipelineExecutableStatisticKHR(uint32_t featureBits, VkStructureType rootType,
6056 const VkPipelineExecutableStatisticKHR* toCount,
6057 size_t* count) {
6058 (void)featureBits;
6059 (void)rootType;
6060 (void)toCount;
6061 (void)count;
6062 *count += sizeof(VkStructureType);
6063 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6064 rootType = toCount->sType;
6065 }
6066 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6067 *count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
6068 *count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
6069 *count += sizeof(VkPipelineExecutableStatisticFormatKHR);
6070 count_VkPipelineExecutableStatisticValueKHR(
6071 featureBits, rootType, (VkPipelineExecutableStatisticValueKHR*)(&toCount->value), count);
6072 }
6073
count_VkPipelineExecutableInternalRepresentationKHR(uint32_t featureBits,VkStructureType rootType,const VkPipelineExecutableInternalRepresentationKHR * toCount,size_t * count)6074 void count_VkPipelineExecutableInternalRepresentationKHR(
6075 uint32_t featureBits, VkStructureType rootType,
6076 const VkPipelineExecutableInternalRepresentationKHR* toCount, size_t* count) {
6077 (void)featureBits;
6078 (void)rootType;
6079 (void)toCount;
6080 (void)count;
6081 *count += sizeof(VkStructureType);
6082 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6083 rootType = toCount->sType;
6084 }
6085 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6086 *count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
6087 *count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
6088 *count += sizeof(VkBool32);
6089 *count += 8;
6090 // WARNING PTR CHECK
6091 *count += 8;
6092 if (toCount->pData) {
6093 if (toCount) {
6094 *count += toCount->dataSize * sizeof(uint8_t);
6095 }
6096 }
6097 }
6098
6099 #endif
6100 #ifdef VK_KHR_shader_integer_dot_product
6101 #endif
6102 #ifdef VK_KHR_shader_non_semantic_info
6103 #endif
6104 #ifdef VK_KHR_synchronization2
count_VkQueueFamilyCheckpointProperties2NV(uint32_t featureBits,VkStructureType rootType,const VkQueueFamilyCheckpointProperties2NV * toCount,size_t * count)6105 void count_VkQueueFamilyCheckpointProperties2NV(uint32_t featureBits, VkStructureType rootType,
6106 const VkQueueFamilyCheckpointProperties2NV* toCount,
6107 size_t* count) {
6108 (void)featureBits;
6109 (void)rootType;
6110 (void)toCount;
6111 (void)count;
6112 *count += sizeof(VkStructureType);
6113 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6114 rootType = toCount->sType;
6115 }
6116 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6117 *count += sizeof(VkPipelineStageFlags2);
6118 }
6119
count_VkCheckpointData2NV(uint32_t featureBits,VkStructureType rootType,const VkCheckpointData2NV * toCount,size_t * count)6120 void count_VkCheckpointData2NV(uint32_t featureBits, VkStructureType rootType,
6121 const VkCheckpointData2NV* toCount, size_t* count) {
6122 (void)featureBits;
6123 (void)rootType;
6124 (void)toCount;
6125 (void)count;
6126 *count += sizeof(VkStructureType);
6127 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6128 rootType = toCount->sType;
6129 }
6130 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6131 *count += sizeof(VkPipelineStageFlags2);
6132 // WARNING PTR CHECK
6133 *count += 8;
6134 if (toCount->pCheckpointMarker) {
6135 *count += sizeof(uint8_t);
6136 }
6137 }
6138
6139 #endif
6140 #ifdef VK_KHR_zero_initialize_workgroup_memory
6141 #endif
6142 #ifdef VK_KHR_copy_commands2
6143 #endif
6144 #ifdef VK_KHR_format_feature_flags2
6145 #endif
6146 #ifdef VK_KHR_maintenance4
6147 #endif
6148 #ifdef VK_KHR_maintenance5
count_VkPhysicalDeviceMaintenance5FeaturesKHR(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceMaintenance5FeaturesKHR * toCount,size_t * count)6149 void count_VkPhysicalDeviceMaintenance5FeaturesKHR(
6150 uint32_t featureBits, VkStructureType rootType,
6151 const VkPhysicalDeviceMaintenance5FeaturesKHR* toCount, size_t* count) {
6152 (void)featureBits;
6153 (void)rootType;
6154 (void)toCount;
6155 (void)count;
6156 *count += sizeof(VkStructureType);
6157 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6158 rootType = toCount->sType;
6159 }
6160 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6161 *count += sizeof(VkBool32);
6162 }
6163
count_VkPhysicalDeviceMaintenance5PropertiesKHR(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceMaintenance5PropertiesKHR * toCount,size_t * count)6164 void count_VkPhysicalDeviceMaintenance5PropertiesKHR(
6165 uint32_t featureBits, VkStructureType rootType,
6166 const VkPhysicalDeviceMaintenance5PropertiesKHR* toCount, size_t* count) {
6167 (void)featureBits;
6168 (void)rootType;
6169 (void)toCount;
6170 (void)count;
6171 *count += sizeof(VkStructureType);
6172 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6173 rootType = toCount->sType;
6174 }
6175 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6176 *count += sizeof(VkBool32);
6177 *count += sizeof(VkBool32);
6178 *count += sizeof(VkBool32);
6179 *count += sizeof(VkBool32);
6180 *count += sizeof(VkBool32);
6181 *count += sizeof(VkBool32);
6182 }
6183
count_VkRenderingAreaInfoKHR(uint32_t featureBits,VkStructureType rootType,const VkRenderingAreaInfoKHR * toCount,size_t * count)6184 void count_VkRenderingAreaInfoKHR(uint32_t featureBits, VkStructureType rootType,
6185 const VkRenderingAreaInfoKHR* toCount, size_t* count) {
6186 (void)featureBits;
6187 (void)rootType;
6188 (void)toCount;
6189 (void)count;
6190 *count += sizeof(VkStructureType);
6191 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6192 rootType = toCount->sType;
6193 }
6194 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6195 *count += sizeof(uint32_t);
6196 *count += sizeof(uint32_t);
6197 // WARNING PTR CHECK
6198 *count += 8;
6199 if (toCount->pColorAttachmentFormats) {
6200 if (toCount) {
6201 *count += toCount->colorAttachmentCount * sizeof(const VkFormat);
6202 }
6203 }
6204 *count += sizeof(VkFormat);
6205 *count += sizeof(VkFormat);
6206 }
6207
count_VkImageSubresource2KHR(uint32_t featureBits,VkStructureType rootType,const VkImageSubresource2KHR * toCount,size_t * count)6208 void count_VkImageSubresource2KHR(uint32_t featureBits, VkStructureType rootType,
6209 const VkImageSubresource2KHR* toCount, size_t* count) {
6210 (void)featureBits;
6211 (void)rootType;
6212 (void)toCount;
6213 (void)count;
6214 *count += sizeof(VkStructureType);
6215 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6216 rootType = toCount->sType;
6217 }
6218 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6219 count_VkImageSubresource(featureBits, rootType,
6220 (VkImageSubresource*)(&toCount->imageSubresource), count);
6221 }
6222
count_VkDeviceImageSubresourceInfoKHR(uint32_t featureBits,VkStructureType rootType,const VkDeviceImageSubresourceInfoKHR * toCount,size_t * count)6223 void count_VkDeviceImageSubresourceInfoKHR(uint32_t featureBits, VkStructureType rootType,
6224 const VkDeviceImageSubresourceInfoKHR* toCount,
6225 size_t* count) {
6226 (void)featureBits;
6227 (void)rootType;
6228 (void)toCount;
6229 (void)count;
6230 *count += sizeof(VkStructureType);
6231 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6232 rootType = toCount->sType;
6233 }
6234 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6235 count_VkImageCreateInfo(featureBits, rootType, (const VkImageCreateInfo*)(toCount->pCreateInfo),
6236 count);
6237 count_VkImageSubresource2KHR(featureBits, rootType,
6238 (const VkImageSubresource2KHR*)(toCount->pSubresource), count);
6239 }
6240
count_VkSubresourceLayout2KHR(uint32_t featureBits,VkStructureType rootType,const VkSubresourceLayout2KHR * toCount,size_t * count)6241 void count_VkSubresourceLayout2KHR(uint32_t featureBits, VkStructureType rootType,
6242 const VkSubresourceLayout2KHR* toCount, size_t* count) {
6243 (void)featureBits;
6244 (void)rootType;
6245 (void)toCount;
6246 (void)count;
6247 *count += sizeof(VkStructureType);
6248 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6249 rootType = toCount->sType;
6250 }
6251 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6252 count_VkSubresourceLayout(featureBits, rootType,
6253 (VkSubresourceLayout*)(&toCount->subresourceLayout), count);
6254 }
6255
count_VkPipelineCreateFlags2CreateInfoKHR(uint32_t featureBits,VkStructureType rootType,const VkPipelineCreateFlags2CreateInfoKHR * toCount,size_t * count)6256 void count_VkPipelineCreateFlags2CreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
6257 const VkPipelineCreateFlags2CreateInfoKHR* toCount,
6258 size_t* count) {
6259 (void)featureBits;
6260 (void)rootType;
6261 (void)toCount;
6262 (void)count;
6263 *count += sizeof(VkStructureType);
6264 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6265 rootType = toCount->sType;
6266 }
6267 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6268 *count += sizeof(VkPipelineCreateFlags2KHR);
6269 }
6270
count_VkBufferUsageFlags2CreateInfoKHR(uint32_t featureBits,VkStructureType rootType,const VkBufferUsageFlags2CreateInfoKHR * toCount,size_t * count)6271 void count_VkBufferUsageFlags2CreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
6272 const VkBufferUsageFlags2CreateInfoKHR* toCount,
6273 size_t* count) {
6274 (void)featureBits;
6275 (void)rootType;
6276 (void)toCount;
6277 (void)count;
6278 *count += sizeof(VkStructureType);
6279 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6280 rootType = toCount->sType;
6281 }
6282 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6283 *count += sizeof(VkBufferUsageFlags2KHR);
6284 }
6285
6286 #endif
6287 #ifdef VK_ANDROID_native_buffer
count_VkNativeBufferUsage2ANDROID(uint32_t featureBits,VkStructureType rootType,const VkNativeBufferUsage2ANDROID * toCount,size_t * count)6288 void count_VkNativeBufferUsage2ANDROID(uint32_t featureBits, VkStructureType rootType,
6289 const VkNativeBufferUsage2ANDROID* toCount, size_t* count) {
6290 (void)featureBits;
6291 (void)rootType;
6292 (void)toCount;
6293 (void)count;
6294 *count += sizeof(uint64_t);
6295 *count += sizeof(uint64_t);
6296 }
6297
count_VkNativeBufferANDROID(uint32_t featureBits,VkStructureType rootType,const VkNativeBufferANDROID * toCount,size_t * count)6298 void count_VkNativeBufferANDROID(uint32_t featureBits, VkStructureType rootType,
6299 const VkNativeBufferANDROID* toCount, size_t* count) {
6300 (void)featureBits;
6301 (void)rootType;
6302 (void)toCount;
6303 (void)count;
6304 *count += sizeof(VkStructureType);
6305 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6306 rootType = toCount->sType;
6307 }
6308 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6309 // WARNING PTR CHECK
6310 *count += 8;
6311 if (toCount->handle) {
6312 *count += sizeof(const uint32_t);
6313 }
6314 *count += sizeof(int);
6315 *count += sizeof(int);
6316 *count += sizeof(int);
6317 count_VkNativeBufferUsage2ANDROID(featureBits, rootType,
6318 (VkNativeBufferUsage2ANDROID*)(&toCount->usage2), count);
6319 }
6320
count_VkSwapchainImageCreateInfoANDROID(uint32_t featureBits,VkStructureType rootType,const VkSwapchainImageCreateInfoANDROID * toCount,size_t * count)6321 void count_VkSwapchainImageCreateInfoANDROID(uint32_t featureBits, VkStructureType rootType,
6322 const VkSwapchainImageCreateInfoANDROID* toCount,
6323 size_t* count) {
6324 (void)featureBits;
6325 (void)rootType;
6326 (void)toCount;
6327 (void)count;
6328 *count += sizeof(VkStructureType);
6329 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6330 rootType = toCount->sType;
6331 }
6332 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6333 *count += sizeof(VkSwapchainImageUsageFlagsANDROID);
6334 }
6335
count_VkPhysicalDevicePresentationPropertiesANDROID(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDevicePresentationPropertiesANDROID * toCount,size_t * count)6336 void count_VkPhysicalDevicePresentationPropertiesANDROID(
6337 uint32_t featureBits, VkStructureType rootType,
6338 const VkPhysicalDevicePresentationPropertiesANDROID* toCount, size_t* count) {
6339 (void)featureBits;
6340 (void)rootType;
6341 (void)toCount;
6342 (void)count;
6343 *count += sizeof(VkStructureType);
6344 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6345 rootType = toCount->sType;
6346 }
6347 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6348 *count += sizeof(VkBool32);
6349 }
6350
6351 #endif
6352 #ifdef VK_EXT_transform_feedback
count_VkPhysicalDeviceTransformFeedbackFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * toCount,size_t * count)6353 void count_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
6354 uint32_t featureBits, VkStructureType rootType,
6355 const VkPhysicalDeviceTransformFeedbackFeaturesEXT* toCount, size_t* count) {
6356 (void)featureBits;
6357 (void)rootType;
6358 (void)toCount;
6359 (void)count;
6360 *count += sizeof(VkStructureType);
6361 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6362 rootType = toCount->sType;
6363 }
6364 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6365 *count += sizeof(VkBool32);
6366 *count += sizeof(VkBool32);
6367 }
6368
count_VkPhysicalDeviceTransformFeedbackPropertiesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceTransformFeedbackPropertiesEXT * toCount,size_t * count)6369 void count_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
6370 uint32_t featureBits, VkStructureType rootType,
6371 const VkPhysicalDeviceTransformFeedbackPropertiesEXT* toCount, size_t* count) {
6372 (void)featureBits;
6373 (void)rootType;
6374 (void)toCount;
6375 (void)count;
6376 *count += sizeof(VkStructureType);
6377 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6378 rootType = toCount->sType;
6379 }
6380 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6381 *count += sizeof(uint32_t);
6382 *count += sizeof(uint32_t);
6383 *count += sizeof(VkDeviceSize);
6384 *count += sizeof(uint32_t);
6385 *count += sizeof(uint32_t);
6386 *count += sizeof(uint32_t);
6387 *count += sizeof(VkBool32);
6388 *count += sizeof(VkBool32);
6389 *count += sizeof(VkBool32);
6390 *count += sizeof(VkBool32);
6391 }
6392
count_VkPipelineRasterizationStateStreamCreateInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkPipelineRasterizationStateStreamCreateInfoEXT * toCount,size_t * count)6393 void count_VkPipelineRasterizationStateStreamCreateInfoEXT(
6394 uint32_t featureBits, VkStructureType rootType,
6395 const VkPipelineRasterizationStateStreamCreateInfoEXT* toCount, size_t* count) {
6396 (void)featureBits;
6397 (void)rootType;
6398 (void)toCount;
6399 (void)count;
6400 *count += sizeof(VkStructureType);
6401 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6402 rootType = toCount->sType;
6403 }
6404 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6405 *count += sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT);
6406 *count += sizeof(uint32_t);
6407 }
6408
6409 #endif
6410 #ifdef VK_AMD_gpu_shader_half_float
6411 #endif
6412 #ifdef VK_EXT_texture_compression_astc_hdr
6413 #endif
6414 #ifdef VK_EXT_depth_clip_enable
count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceDepthClipEnableFeaturesEXT * toCount,size_t * count)6415 void count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
6416 uint32_t featureBits, VkStructureType rootType,
6417 const VkPhysicalDeviceDepthClipEnableFeaturesEXT* toCount, size_t* count) {
6418 (void)featureBits;
6419 (void)rootType;
6420 (void)toCount;
6421 (void)count;
6422 *count += sizeof(VkStructureType);
6423 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6424 rootType = toCount->sType;
6425 }
6426 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6427 *count += sizeof(VkBool32);
6428 }
6429
count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkPipelineRasterizationDepthClipStateCreateInfoEXT * toCount,size_t * count)6430 void count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
6431 uint32_t featureBits, VkStructureType rootType,
6432 const VkPipelineRasterizationDepthClipStateCreateInfoEXT* toCount, size_t* count) {
6433 (void)featureBits;
6434 (void)rootType;
6435 (void)toCount;
6436 (void)count;
6437 *count += sizeof(VkStructureType);
6438 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6439 rootType = toCount->sType;
6440 }
6441 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6442 *count += sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT);
6443 *count += sizeof(VkBool32);
6444 }
6445
6446 #endif
6447 #ifdef VK_EXT_swapchain_colorspace
6448 #endif
6449 #ifdef VK_MVK_moltenvk
6450 #endif
6451 #ifdef VK_EXT_queue_family_foreign
6452 #endif
6453 #ifdef VK_EXT_debug_utils
6454 #endif
6455 #ifdef VK_ANDROID_external_memory_android_hardware_buffer
6456 #endif
6457 #ifdef VK_EXT_inline_uniform_block
6458 #endif
6459 #ifdef VK_EXT_shader_stencil_export
6460 #endif
6461 #ifdef VK_EXT_vertex_attribute_divisor
count_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * toCount,size_t * count)6462 void count_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
6463 uint32_t featureBits, VkStructureType rootType,
6464 const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toCount, size_t* count) {
6465 (void)featureBits;
6466 (void)rootType;
6467 (void)toCount;
6468 (void)count;
6469 *count += sizeof(VkStructureType);
6470 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6471 rootType = toCount->sType;
6472 }
6473 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6474 *count += sizeof(uint32_t);
6475 }
6476
count_VkVertexInputBindingDivisorDescriptionEXT(uint32_t featureBits,VkStructureType rootType,const VkVertexInputBindingDivisorDescriptionEXT * toCount,size_t * count)6477 void count_VkVertexInputBindingDivisorDescriptionEXT(
6478 uint32_t featureBits, VkStructureType rootType,
6479 const VkVertexInputBindingDivisorDescriptionEXT* toCount, size_t* count) {
6480 (void)featureBits;
6481 (void)rootType;
6482 (void)toCount;
6483 (void)count;
6484 *count += sizeof(uint32_t);
6485 *count += sizeof(uint32_t);
6486 }
6487
count_VkPipelineVertexInputDivisorStateCreateInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkPipelineVertexInputDivisorStateCreateInfoEXT * toCount,size_t * count)6488 void count_VkPipelineVertexInputDivisorStateCreateInfoEXT(
6489 uint32_t featureBits, VkStructureType rootType,
6490 const VkPipelineVertexInputDivisorStateCreateInfoEXT* toCount, size_t* count) {
6491 (void)featureBits;
6492 (void)rootType;
6493 (void)toCount;
6494 (void)count;
6495 *count += sizeof(VkStructureType);
6496 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6497 rootType = toCount->sType;
6498 }
6499 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6500 *count += sizeof(uint32_t);
6501 if (toCount) {
6502 for (uint32_t i = 0; i < (uint32_t)toCount->vertexBindingDivisorCount; ++i) {
6503 count_VkVertexInputBindingDivisorDescriptionEXT(
6504 featureBits, rootType,
6505 (const VkVertexInputBindingDivisorDescriptionEXT*)(toCount->pVertexBindingDivisors +
6506 i),
6507 count);
6508 }
6509 }
6510 }
6511
count_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * toCount,size_t * count)6512 void count_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
6513 uint32_t featureBits, VkStructureType rootType,
6514 const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toCount, size_t* count) {
6515 (void)featureBits;
6516 (void)rootType;
6517 (void)toCount;
6518 (void)count;
6519 *count += sizeof(VkStructureType);
6520 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6521 rootType = toCount->sType;
6522 }
6523 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6524 *count += sizeof(VkBool32);
6525 *count += sizeof(VkBool32);
6526 }
6527
6528 #endif
6529 #ifdef VK_EXT_pipeline_creation_feedback
6530 #endif
6531 #ifdef VK_NV_shader_subgroup_partitioned
6532 #endif
6533 #ifdef VK_EXT_metal_surface
6534 #endif
6535 #ifdef VK_EXT_fragment_density_map
count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceFragmentDensityMapFeaturesEXT * toCount,size_t * count)6536 void count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
6537 uint32_t featureBits, VkStructureType rootType,
6538 const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toCount, size_t* count) {
6539 (void)featureBits;
6540 (void)rootType;
6541 (void)toCount;
6542 (void)count;
6543 *count += sizeof(VkStructureType);
6544 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6545 rootType = toCount->sType;
6546 }
6547 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6548 *count += sizeof(VkBool32);
6549 *count += sizeof(VkBool32);
6550 *count += sizeof(VkBool32);
6551 }
6552
count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceFragmentDensityMapPropertiesEXT * toCount,size_t * count)6553 void count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
6554 uint32_t featureBits, VkStructureType rootType,
6555 const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toCount, size_t* count) {
6556 (void)featureBits;
6557 (void)rootType;
6558 (void)toCount;
6559 (void)count;
6560 *count += sizeof(VkStructureType);
6561 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6562 rootType = toCount->sType;
6563 }
6564 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6565 count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->minFragmentDensityTexelSize),
6566 count);
6567 count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxFragmentDensityTexelSize),
6568 count);
6569 *count += sizeof(VkBool32);
6570 }
6571
count_VkRenderPassFragmentDensityMapCreateInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkRenderPassFragmentDensityMapCreateInfoEXT * toCount,size_t * count)6572 void count_VkRenderPassFragmentDensityMapCreateInfoEXT(
6573 uint32_t featureBits, VkStructureType rootType,
6574 const VkRenderPassFragmentDensityMapCreateInfoEXT* toCount, size_t* count) {
6575 (void)featureBits;
6576 (void)rootType;
6577 (void)toCount;
6578 (void)count;
6579 *count += sizeof(VkStructureType);
6580 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6581 rootType = toCount->sType;
6582 }
6583 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6584 count_VkAttachmentReference(featureBits, rootType,
6585 (VkAttachmentReference*)(&toCount->fragmentDensityMapAttachment),
6586 count);
6587 }
6588
6589 #endif
6590 #ifdef VK_EXT_scalar_block_layout
6591 #endif
6592 #ifdef VK_EXT_subgroup_size_control
6593 #endif
6594 #ifdef VK_EXT_tooling_info
6595 #endif
6596 #ifdef VK_EXT_validation_features
6597 #endif
6598 #ifdef VK_EXT_provoking_vertex
count_VkPhysicalDeviceProvokingVertexFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceProvokingVertexFeaturesEXT * toCount,size_t * count)6599 void count_VkPhysicalDeviceProvokingVertexFeaturesEXT(
6600 uint32_t featureBits, VkStructureType rootType,
6601 const VkPhysicalDeviceProvokingVertexFeaturesEXT* toCount, size_t* count) {
6602 (void)featureBits;
6603 (void)rootType;
6604 (void)toCount;
6605 (void)count;
6606 *count += sizeof(VkStructureType);
6607 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6608 rootType = toCount->sType;
6609 }
6610 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6611 *count += sizeof(VkBool32);
6612 *count += sizeof(VkBool32);
6613 }
6614
count_VkPhysicalDeviceProvokingVertexPropertiesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceProvokingVertexPropertiesEXT * toCount,size_t * count)6615 void count_VkPhysicalDeviceProvokingVertexPropertiesEXT(
6616 uint32_t featureBits, VkStructureType rootType,
6617 const VkPhysicalDeviceProvokingVertexPropertiesEXT* toCount, size_t* count) {
6618 (void)featureBits;
6619 (void)rootType;
6620 (void)toCount;
6621 (void)count;
6622 *count += sizeof(VkStructureType);
6623 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6624 rootType = toCount->sType;
6625 }
6626 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6627 *count += sizeof(VkBool32);
6628 *count += sizeof(VkBool32);
6629 }
6630
count_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * toCount,size_t * count)6631 void count_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
6632 uint32_t featureBits, VkStructureType rootType,
6633 const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* toCount, size_t* count) {
6634 (void)featureBits;
6635 (void)rootType;
6636 (void)toCount;
6637 (void)count;
6638 *count += sizeof(VkStructureType);
6639 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6640 rootType = toCount->sType;
6641 }
6642 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6643 *count += sizeof(VkProvokingVertexModeEXT);
6644 }
6645
6646 #endif
6647 #ifdef VK_EXT_line_rasterization
count_VkPhysicalDeviceLineRasterizationFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceLineRasterizationFeaturesEXT * toCount,size_t * count)6648 void count_VkPhysicalDeviceLineRasterizationFeaturesEXT(
6649 uint32_t featureBits, VkStructureType rootType,
6650 const VkPhysicalDeviceLineRasterizationFeaturesEXT* toCount, size_t* count) {
6651 (void)featureBits;
6652 (void)rootType;
6653 (void)toCount;
6654 (void)count;
6655 *count += sizeof(VkStructureType);
6656 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6657 rootType = toCount->sType;
6658 }
6659 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6660 *count += sizeof(VkBool32);
6661 *count += sizeof(VkBool32);
6662 *count += sizeof(VkBool32);
6663 *count += sizeof(VkBool32);
6664 *count += sizeof(VkBool32);
6665 *count += sizeof(VkBool32);
6666 }
6667
count_VkPhysicalDeviceLineRasterizationPropertiesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceLineRasterizationPropertiesEXT * toCount,size_t * count)6668 void count_VkPhysicalDeviceLineRasterizationPropertiesEXT(
6669 uint32_t featureBits, VkStructureType rootType,
6670 const VkPhysicalDeviceLineRasterizationPropertiesEXT* toCount, size_t* count) {
6671 (void)featureBits;
6672 (void)rootType;
6673 (void)toCount;
6674 (void)count;
6675 *count += sizeof(VkStructureType);
6676 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6677 rootType = toCount->sType;
6678 }
6679 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6680 *count += sizeof(uint32_t);
6681 }
6682
count_VkPipelineRasterizationLineStateCreateInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkPipelineRasterizationLineStateCreateInfoEXT * toCount,size_t * count)6683 void count_VkPipelineRasterizationLineStateCreateInfoEXT(
6684 uint32_t featureBits, VkStructureType rootType,
6685 const VkPipelineRasterizationLineStateCreateInfoEXT* toCount, size_t* count) {
6686 (void)featureBits;
6687 (void)rootType;
6688 (void)toCount;
6689 (void)count;
6690 *count += sizeof(VkStructureType);
6691 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6692 rootType = toCount->sType;
6693 }
6694 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6695 *count += sizeof(VkLineRasterizationModeEXT);
6696 *count += sizeof(VkBool32);
6697 *count += sizeof(uint32_t);
6698 *count += sizeof(uint16_t);
6699 }
6700
6701 #endif
6702 #ifdef VK_EXT_index_type_uint8
count_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * toCount,size_t * count)6703 void count_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
6704 uint32_t featureBits, VkStructureType rootType,
6705 const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toCount, size_t* count) {
6706 (void)featureBits;
6707 (void)rootType;
6708 (void)toCount;
6709 (void)count;
6710 *count += sizeof(VkStructureType);
6711 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6712 rootType = toCount->sType;
6713 }
6714 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6715 *count += sizeof(VkBool32);
6716 }
6717
6718 #endif
6719 #ifdef VK_EXT_extended_dynamic_state
count_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * toCount,size_t * count)6720 void count_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
6721 uint32_t featureBits, VkStructureType rootType,
6722 const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toCount, size_t* count) {
6723 (void)featureBits;
6724 (void)rootType;
6725 (void)toCount;
6726 (void)count;
6727 *count += sizeof(VkStructureType);
6728 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6729 rootType = toCount->sType;
6730 }
6731 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6732 *count += sizeof(VkBool32);
6733 }
6734
6735 #endif
6736 #ifdef VK_EXT_host_image_copy
count_VkPhysicalDeviceHostImageCopyFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceHostImageCopyFeaturesEXT * toCount,size_t * count)6737 void count_VkPhysicalDeviceHostImageCopyFeaturesEXT(
6738 uint32_t featureBits, VkStructureType rootType,
6739 const VkPhysicalDeviceHostImageCopyFeaturesEXT* toCount, size_t* count) {
6740 (void)featureBits;
6741 (void)rootType;
6742 (void)toCount;
6743 (void)count;
6744 *count += sizeof(VkStructureType);
6745 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6746 rootType = toCount->sType;
6747 }
6748 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6749 *count += sizeof(VkBool32);
6750 }
6751
count_VkPhysicalDeviceHostImageCopyPropertiesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceHostImageCopyPropertiesEXT * toCount,size_t * count)6752 void count_VkPhysicalDeviceHostImageCopyPropertiesEXT(
6753 uint32_t featureBits, VkStructureType rootType,
6754 const VkPhysicalDeviceHostImageCopyPropertiesEXT* toCount, size_t* count) {
6755 (void)featureBits;
6756 (void)rootType;
6757 (void)toCount;
6758 (void)count;
6759 *count += sizeof(VkStructureType);
6760 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6761 rootType = toCount->sType;
6762 }
6763 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6764 *count += sizeof(uint32_t);
6765 // WARNING PTR CHECK
6766 *count += 8;
6767 if (toCount->pCopySrcLayouts) {
6768 if (toCount) {
6769 *count += toCount->copySrcLayoutCount * sizeof(VkImageLayout);
6770 }
6771 }
6772 *count += sizeof(uint32_t);
6773 // WARNING PTR CHECK
6774 *count += 8;
6775 if (toCount->pCopyDstLayouts) {
6776 if (toCount) {
6777 *count += toCount->copyDstLayoutCount * sizeof(VkImageLayout);
6778 }
6779 }
6780 *count += VK_UUID_SIZE * sizeof(uint8_t);
6781 *count += sizeof(VkBool32);
6782 }
6783
count_VkMemoryToImageCopyEXT(uint32_t featureBits,VkStructureType rootType,const VkMemoryToImageCopyEXT * toCount,size_t * count)6784 void count_VkMemoryToImageCopyEXT(uint32_t featureBits, VkStructureType rootType,
6785 const VkMemoryToImageCopyEXT* toCount, size_t* count) {
6786 (void)featureBits;
6787 (void)rootType;
6788 (void)toCount;
6789 (void)count;
6790 *count += sizeof(VkStructureType);
6791 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6792 rootType = toCount->sType;
6793 }
6794 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6795 *count += sizeof(const uint8_t);
6796 *count += sizeof(uint32_t);
6797 *count += sizeof(uint32_t);
6798 count_VkImageSubresourceLayers(featureBits, rootType,
6799 (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
6800 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->imageOffset), count);
6801 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->imageExtent), count);
6802 }
6803
count_VkImageToMemoryCopyEXT(uint32_t featureBits,VkStructureType rootType,const VkImageToMemoryCopyEXT * toCount,size_t * count)6804 void count_VkImageToMemoryCopyEXT(uint32_t featureBits, VkStructureType rootType,
6805 const VkImageToMemoryCopyEXT* toCount, size_t* count) {
6806 (void)featureBits;
6807 (void)rootType;
6808 (void)toCount;
6809 (void)count;
6810 *count += sizeof(VkStructureType);
6811 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6812 rootType = toCount->sType;
6813 }
6814 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6815 *count += sizeof(uint8_t);
6816 *count += sizeof(uint32_t);
6817 *count += sizeof(uint32_t);
6818 count_VkImageSubresourceLayers(featureBits, rootType,
6819 (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
6820 count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->imageOffset), count);
6821 count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->imageExtent), count);
6822 }
6823
count_VkCopyMemoryToImageInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkCopyMemoryToImageInfoEXT * toCount,size_t * count)6824 void count_VkCopyMemoryToImageInfoEXT(uint32_t featureBits, VkStructureType rootType,
6825 const VkCopyMemoryToImageInfoEXT* toCount, size_t* count) {
6826 (void)featureBits;
6827 (void)rootType;
6828 (void)toCount;
6829 (void)count;
6830 *count += sizeof(VkStructureType);
6831 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6832 rootType = toCount->sType;
6833 }
6834 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6835 *count += sizeof(VkHostImageCopyFlagsEXT);
6836 uint64_t cgen_var_0;
6837 *count += 1 * 8;
6838 *count += sizeof(VkImageLayout);
6839 *count += sizeof(uint32_t);
6840 if (toCount) {
6841 for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
6842 count_VkMemoryToImageCopyEXT(featureBits, rootType,
6843 (const VkMemoryToImageCopyEXT*)(toCount->pRegions + i),
6844 count);
6845 }
6846 }
6847 }
6848
count_VkCopyImageToMemoryInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkCopyImageToMemoryInfoEXT * toCount,size_t * count)6849 void count_VkCopyImageToMemoryInfoEXT(uint32_t featureBits, VkStructureType rootType,
6850 const VkCopyImageToMemoryInfoEXT* toCount, size_t* count) {
6851 (void)featureBits;
6852 (void)rootType;
6853 (void)toCount;
6854 (void)count;
6855 *count += sizeof(VkStructureType);
6856 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6857 rootType = toCount->sType;
6858 }
6859 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6860 *count += sizeof(VkHostImageCopyFlagsEXT);
6861 uint64_t cgen_var_0;
6862 *count += 1 * 8;
6863 *count += sizeof(VkImageLayout);
6864 *count += sizeof(uint32_t);
6865 if (toCount) {
6866 for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
6867 count_VkImageToMemoryCopyEXT(featureBits, rootType,
6868 (const VkImageToMemoryCopyEXT*)(toCount->pRegions + i),
6869 count);
6870 }
6871 }
6872 }
6873
count_VkCopyImageToImageInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkCopyImageToImageInfoEXT * toCount,size_t * count)6874 void count_VkCopyImageToImageInfoEXT(uint32_t featureBits, VkStructureType rootType,
6875 const VkCopyImageToImageInfoEXT* toCount, size_t* count) {
6876 (void)featureBits;
6877 (void)rootType;
6878 (void)toCount;
6879 (void)count;
6880 *count += sizeof(VkStructureType);
6881 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6882 rootType = toCount->sType;
6883 }
6884 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6885 *count += sizeof(VkHostImageCopyFlagsEXT);
6886 uint64_t cgen_var_0;
6887 *count += 1 * 8;
6888 *count += sizeof(VkImageLayout);
6889 uint64_t cgen_var_1;
6890 *count += 1 * 8;
6891 *count += sizeof(VkImageLayout);
6892 *count += sizeof(uint32_t);
6893 if (toCount) {
6894 for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
6895 count_VkImageCopy2(featureBits, rootType, (const VkImageCopy2*)(toCount->pRegions + i),
6896 count);
6897 }
6898 }
6899 }
6900
count_VkHostImageLayoutTransitionInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkHostImageLayoutTransitionInfoEXT * toCount,size_t * count)6901 void count_VkHostImageLayoutTransitionInfoEXT(uint32_t featureBits, VkStructureType rootType,
6902 const VkHostImageLayoutTransitionInfoEXT* toCount,
6903 size_t* count) {
6904 (void)featureBits;
6905 (void)rootType;
6906 (void)toCount;
6907 (void)count;
6908 *count += sizeof(VkStructureType);
6909 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6910 rootType = toCount->sType;
6911 }
6912 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6913 uint64_t cgen_var_0;
6914 *count += 1 * 8;
6915 *count += sizeof(VkImageLayout);
6916 *count += sizeof(VkImageLayout);
6917 count_VkImageSubresourceRange(featureBits, rootType,
6918 (VkImageSubresourceRange*)(&toCount->subresourceRange), count);
6919 }
6920
count_VkSubresourceHostMemcpySizeEXT(uint32_t featureBits,VkStructureType rootType,const VkSubresourceHostMemcpySizeEXT * toCount,size_t * count)6921 void count_VkSubresourceHostMemcpySizeEXT(uint32_t featureBits, VkStructureType rootType,
6922 const VkSubresourceHostMemcpySizeEXT* toCount,
6923 size_t* count) {
6924 (void)featureBits;
6925 (void)rootType;
6926 (void)toCount;
6927 (void)count;
6928 *count += sizeof(VkStructureType);
6929 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6930 rootType = toCount->sType;
6931 }
6932 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6933 *count += sizeof(VkDeviceSize);
6934 }
6935
count_VkHostImageCopyDevicePerformanceQueryEXT(uint32_t featureBits,VkStructureType rootType,const VkHostImageCopyDevicePerformanceQueryEXT * toCount,size_t * count)6936 void count_VkHostImageCopyDevicePerformanceQueryEXT(
6937 uint32_t featureBits, VkStructureType rootType,
6938 const VkHostImageCopyDevicePerformanceQueryEXT* toCount, size_t* count) {
6939 (void)featureBits;
6940 (void)rootType;
6941 (void)toCount;
6942 (void)count;
6943 *count += sizeof(VkStructureType);
6944 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6945 rootType = toCount->sType;
6946 }
6947 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6948 *count += sizeof(VkBool32);
6949 *count += sizeof(VkBool32);
6950 }
6951
6952 #endif
6953 #ifdef VK_EXT_swapchain_maintenance1
6954 #endif
6955 #ifdef VK_EXT_shader_demote_to_helper_invocation
6956 #endif
6957 #ifdef VK_EXT_texel_buffer_alignment
count_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * toCount,size_t * count)6958 void count_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
6959 uint32_t featureBits, VkStructureType rootType,
6960 const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toCount, size_t* count) {
6961 (void)featureBits;
6962 (void)rootType;
6963 (void)toCount;
6964 (void)count;
6965 *count += sizeof(VkStructureType);
6966 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6967 rootType = toCount->sType;
6968 }
6969 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6970 *count += sizeof(VkBool32);
6971 }
6972
6973 #endif
6974 #ifdef VK_EXT_device_memory_report
count_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT * toCount,size_t * count)6975 void count_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
6976 uint32_t featureBits, VkStructureType rootType,
6977 const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toCount, size_t* count) {
6978 (void)featureBits;
6979 (void)rootType;
6980 (void)toCount;
6981 (void)count;
6982 *count += sizeof(VkStructureType);
6983 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6984 rootType = toCount->sType;
6985 }
6986 count_extension_struct(featureBits, rootType, toCount->pNext, count);
6987 *count += sizeof(VkBool32);
6988 }
6989
count_VkDeviceMemoryReportCallbackDataEXT(uint32_t featureBits,VkStructureType rootType,const VkDeviceMemoryReportCallbackDataEXT * toCount,size_t * count)6990 void count_VkDeviceMemoryReportCallbackDataEXT(uint32_t featureBits, VkStructureType rootType,
6991 const VkDeviceMemoryReportCallbackDataEXT* toCount,
6992 size_t* count) {
6993 (void)featureBits;
6994 (void)rootType;
6995 (void)toCount;
6996 (void)count;
6997 *count += sizeof(VkStructureType);
6998 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
6999 rootType = toCount->sType;
7000 }
7001 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7002 *count += sizeof(VkDeviceMemoryReportFlagsEXT);
7003 *count += sizeof(VkDeviceMemoryReportEventTypeEXT);
7004 *count += sizeof(uint64_t);
7005 *count += sizeof(VkDeviceSize);
7006 *count += sizeof(VkObjectType);
7007 *count += sizeof(uint64_t);
7008 *count += sizeof(uint32_t);
7009 }
7010
count_VkDeviceDeviceMemoryReportCreateInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkDeviceDeviceMemoryReportCreateInfoEXT * toCount,size_t * count)7011 void count_VkDeviceDeviceMemoryReportCreateInfoEXT(
7012 uint32_t featureBits, VkStructureType rootType,
7013 const VkDeviceDeviceMemoryReportCreateInfoEXT* toCount, size_t* count) {
7014 (void)featureBits;
7015 (void)rootType;
7016 (void)toCount;
7017 (void)count;
7018 *count += sizeof(VkStructureType);
7019 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7020 rootType = toCount->sType;
7021 }
7022 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7023 *count += sizeof(VkDeviceMemoryReportFlagsEXT);
7024 *count += 8;
7025 *count += sizeof(uint8_t);
7026 }
7027
7028 #endif
7029 #ifdef VK_EXT_robustness2
count_VkPhysicalDeviceRobustness2FeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceRobustness2FeaturesEXT * toCount,size_t * count)7030 void count_VkPhysicalDeviceRobustness2FeaturesEXT(
7031 uint32_t featureBits, VkStructureType rootType,
7032 const VkPhysicalDeviceRobustness2FeaturesEXT* toCount, size_t* count) {
7033 (void)featureBits;
7034 (void)rootType;
7035 (void)toCount;
7036 (void)count;
7037 *count += sizeof(VkStructureType);
7038 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7039 rootType = toCount->sType;
7040 }
7041 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7042 *count += sizeof(VkBool32);
7043 *count += sizeof(VkBool32);
7044 *count += sizeof(VkBool32);
7045 }
7046
count_VkPhysicalDeviceRobustness2PropertiesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceRobustness2PropertiesEXT * toCount,size_t * count)7047 void count_VkPhysicalDeviceRobustness2PropertiesEXT(
7048 uint32_t featureBits, VkStructureType rootType,
7049 const VkPhysicalDeviceRobustness2PropertiesEXT* toCount, size_t* count) {
7050 (void)featureBits;
7051 (void)rootType;
7052 (void)toCount;
7053 (void)count;
7054 *count += sizeof(VkStructureType);
7055 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7056 rootType = toCount->sType;
7057 }
7058 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7059 *count += sizeof(VkDeviceSize);
7060 *count += sizeof(VkDeviceSize);
7061 }
7062
7063 #endif
7064 #ifdef VK_EXT_custom_border_color
count_VkSamplerCustomBorderColorCreateInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkSamplerCustomBorderColorCreateInfoEXT * toCount,size_t * count)7065 void count_VkSamplerCustomBorderColorCreateInfoEXT(
7066 uint32_t featureBits, VkStructureType rootType,
7067 const VkSamplerCustomBorderColorCreateInfoEXT* toCount, size_t* count) {
7068 (void)featureBits;
7069 (void)rootType;
7070 (void)toCount;
7071 (void)count;
7072 *count += sizeof(VkStructureType);
7073 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7074 rootType = toCount->sType;
7075 }
7076 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7077 count_VkClearColorValue(featureBits, rootType,
7078 (VkClearColorValue*)(&toCount->customBorderColor), count);
7079 *count += sizeof(VkFormat);
7080 }
7081
count_VkPhysicalDeviceCustomBorderColorPropertiesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceCustomBorderColorPropertiesEXT * toCount,size_t * count)7082 void count_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
7083 uint32_t featureBits, VkStructureType rootType,
7084 const VkPhysicalDeviceCustomBorderColorPropertiesEXT* toCount, size_t* count) {
7085 (void)featureBits;
7086 (void)rootType;
7087 (void)toCount;
7088 (void)count;
7089 *count += sizeof(VkStructureType);
7090 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7091 rootType = toCount->sType;
7092 }
7093 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7094 *count += sizeof(uint32_t);
7095 }
7096
count_VkPhysicalDeviceCustomBorderColorFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceCustomBorderColorFeaturesEXT * toCount,size_t * count)7097 void count_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
7098 uint32_t featureBits, VkStructureType rootType,
7099 const VkPhysicalDeviceCustomBorderColorFeaturesEXT* toCount, size_t* count) {
7100 (void)featureBits;
7101 (void)rootType;
7102 (void)toCount;
7103 (void)count;
7104 *count += sizeof(VkStructureType);
7105 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7106 rootType = toCount->sType;
7107 }
7108 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7109 *count += sizeof(VkBool32);
7110 *count += sizeof(VkBool32);
7111 }
7112
7113 #endif
7114 #ifdef VK_EXT_private_data
7115 #endif
7116 #ifdef VK_EXT_pipeline_creation_cache_control
7117 #endif
7118 #ifdef VK_EXT_metal_objects
7119 #endif
7120 #ifdef VK_EXT_graphics_pipeline_library
count_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT * toCount,size_t * count)7121 void count_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
7122 uint32_t featureBits, VkStructureType rootType,
7123 const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* toCount, size_t* count) {
7124 (void)featureBits;
7125 (void)rootType;
7126 (void)toCount;
7127 (void)count;
7128 *count += sizeof(VkStructureType);
7129 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7130 rootType = toCount->sType;
7131 }
7132 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7133 *count += sizeof(VkBool32);
7134 }
7135
count_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT * toCount,size_t * count)7136 void count_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
7137 uint32_t featureBits, VkStructureType rootType,
7138 const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* toCount, size_t* count) {
7139 (void)featureBits;
7140 (void)rootType;
7141 (void)toCount;
7142 (void)count;
7143 *count += sizeof(VkStructureType);
7144 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7145 rootType = toCount->sType;
7146 }
7147 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7148 *count += sizeof(VkBool32);
7149 *count += sizeof(VkBool32);
7150 }
7151
count_VkGraphicsPipelineLibraryCreateInfoEXT(uint32_t featureBits,VkStructureType rootType,const VkGraphicsPipelineLibraryCreateInfoEXT * toCount,size_t * count)7152 void count_VkGraphicsPipelineLibraryCreateInfoEXT(
7153 uint32_t featureBits, VkStructureType rootType,
7154 const VkGraphicsPipelineLibraryCreateInfoEXT* toCount, size_t* count) {
7155 (void)featureBits;
7156 (void)rootType;
7157 (void)toCount;
7158 (void)count;
7159 *count += sizeof(VkStructureType);
7160 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7161 rootType = toCount->sType;
7162 }
7163 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7164 *count += sizeof(VkGraphicsPipelineLibraryFlagsEXT);
7165 }
7166
7167 #endif
7168 #ifdef VK_EXT_ycbcr_2plane_444_formats
count_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * toCount,size_t * count)7169 void count_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
7170 uint32_t featureBits, VkStructureType rootType,
7171 const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toCount, size_t* count) {
7172 (void)featureBits;
7173 (void)rootType;
7174 (void)toCount;
7175 (void)count;
7176 *count += sizeof(VkStructureType);
7177 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7178 rootType = toCount->sType;
7179 }
7180 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7181 *count += sizeof(VkBool32);
7182 }
7183
7184 #endif
7185 #ifdef VK_EXT_image_robustness
7186 #endif
7187 #ifdef VK_EXT_image_compression_control
count_VkPhysicalDeviceImageCompressionControlFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceImageCompressionControlFeaturesEXT * toCount,size_t * count)7188 void count_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
7189 uint32_t featureBits, VkStructureType rootType,
7190 const VkPhysicalDeviceImageCompressionControlFeaturesEXT* toCount, size_t* count) {
7191 (void)featureBits;
7192 (void)rootType;
7193 (void)toCount;
7194 (void)count;
7195 *count += sizeof(VkStructureType);
7196 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7197 rootType = toCount->sType;
7198 }
7199 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7200 *count += sizeof(VkBool32);
7201 }
7202
count_VkImageCompressionControlEXT(uint32_t featureBits,VkStructureType rootType,const VkImageCompressionControlEXT * toCount,size_t * count)7203 void count_VkImageCompressionControlEXT(uint32_t featureBits, VkStructureType rootType,
7204 const VkImageCompressionControlEXT* toCount,
7205 size_t* count) {
7206 (void)featureBits;
7207 (void)rootType;
7208 (void)toCount;
7209 (void)count;
7210 *count += sizeof(VkStructureType);
7211 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7212 rootType = toCount->sType;
7213 }
7214 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7215 *count += sizeof(VkImageCompressionFlagsEXT);
7216 *count += sizeof(uint32_t);
7217 // WARNING PTR CHECK
7218 *count += 8;
7219 if (toCount->pFixedRateFlags) {
7220 if (toCount) {
7221 *count +=
7222 toCount->compressionControlPlaneCount * sizeof(VkImageCompressionFixedRateFlagsEXT);
7223 }
7224 }
7225 }
7226
count_VkImageCompressionPropertiesEXT(uint32_t featureBits,VkStructureType rootType,const VkImageCompressionPropertiesEXT * toCount,size_t * count)7227 void count_VkImageCompressionPropertiesEXT(uint32_t featureBits, VkStructureType rootType,
7228 const VkImageCompressionPropertiesEXT* toCount,
7229 size_t* count) {
7230 (void)featureBits;
7231 (void)rootType;
7232 (void)toCount;
7233 (void)count;
7234 *count += sizeof(VkStructureType);
7235 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7236 rootType = toCount->sType;
7237 }
7238 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7239 *count += sizeof(VkImageCompressionFlagsEXT);
7240 *count += sizeof(VkImageCompressionFixedRateFlagsEXT);
7241 }
7242
7243 #endif
7244 #ifdef VK_EXT_4444_formats
count_VkPhysicalDevice4444FormatsFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDevice4444FormatsFeaturesEXT * toCount,size_t * count)7245 void count_VkPhysicalDevice4444FormatsFeaturesEXT(
7246 uint32_t featureBits, VkStructureType rootType,
7247 const VkPhysicalDevice4444FormatsFeaturesEXT* toCount, size_t* count) {
7248 (void)featureBits;
7249 (void)rootType;
7250 (void)toCount;
7251 (void)count;
7252 *count += sizeof(VkStructureType);
7253 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7254 rootType = toCount->sType;
7255 }
7256 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7257 *count += sizeof(VkBool32);
7258 *count += sizeof(VkBool32);
7259 }
7260
7261 #endif
7262 #ifdef VK_EXT_primitive_topology_list_restart
count_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT * toCount,size_t * count)7263 void count_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
7264 uint32_t featureBits, VkStructureType rootType,
7265 const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toCount, size_t* count) {
7266 (void)featureBits;
7267 (void)rootType;
7268 (void)toCount;
7269 (void)count;
7270 *count += sizeof(VkStructureType);
7271 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7272 rootType = toCount->sType;
7273 }
7274 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7275 *count += sizeof(VkBool32);
7276 *count += sizeof(VkBool32);
7277 }
7278
7279 #endif
7280 #ifdef VK_EXT_extended_dynamic_state2
count_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * toCount,size_t * count)7281 void count_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
7282 uint32_t featureBits, VkStructureType rootType,
7283 const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toCount, size_t* count) {
7284 (void)featureBits;
7285 (void)rootType;
7286 (void)toCount;
7287 (void)count;
7288 *count += sizeof(VkStructureType);
7289 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7290 rootType = toCount->sType;
7291 }
7292 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7293 *count += sizeof(VkBool32);
7294 *count += sizeof(VkBool32);
7295 *count += sizeof(VkBool32);
7296 }
7297
7298 #endif
7299 #ifdef VK_GOOGLE_gfxstream
count_VkImportColorBufferGOOGLE(uint32_t featureBits,VkStructureType rootType,const VkImportColorBufferGOOGLE * toCount,size_t * count)7300 void count_VkImportColorBufferGOOGLE(uint32_t featureBits, VkStructureType rootType,
7301 const VkImportColorBufferGOOGLE* toCount, size_t* count) {
7302 (void)featureBits;
7303 (void)rootType;
7304 (void)toCount;
7305 (void)count;
7306 *count += sizeof(VkStructureType);
7307 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7308 rootType = toCount->sType;
7309 }
7310 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7311 *count += sizeof(uint32_t);
7312 }
7313
count_VkImportBufferGOOGLE(uint32_t featureBits,VkStructureType rootType,const VkImportBufferGOOGLE * toCount,size_t * count)7314 void count_VkImportBufferGOOGLE(uint32_t featureBits, VkStructureType rootType,
7315 const VkImportBufferGOOGLE* toCount, size_t* count) {
7316 (void)featureBits;
7317 (void)rootType;
7318 (void)toCount;
7319 (void)count;
7320 *count += sizeof(VkStructureType);
7321 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7322 rootType = toCount->sType;
7323 }
7324 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7325 *count += sizeof(uint32_t);
7326 }
7327
count_VkCreateBlobGOOGLE(uint32_t featureBits,VkStructureType rootType,const VkCreateBlobGOOGLE * toCount,size_t * count)7328 void count_VkCreateBlobGOOGLE(uint32_t featureBits, VkStructureType rootType,
7329 const VkCreateBlobGOOGLE* toCount, size_t* count) {
7330 (void)featureBits;
7331 (void)rootType;
7332 (void)toCount;
7333 (void)count;
7334 *count += sizeof(VkStructureType);
7335 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7336 rootType = toCount->sType;
7337 }
7338 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7339 *count += sizeof(uint32_t);
7340 *count += sizeof(uint32_t);
7341 *count += sizeof(uint64_t);
7342 }
7343
7344 #endif
7345 #ifdef VK_EXT_load_store_op_none
7346 #endif
7347 #ifdef VK_EXT_image_compression_control_swapchain
count_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(uint32_t featureBits,VkStructureType rootType,const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT * toCount,size_t * count)7348 void count_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
7349 uint32_t featureBits, VkStructureType rootType,
7350 const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toCount, size_t* count) {
7351 (void)featureBits;
7352 (void)rootType;
7353 (void)toCount;
7354 (void)count;
7355 *count += sizeof(VkStructureType);
7356 if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
7357 rootType = toCount->sType;
7358 }
7359 count_extension_struct(featureBits, rootType, toCount->pNext, count);
7360 *count += sizeof(VkBool32);
7361 }
7362
7363 #endif
7364 #ifdef VK_QNX_external_memory_screen_buffer
7365 #endif
count_extension_struct(uint32_t featureBits,VkStructureType rootType,const void * structExtension,size_t * count)7366 void count_extension_struct(uint32_t featureBits, VkStructureType rootType,
7367 const void* structExtension, size_t* count) {
7368 VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
7369 size_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(
7370 featureBits, rootType, structExtension);
7371 if (!currExtSize && structExtension) {
7372 // unknown struct extension; skip and call on its pNext field
7373 count_extension_struct(featureBits, rootType, (void*)structAccess->pNext, count);
7374 return;
7375 } else {
7376 // known or null extension struct
7377 *count += sizeof(uint32_t);
7378 if (!currExtSize) {
7379 // exit if this was a null extension struct (size == 0 in this branch)
7380 return;
7381 }
7382 }
7383 *count += sizeof(VkStructureType);
7384 if (!structExtension) {
7385 return;
7386 }
7387 uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
7388 switch (structType) {
7389 #ifdef VK_VERSION_1_0
7390 case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
7391 count_VkShaderModuleCreateInfo(
7392 featureBits, rootType,
7393 reinterpret_cast<const VkShaderModuleCreateInfo*>(structExtension), count);
7394 break;
7395 }
7396 #endif
7397 #ifdef VK_VERSION_1_1
7398 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
7399 count_VkPhysicalDeviceSubgroupProperties(
7400 featureBits, rootType,
7401 reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension),
7402 count);
7403 break;
7404 }
7405 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
7406 count_VkPhysicalDevice16BitStorageFeatures(
7407 featureBits, rootType,
7408 reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension),
7409 count);
7410 break;
7411 }
7412 case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
7413 count_VkMemoryDedicatedRequirements(
7414 featureBits, rootType,
7415 reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), count);
7416 break;
7417 }
7418 case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
7419 count_VkMemoryDedicatedAllocateInfo(
7420 featureBits, rootType,
7421 reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), count);
7422 break;
7423 }
7424 case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
7425 count_VkMemoryAllocateFlagsInfo(
7426 featureBits, rootType,
7427 reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), count);
7428 break;
7429 }
7430 case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
7431 count_VkDeviceGroupRenderPassBeginInfo(
7432 featureBits, rootType,
7433 reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), count);
7434 break;
7435 }
7436 case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
7437 count_VkDeviceGroupCommandBufferBeginInfo(
7438 featureBits, rootType,
7439 reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension),
7440 count);
7441 break;
7442 }
7443 case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
7444 count_VkDeviceGroupSubmitInfo(
7445 featureBits, rootType,
7446 reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), count);
7447 break;
7448 }
7449 case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
7450 count_VkDeviceGroupBindSparseInfo(
7451 featureBits, rootType,
7452 reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), count);
7453 break;
7454 }
7455 case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
7456 count_VkBindBufferMemoryDeviceGroupInfo(
7457 featureBits, rootType,
7458 reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), count);
7459 break;
7460 }
7461 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
7462 count_VkBindImageMemoryDeviceGroupInfo(
7463 featureBits, rootType,
7464 reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), count);
7465 break;
7466 }
7467 case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
7468 count_VkDeviceGroupDeviceCreateInfo(
7469 featureBits, rootType,
7470 reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), count);
7471 break;
7472 }
7473 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
7474 count_VkPhysicalDeviceFeatures2(
7475 featureBits, rootType,
7476 reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), count);
7477 break;
7478 }
7479 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
7480 count_VkPhysicalDevicePointClippingProperties(
7481 featureBits, rootType,
7482 reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension),
7483 count);
7484 break;
7485 }
7486 case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
7487 count_VkRenderPassInputAttachmentAspectCreateInfo(
7488 featureBits, rootType,
7489 reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(
7490 structExtension),
7491 count);
7492 break;
7493 }
7494 case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
7495 count_VkImageViewUsageCreateInfo(
7496 featureBits, rootType,
7497 reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension), count);
7498 break;
7499 }
7500 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
7501 count_VkPipelineTessellationDomainOriginStateCreateInfo(
7502 featureBits, rootType,
7503 reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(
7504 structExtension),
7505 count);
7506 break;
7507 }
7508 case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
7509 count_VkRenderPassMultiviewCreateInfo(
7510 featureBits, rootType,
7511 reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), count);
7512 break;
7513 }
7514 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
7515 count_VkPhysicalDeviceMultiviewFeatures(
7516 featureBits, rootType,
7517 reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), count);
7518 break;
7519 }
7520 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
7521 count_VkPhysicalDeviceMultiviewProperties(
7522 featureBits, rootType,
7523 reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension),
7524 count);
7525 break;
7526 }
7527 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
7528 count_VkPhysicalDeviceVariablePointersFeatures(
7529 featureBits, rootType,
7530 reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension),
7531 count);
7532 break;
7533 }
7534 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
7535 count_VkPhysicalDeviceProtectedMemoryFeatures(
7536 featureBits, rootType,
7537 reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension),
7538 count);
7539 break;
7540 }
7541 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
7542 count_VkPhysicalDeviceProtectedMemoryProperties(
7543 featureBits, rootType,
7544 reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension),
7545 count);
7546 break;
7547 }
7548 case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
7549 count_VkProtectedSubmitInfo(
7550 featureBits, rootType,
7551 reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension), count);
7552 break;
7553 }
7554 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
7555 count_VkSamplerYcbcrConversionInfo(
7556 featureBits, rootType,
7557 reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), count);
7558 break;
7559 }
7560 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
7561 count_VkBindImagePlaneMemoryInfo(
7562 featureBits, rootType,
7563 reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), count);
7564 break;
7565 }
7566 case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
7567 count_VkImagePlaneMemoryRequirementsInfo(
7568 featureBits, rootType,
7569 reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension),
7570 count);
7571 break;
7572 }
7573 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
7574 count_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
7575 featureBits, rootType,
7576 reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
7577 structExtension),
7578 count);
7579 break;
7580 }
7581 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
7582 count_VkSamplerYcbcrConversionImageFormatProperties(
7583 featureBits, rootType,
7584 reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(
7585 structExtension),
7586 count);
7587 break;
7588 }
7589 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
7590 count_VkPhysicalDeviceExternalImageFormatInfo(
7591 featureBits, rootType,
7592 reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension),
7593 count);
7594 break;
7595 }
7596 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
7597 count_VkExternalImageFormatProperties(
7598 featureBits, rootType,
7599 reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), count);
7600 break;
7601 }
7602 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
7603 count_VkPhysicalDeviceIDProperties(
7604 featureBits, rootType,
7605 reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), count);
7606 break;
7607 }
7608 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
7609 count_VkExternalMemoryImageCreateInfo(
7610 featureBits, rootType,
7611 reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), count);
7612 break;
7613 }
7614 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
7615 count_VkExternalMemoryBufferCreateInfo(
7616 featureBits, rootType,
7617 reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), count);
7618 break;
7619 }
7620 case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
7621 count_VkExportMemoryAllocateInfo(
7622 featureBits, rootType,
7623 reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), count);
7624 break;
7625 }
7626 case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
7627 count_VkExportFenceCreateInfo(
7628 featureBits, rootType,
7629 reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), count);
7630 break;
7631 }
7632 case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
7633 count_VkExportSemaphoreCreateInfo(
7634 featureBits, rootType,
7635 reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), count);
7636 break;
7637 }
7638 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
7639 count_VkPhysicalDeviceMaintenance3Properties(
7640 featureBits, rootType,
7641 reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension),
7642 count);
7643 break;
7644 }
7645 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
7646 count_VkPhysicalDeviceShaderDrawParametersFeatures(
7647 featureBits, rootType,
7648 reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(
7649 structExtension),
7650 count);
7651 break;
7652 }
7653 #endif
7654 #ifdef VK_VERSION_1_2
7655 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
7656 count_VkPhysicalDeviceVulkan11Features(
7657 featureBits, rootType,
7658 reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension), count);
7659 break;
7660 }
7661 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
7662 count_VkPhysicalDeviceVulkan11Properties(
7663 featureBits, rootType,
7664 reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension),
7665 count);
7666 break;
7667 }
7668 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
7669 count_VkPhysicalDeviceVulkan12Features(
7670 featureBits, rootType,
7671 reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension), count);
7672 break;
7673 }
7674 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
7675 count_VkPhysicalDeviceVulkan12Properties(
7676 featureBits, rootType,
7677 reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension),
7678 count);
7679 break;
7680 }
7681 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
7682 count_VkImageFormatListCreateInfo(
7683 featureBits, rootType,
7684 reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension), count);
7685 break;
7686 }
7687 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
7688 count_VkPhysicalDevice8BitStorageFeatures(
7689 featureBits, rootType,
7690 reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension),
7691 count);
7692 break;
7693 }
7694 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
7695 count_VkPhysicalDeviceDriverProperties(
7696 featureBits, rootType,
7697 reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension), count);
7698 break;
7699 }
7700 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
7701 count_VkPhysicalDeviceShaderAtomicInt64Features(
7702 featureBits, rootType,
7703 reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension),
7704 count);
7705 break;
7706 }
7707 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
7708 count_VkPhysicalDeviceShaderFloat16Int8Features(
7709 featureBits, rootType,
7710 reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension),
7711 count);
7712 break;
7713 }
7714 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
7715 count_VkPhysicalDeviceFloatControlsProperties(
7716 featureBits, rootType,
7717 reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension),
7718 count);
7719 break;
7720 }
7721 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
7722 count_VkDescriptorSetLayoutBindingFlagsCreateInfo(
7723 featureBits, rootType,
7724 reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(
7725 structExtension),
7726 count);
7727 break;
7728 }
7729 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
7730 count_VkPhysicalDeviceDescriptorIndexingFeatures(
7731 featureBits, rootType,
7732 reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(
7733 structExtension),
7734 count);
7735 break;
7736 }
7737 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
7738 count_VkPhysicalDeviceDescriptorIndexingProperties(
7739 featureBits, rootType,
7740 reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(
7741 structExtension),
7742 count);
7743 break;
7744 }
7745 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
7746 count_VkDescriptorSetVariableDescriptorCountAllocateInfo(
7747 featureBits, rootType,
7748 reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(
7749 structExtension),
7750 count);
7751 break;
7752 }
7753 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
7754 count_VkDescriptorSetVariableDescriptorCountLayoutSupport(
7755 featureBits, rootType,
7756 reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(
7757 structExtension),
7758 count);
7759 break;
7760 }
7761 case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
7762 count_VkSubpassDescriptionDepthStencilResolve(
7763 featureBits, rootType,
7764 reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension),
7765 count);
7766 break;
7767 }
7768 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
7769 count_VkPhysicalDeviceDepthStencilResolveProperties(
7770 featureBits, rootType,
7771 reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(
7772 structExtension),
7773 count);
7774 break;
7775 }
7776 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
7777 count_VkPhysicalDeviceScalarBlockLayoutFeatures(
7778 featureBits, rootType,
7779 reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension),
7780 count);
7781 break;
7782 }
7783 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
7784 count_VkImageStencilUsageCreateInfo(
7785 featureBits, rootType,
7786 reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension), count);
7787 break;
7788 }
7789 case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
7790 count_VkSamplerReductionModeCreateInfo(
7791 featureBits, rootType,
7792 reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension), count);
7793 break;
7794 }
7795 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
7796 count_VkPhysicalDeviceSamplerFilterMinmaxProperties(
7797 featureBits, rootType,
7798 reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(
7799 structExtension),
7800 count);
7801 break;
7802 }
7803 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
7804 count_VkPhysicalDeviceVulkanMemoryModelFeatures(
7805 featureBits, rootType,
7806 reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension),
7807 count);
7808 break;
7809 }
7810 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
7811 count_VkPhysicalDeviceImagelessFramebufferFeatures(
7812 featureBits, rootType,
7813 reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(
7814 structExtension),
7815 count);
7816 break;
7817 }
7818 case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
7819 count_VkFramebufferAttachmentsCreateInfo(
7820 featureBits, rootType,
7821 reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension),
7822 count);
7823 break;
7824 }
7825 case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
7826 count_VkRenderPassAttachmentBeginInfo(
7827 featureBits, rootType,
7828 reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension), count);
7829 break;
7830 }
7831 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
7832 count_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
7833 featureBits, rootType,
7834 reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
7835 structExtension),
7836 count);
7837 break;
7838 }
7839 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
7840 count_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
7841 featureBits, rootType,
7842 reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
7843 structExtension),
7844 count);
7845 break;
7846 }
7847 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
7848 count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
7849 featureBits, rootType,
7850 reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
7851 structExtension),
7852 count);
7853 break;
7854 }
7855 case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
7856 count_VkAttachmentReferenceStencilLayout(
7857 featureBits, rootType,
7858 reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension),
7859 count);
7860 break;
7861 }
7862 case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
7863 count_VkAttachmentDescriptionStencilLayout(
7864 featureBits, rootType,
7865 reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension),
7866 count);
7867 break;
7868 }
7869 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
7870 count_VkPhysicalDeviceHostQueryResetFeatures(
7871 featureBits, rootType,
7872 reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension),
7873 count);
7874 break;
7875 }
7876 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
7877 count_VkPhysicalDeviceTimelineSemaphoreFeatures(
7878 featureBits, rootType,
7879 reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension),
7880 count);
7881 break;
7882 }
7883 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
7884 count_VkPhysicalDeviceTimelineSemaphoreProperties(
7885 featureBits, rootType,
7886 reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(
7887 structExtension),
7888 count);
7889 break;
7890 }
7891 case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
7892 count_VkSemaphoreTypeCreateInfo(
7893 featureBits, rootType,
7894 reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension), count);
7895 break;
7896 }
7897 case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
7898 count_VkTimelineSemaphoreSubmitInfo(
7899 featureBits, rootType,
7900 reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension), count);
7901 break;
7902 }
7903 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
7904 count_VkPhysicalDeviceBufferDeviceAddressFeatures(
7905 featureBits, rootType,
7906 reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(
7907 structExtension),
7908 count);
7909 break;
7910 }
7911 case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
7912 count_VkBufferOpaqueCaptureAddressCreateInfo(
7913 featureBits, rootType,
7914 reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension),
7915 count);
7916 break;
7917 }
7918 case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
7919 count_VkMemoryOpaqueCaptureAddressAllocateInfo(
7920 featureBits, rootType,
7921 reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension),
7922 count);
7923 break;
7924 }
7925 #endif
7926 #ifdef VK_VERSION_1_3
7927 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
7928 count_VkPhysicalDeviceVulkan13Features(
7929 featureBits, rootType,
7930 reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(structExtension), count);
7931 break;
7932 }
7933 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
7934 count_VkPhysicalDeviceVulkan13Properties(
7935 featureBits, rootType,
7936 reinterpret_cast<const VkPhysicalDeviceVulkan13Properties*>(structExtension),
7937 count);
7938 break;
7939 }
7940 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
7941 count_VkPipelineCreationFeedbackCreateInfo(
7942 featureBits, rootType,
7943 reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo*>(structExtension),
7944 count);
7945 break;
7946 }
7947 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
7948 count_VkPhysicalDeviceShaderTerminateInvocationFeatures(
7949 featureBits, rootType,
7950 reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
7951 structExtension),
7952 count);
7953 break;
7954 }
7955 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
7956 count_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
7957 featureBits, rootType,
7958 reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
7959 structExtension),
7960 count);
7961 break;
7962 }
7963 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
7964 count_VkPhysicalDevicePrivateDataFeatures(
7965 featureBits, rootType,
7966 reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(structExtension),
7967 count);
7968 break;
7969 }
7970 case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
7971 count_VkDevicePrivateDataCreateInfo(
7972 featureBits, rootType,
7973 reinterpret_cast<const VkDevicePrivateDataCreateInfo*>(structExtension), count);
7974 break;
7975 }
7976 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
7977 count_VkPhysicalDevicePipelineCreationCacheControlFeatures(
7978 featureBits, rootType,
7979 reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
7980 structExtension),
7981 count);
7982 break;
7983 }
7984 case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
7985 count_VkMemoryBarrier2(featureBits, rootType,
7986 reinterpret_cast<const VkMemoryBarrier2*>(structExtension),
7987 count);
7988 break;
7989 }
7990 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
7991 count_VkPhysicalDeviceSynchronization2Features(
7992 featureBits, rootType,
7993 reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(structExtension),
7994 count);
7995 break;
7996 }
7997 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
7998 count_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
7999 featureBits, rootType,
8000 reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
8001 structExtension),
8002 count);
8003 break;
8004 }
8005 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
8006 count_VkPhysicalDeviceImageRobustnessFeatures(
8007 featureBits, rootType,
8008 reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(structExtension),
8009 count);
8010 break;
8011 }
8012 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
8013 count_VkPhysicalDeviceSubgroupSizeControlFeatures(
8014 featureBits, rootType,
8015 reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(
8016 structExtension),
8017 count);
8018 break;
8019 }
8020 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
8021 count_VkPhysicalDeviceSubgroupSizeControlProperties(
8022 featureBits, rootType,
8023 reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties*>(
8024 structExtension),
8025 count);
8026 break;
8027 }
8028 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
8029 count_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
8030 featureBits, rootType,
8031 reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
8032 structExtension),
8033 count);
8034 break;
8035 }
8036 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
8037 count_VkPhysicalDeviceInlineUniformBlockFeatures(
8038 featureBits, rootType,
8039 reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(
8040 structExtension),
8041 count);
8042 break;
8043 }
8044 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
8045 count_VkPhysicalDeviceInlineUniformBlockProperties(
8046 featureBits, rootType,
8047 reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties*>(
8048 structExtension),
8049 count);
8050 break;
8051 }
8052 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
8053 count_VkWriteDescriptorSetInlineUniformBlock(
8054 featureBits, rootType,
8055 reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock*>(structExtension),
8056 count);
8057 break;
8058 }
8059 case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
8060 count_VkDescriptorPoolInlineUniformBlockCreateInfo(
8061 featureBits, rootType,
8062 reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo*>(
8063 structExtension),
8064 count);
8065 break;
8066 }
8067 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
8068 count_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
8069 featureBits, rootType,
8070 reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
8071 structExtension),
8072 count);
8073 break;
8074 }
8075 case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
8076 count_VkPipelineRenderingCreateInfo(
8077 featureBits, rootType,
8078 reinterpret_cast<const VkPipelineRenderingCreateInfo*>(structExtension), count);
8079 break;
8080 }
8081 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
8082 count_VkPhysicalDeviceDynamicRenderingFeatures(
8083 featureBits, rootType,
8084 reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension),
8085 count);
8086 break;
8087 }
8088 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
8089 count_VkCommandBufferInheritanceRenderingInfo(
8090 featureBits, rootType,
8091 reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo*>(structExtension),
8092 count);
8093 break;
8094 }
8095 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
8096 count_VkPhysicalDeviceShaderIntegerDotProductFeatures(
8097 featureBits, rootType,
8098 reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
8099 structExtension),
8100 count);
8101 break;
8102 }
8103 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
8104 count_VkPhysicalDeviceShaderIntegerDotProductProperties(
8105 featureBits, rootType,
8106 reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties*>(
8107 structExtension),
8108 count);
8109 break;
8110 }
8111 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
8112 count_VkPhysicalDeviceTexelBufferAlignmentProperties(
8113 featureBits, rootType,
8114 reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties*>(
8115 structExtension),
8116 count);
8117 break;
8118 }
8119 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
8120 count_VkFormatProperties3(featureBits, rootType,
8121 reinterpret_cast<const VkFormatProperties3*>(structExtension),
8122 count);
8123 break;
8124 }
8125 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
8126 count_VkPhysicalDeviceMaintenance4Features(
8127 featureBits, rootType,
8128 reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(structExtension),
8129 count);
8130 break;
8131 }
8132 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
8133 count_VkPhysicalDeviceMaintenance4Properties(
8134 featureBits, rootType,
8135 reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties*>(structExtension),
8136 count);
8137 break;
8138 }
8139 #endif
8140 #ifdef VK_KHR_dynamic_rendering
8141 case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
8142 count_VkRenderingFragmentShadingRateAttachmentInfoKHR(
8143 featureBits, rootType,
8144 reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
8145 structExtension),
8146 count);
8147 break;
8148 }
8149 case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
8150 count_VkRenderingFragmentDensityMapAttachmentInfoEXT(
8151 featureBits, rootType,
8152 reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
8153 structExtension),
8154 count);
8155 break;
8156 }
8157 case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
8158 count_VkAttachmentSampleCountInfoAMD(
8159 featureBits, rootType,
8160 reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension), count);
8161 break;
8162 }
8163 case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
8164 count_VkMultiviewPerViewAttributesInfoNVX(
8165 featureBits, rootType,
8166 reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension),
8167 count);
8168 break;
8169 }
8170 #endif
8171 #ifdef VK_KHR_incremental_present
8172 case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
8173 count_VkPresentRegionsKHR(featureBits, rootType,
8174 reinterpret_cast<const VkPresentRegionsKHR*>(structExtension),
8175 count);
8176 break;
8177 }
8178 #endif
8179 #ifdef VK_KHR_pipeline_executable_properties
8180 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
8181 count_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
8182 featureBits, rootType,
8183 reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
8184 structExtension),
8185 count);
8186 break;
8187 }
8188 #endif
8189 #ifdef VK_KHR_synchronization2
8190 case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
8191 count_VkQueueFamilyCheckpointProperties2NV(
8192 featureBits, rootType,
8193 reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension),
8194 count);
8195 break;
8196 }
8197 #endif
8198 #ifdef VK_KHR_maintenance5
8199 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
8200 count_VkPhysicalDeviceMaintenance5FeaturesKHR(
8201 featureBits, rootType,
8202 reinterpret_cast<const VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension),
8203 count);
8204 break;
8205 }
8206 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
8207 count_VkPhysicalDeviceMaintenance5PropertiesKHR(
8208 featureBits, rootType,
8209 reinterpret_cast<const VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension),
8210 count);
8211 break;
8212 }
8213 case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
8214 count_VkPipelineCreateFlags2CreateInfoKHR(
8215 featureBits, rootType,
8216 reinterpret_cast<const VkPipelineCreateFlags2CreateInfoKHR*>(structExtension),
8217 count);
8218 break;
8219 }
8220 case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
8221 count_VkBufferUsageFlags2CreateInfoKHR(
8222 featureBits, rootType,
8223 reinterpret_cast<const VkBufferUsageFlags2CreateInfoKHR*>(structExtension), count);
8224 break;
8225 }
8226 #endif
8227 #ifdef VK_ANDROID_native_buffer
8228 case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
8229 count_VkNativeBufferANDROID(
8230 featureBits, rootType,
8231 reinterpret_cast<const VkNativeBufferANDROID*>(structExtension), count);
8232 break;
8233 }
8234 #endif
8235 #ifdef VK_EXT_transform_feedback
8236 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
8237 count_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
8238 featureBits, rootType,
8239 reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
8240 structExtension),
8241 count);
8242 break;
8243 }
8244 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
8245 count_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
8246 featureBits, rootType,
8247 reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(
8248 structExtension),
8249 count);
8250 break;
8251 }
8252 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
8253 count_VkPipelineRasterizationStateStreamCreateInfoEXT(
8254 featureBits, rootType,
8255 reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(
8256 structExtension),
8257 count);
8258 break;
8259 }
8260 #endif
8261 #ifdef VK_EXT_depth_clip_enable
8262 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
8263 count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
8264 featureBits, rootType,
8265 reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
8266 structExtension),
8267 count);
8268 break;
8269 }
8270 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
8271 count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
8272 featureBits, rootType,
8273 reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
8274 structExtension),
8275 count);
8276 break;
8277 }
8278 #endif
8279 #ifdef VK_EXT_vertex_attribute_divisor
8280 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
8281 count_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
8282 featureBits, rootType,
8283 reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(
8284 structExtension),
8285 count);
8286 break;
8287 }
8288 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
8289 count_VkPipelineVertexInputDivisorStateCreateInfoEXT(
8290 featureBits, rootType,
8291 reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(
8292 structExtension),
8293 count);
8294 break;
8295 }
8296 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
8297 count_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
8298 featureBits, rootType,
8299 reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(
8300 structExtension),
8301 count);
8302 break;
8303 }
8304 #endif
8305 #ifdef VK_EXT_fragment_density_map
8306 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
8307 switch (rootType) {
8308 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
8309 count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
8310 featureBits, rootType,
8311 reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
8312 structExtension),
8313 count);
8314 break;
8315 }
8316 case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: {
8317 count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
8318 featureBits, rootType,
8319 reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
8320 structExtension),
8321 count);
8322 break;
8323 }
8324 case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
8325 count_VkImportColorBufferGOOGLE(
8326 featureBits, rootType,
8327 reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), count);
8328 break;
8329 }
8330 default: {
8331 count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
8332 featureBits, rootType,
8333 reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
8334 structExtension),
8335 count);
8336 break;
8337 }
8338 }
8339 break;
8340 }
8341 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
8342 switch (rootType) {
8343 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: {
8344 count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
8345 featureBits, rootType,
8346 reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
8347 structExtension),
8348 count);
8349 break;
8350 }
8351 case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
8352 count_VkCreateBlobGOOGLE(
8353 featureBits, rootType,
8354 reinterpret_cast<const VkCreateBlobGOOGLE*>(structExtension), count);
8355 break;
8356 }
8357 default: {
8358 count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
8359 featureBits, rootType,
8360 reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
8361 structExtension),
8362 count);
8363 break;
8364 }
8365 }
8366 break;
8367 }
8368 case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
8369 switch (rootType) {
8370 case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: {
8371 count_VkRenderPassFragmentDensityMapCreateInfoEXT(
8372 featureBits, rootType,
8373 reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
8374 structExtension),
8375 count);
8376 break;
8377 }
8378 case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: {
8379 count_VkRenderPassFragmentDensityMapCreateInfoEXT(
8380 featureBits, rootType,
8381 reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
8382 structExtension),
8383 count);
8384 break;
8385 }
8386 case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
8387 count_VkImportBufferGOOGLE(
8388 featureBits, rootType,
8389 reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), count);
8390 break;
8391 }
8392 default: {
8393 count_VkRenderPassFragmentDensityMapCreateInfoEXT(
8394 featureBits, rootType,
8395 reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
8396 structExtension),
8397 count);
8398 break;
8399 }
8400 }
8401 break;
8402 }
8403 #endif
8404 #ifdef VK_EXT_provoking_vertex
8405 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
8406 count_VkPhysicalDeviceProvokingVertexFeaturesEXT(
8407 featureBits, rootType,
8408 reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(
8409 structExtension),
8410 count);
8411 break;
8412 }
8413 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
8414 count_VkPhysicalDeviceProvokingVertexPropertiesEXT(
8415 featureBits, rootType,
8416 reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(
8417 structExtension),
8418 count);
8419 break;
8420 }
8421 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
8422 count_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
8423 featureBits, rootType,
8424 reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(
8425 structExtension),
8426 count);
8427 break;
8428 }
8429 #endif
8430 #ifdef VK_EXT_line_rasterization
8431 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
8432 count_VkPhysicalDeviceLineRasterizationFeaturesEXT(
8433 featureBits, rootType,
8434 reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(
8435 structExtension),
8436 count);
8437 break;
8438 }
8439 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
8440 count_VkPhysicalDeviceLineRasterizationPropertiesEXT(
8441 featureBits, rootType,
8442 reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(
8443 structExtension),
8444 count);
8445 break;
8446 }
8447 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
8448 count_VkPipelineRasterizationLineStateCreateInfoEXT(
8449 featureBits, rootType,
8450 reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(
8451 structExtension),
8452 count);
8453 break;
8454 }
8455 #endif
8456 #ifdef VK_EXT_index_type_uint8
8457 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
8458 count_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
8459 featureBits, rootType,
8460 reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension),
8461 count);
8462 break;
8463 }
8464 #endif
8465 #ifdef VK_EXT_extended_dynamic_state
8466 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
8467 count_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
8468 featureBits, rootType,
8469 reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
8470 structExtension),
8471 count);
8472 break;
8473 }
8474 #endif
8475 #ifdef VK_EXT_host_image_copy
8476 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
8477 count_VkPhysicalDeviceHostImageCopyFeaturesEXT(
8478 featureBits, rootType,
8479 reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension),
8480 count);
8481 break;
8482 }
8483 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
8484 count_VkPhysicalDeviceHostImageCopyPropertiesEXT(
8485 featureBits, rootType,
8486 reinterpret_cast<const VkPhysicalDeviceHostImageCopyPropertiesEXT*>(
8487 structExtension),
8488 count);
8489 break;
8490 }
8491 case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
8492 count_VkSubresourceHostMemcpySizeEXT(
8493 featureBits, rootType,
8494 reinterpret_cast<const VkSubresourceHostMemcpySizeEXT*>(structExtension), count);
8495 break;
8496 }
8497 case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
8498 count_VkHostImageCopyDevicePerformanceQueryEXT(
8499 featureBits, rootType,
8500 reinterpret_cast<const VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension),
8501 count);
8502 break;
8503 }
8504 #endif
8505 #ifdef VK_EXT_texel_buffer_alignment
8506 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
8507 count_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
8508 featureBits, rootType,
8509 reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
8510 structExtension),
8511 count);
8512 break;
8513 }
8514 #endif
8515 #ifdef VK_EXT_device_memory_report
8516 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
8517 count_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
8518 featureBits, rootType,
8519 reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
8520 structExtension),
8521 count);
8522 break;
8523 }
8524 case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
8525 count_VkDeviceDeviceMemoryReportCreateInfoEXT(
8526 featureBits, rootType,
8527 reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension),
8528 count);
8529 break;
8530 }
8531 #endif
8532 #ifdef VK_EXT_robustness2
8533 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
8534 count_VkPhysicalDeviceRobustness2FeaturesEXT(
8535 featureBits, rootType,
8536 reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension),
8537 count);
8538 break;
8539 }
8540 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
8541 count_VkPhysicalDeviceRobustness2PropertiesEXT(
8542 featureBits, rootType,
8543 reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension),
8544 count);
8545 break;
8546 }
8547 #endif
8548 #ifdef VK_EXT_custom_border_color
8549 case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
8550 count_VkSamplerCustomBorderColorCreateInfoEXT(
8551 featureBits, rootType,
8552 reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension),
8553 count);
8554 break;
8555 }
8556 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
8557 count_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
8558 featureBits, rootType,
8559 reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(
8560 structExtension),
8561 count);
8562 break;
8563 }
8564 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
8565 count_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
8566 featureBits, rootType,
8567 reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
8568 structExtension),
8569 count);
8570 break;
8571 }
8572 #endif
8573 #ifdef VK_EXT_graphics_pipeline_library
8574 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
8575 count_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
8576 featureBits, rootType,
8577 reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
8578 structExtension),
8579 count);
8580 break;
8581 }
8582 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
8583 count_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
8584 featureBits, rootType,
8585 reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
8586 structExtension),
8587 count);
8588 break;
8589 }
8590 case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
8591 count_VkGraphicsPipelineLibraryCreateInfoEXT(
8592 featureBits, rootType,
8593 reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension),
8594 count);
8595 break;
8596 }
8597 #endif
8598 #ifdef VK_EXT_ycbcr_2plane_444_formats
8599 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
8600 count_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
8601 featureBits, rootType,
8602 reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
8603 structExtension),
8604 count);
8605 break;
8606 }
8607 #endif
8608 #ifdef VK_EXT_image_compression_control
8609 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
8610 count_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
8611 featureBits, rootType,
8612 reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
8613 structExtension),
8614 count);
8615 break;
8616 }
8617 case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
8618 count_VkImageCompressionControlEXT(
8619 featureBits, rootType,
8620 reinterpret_cast<const VkImageCompressionControlEXT*>(structExtension), count);
8621 break;
8622 }
8623 case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
8624 count_VkImageCompressionPropertiesEXT(
8625 featureBits, rootType,
8626 reinterpret_cast<const VkImageCompressionPropertiesEXT*>(structExtension), count);
8627 break;
8628 }
8629 #endif
8630 #ifdef VK_EXT_4444_formats
8631 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
8632 count_VkPhysicalDevice4444FormatsFeaturesEXT(
8633 featureBits, rootType,
8634 reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension),
8635 count);
8636 break;
8637 }
8638 #endif
8639 #ifdef VK_EXT_primitive_topology_list_restart
8640 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
8641 count_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
8642 featureBits, rootType,
8643 reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
8644 structExtension),
8645 count);
8646 break;
8647 }
8648 #endif
8649 #ifdef VK_EXT_extended_dynamic_state2
8650 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
8651 count_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
8652 featureBits, rootType,
8653 reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
8654 structExtension),
8655 count);
8656 break;
8657 }
8658 #endif
8659 #ifdef VK_GOOGLE_gfxstream
8660 case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
8661 count_VkImportColorBufferGOOGLE(
8662 featureBits, rootType,
8663 reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), count);
8664 break;
8665 }
8666 case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
8667 count_VkImportBufferGOOGLE(
8668 featureBits, rootType,
8669 reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), count);
8670 break;
8671 }
8672 case VK_STRUCTURE_TYPE_CREATE_BLOB_GOOGLE: {
8673 count_VkCreateBlobGOOGLE(featureBits, rootType,
8674 reinterpret_cast<const VkCreateBlobGOOGLE*>(structExtension),
8675 count);
8676 break;
8677 }
8678 #endif
8679 #ifdef VK_EXT_image_compression_control_swapchain
8680 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
8681 count_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
8682 featureBits, rootType,
8683 reinterpret_cast<
8684 const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
8685 structExtension),
8686 count);
8687 break;
8688 }
8689 #endif
8690 default: {
8691 // fatal; the switch is only taken if the extension struct is known
8692 abort();
8693 }
8694 }
8695 }
8696
8697 } // namespace vk
8698 } // namespace gfxstream
8699