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_handlemap_guest
17 // (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
18 // Please do not modify directly;
19 // re-run android/scripts/generate-vulkan-sources.sh,
20 // or directly from Python by defining:
21 // VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
22 // CEREAL_OUTPUT_DIR: Where to put the generated sources.
23 // python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
24 
25 #include "goldfish_vk_handlemap_guest.h"
26 
27 
28 #include "goldfish_vk_extension_structs_guest.h"
29 #include "goldfish_vk_private_defs.h"
30 
31 
32 namespace goldfish_vk {
33 
34 void handlemap_extension_struct(
35     VulkanHandleMapping* handlemap,
36     void* structExtension_out);
37 
38 #ifdef VK_VERSION_1_0
handlemap_VkApplicationInfo(VulkanHandleMapping * handlemap,VkApplicationInfo * toMap)39 void handlemap_VkApplicationInfo(
40     VulkanHandleMapping* handlemap,
41     VkApplicationInfo* toMap)
42 {
43     (void)handlemap;
44     (void)toMap;
45     if (toMap->pNext)
46     {
47         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
48     }
49 }
50 
handlemap_VkInstanceCreateInfo(VulkanHandleMapping * handlemap,VkInstanceCreateInfo * toMap)51 void handlemap_VkInstanceCreateInfo(
52     VulkanHandleMapping* handlemap,
53     VkInstanceCreateInfo* toMap)
54 {
55     (void)handlemap;
56     (void)toMap;
57     if (toMap->pNext)
58     {
59         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
60     }
61     if (toMap->pApplicationInfo)
62     {
63         handlemap_VkApplicationInfo(handlemap, (VkApplicationInfo*)(toMap->pApplicationInfo));
64     }
65 }
66 
handlemap_VkAllocationCallbacks(VulkanHandleMapping * handlemap,VkAllocationCallbacks * toMap)67 void handlemap_VkAllocationCallbacks(
68     VulkanHandleMapping* handlemap,
69     VkAllocationCallbacks* toMap)
70 {
71     (void)handlemap;
72     (void)toMap;
73 }
74 
handlemap_VkPhysicalDeviceFeatures(VulkanHandleMapping * handlemap,VkPhysicalDeviceFeatures * toMap)75 void handlemap_VkPhysicalDeviceFeatures(
76     VulkanHandleMapping* handlemap,
77     VkPhysicalDeviceFeatures* toMap)
78 {
79     (void)handlemap;
80     (void)toMap;
81 }
82 
handlemap_VkFormatProperties(VulkanHandleMapping * handlemap,VkFormatProperties * toMap)83 void handlemap_VkFormatProperties(
84     VulkanHandleMapping* handlemap,
85     VkFormatProperties* toMap)
86 {
87     (void)handlemap;
88     (void)toMap;
89 }
90 
handlemap_VkExtent3D(VulkanHandleMapping * handlemap,VkExtent3D * toMap)91 void handlemap_VkExtent3D(
92     VulkanHandleMapping* handlemap,
93     VkExtent3D* toMap)
94 {
95     (void)handlemap;
96     (void)toMap;
97 }
98 
handlemap_VkImageFormatProperties(VulkanHandleMapping * handlemap,VkImageFormatProperties * toMap)99 void handlemap_VkImageFormatProperties(
100     VulkanHandleMapping* handlemap,
101     VkImageFormatProperties* toMap)
102 {
103     (void)handlemap;
104     (void)toMap;
105     handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->maxExtent));
106 }
107 
handlemap_VkPhysicalDeviceLimits(VulkanHandleMapping * handlemap,VkPhysicalDeviceLimits * toMap)108 void handlemap_VkPhysicalDeviceLimits(
109     VulkanHandleMapping* handlemap,
110     VkPhysicalDeviceLimits* toMap)
111 {
112     (void)handlemap;
113     (void)toMap;
114 }
115 
handlemap_VkPhysicalDeviceSparseProperties(VulkanHandleMapping * handlemap,VkPhysicalDeviceSparseProperties * toMap)116 void handlemap_VkPhysicalDeviceSparseProperties(
117     VulkanHandleMapping* handlemap,
118     VkPhysicalDeviceSparseProperties* toMap)
119 {
120     (void)handlemap;
121     (void)toMap;
122 }
123 
handlemap_VkPhysicalDeviceProperties(VulkanHandleMapping * handlemap,VkPhysicalDeviceProperties * toMap)124 void handlemap_VkPhysicalDeviceProperties(
125     VulkanHandleMapping* handlemap,
126     VkPhysicalDeviceProperties* toMap)
127 {
128     (void)handlemap;
129     (void)toMap;
130     handlemap_VkPhysicalDeviceLimits(handlemap, (VkPhysicalDeviceLimits*)(&toMap->limits));
131     handlemap_VkPhysicalDeviceSparseProperties(handlemap, (VkPhysicalDeviceSparseProperties*)(&toMap->sparseProperties));
132 }
133 
handlemap_VkQueueFamilyProperties(VulkanHandleMapping * handlemap,VkQueueFamilyProperties * toMap)134 void handlemap_VkQueueFamilyProperties(
135     VulkanHandleMapping* handlemap,
136     VkQueueFamilyProperties* toMap)
137 {
138     (void)handlemap;
139     (void)toMap;
140     handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->minImageTransferGranularity));
141 }
142 
handlemap_VkMemoryType(VulkanHandleMapping * handlemap,VkMemoryType * toMap)143 void handlemap_VkMemoryType(
144     VulkanHandleMapping* handlemap,
145     VkMemoryType* toMap)
146 {
147     (void)handlemap;
148     (void)toMap;
149 }
150 
handlemap_VkMemoryHeap(VulkanHandleMapping * handlemap,VkMemoryHeap * toMap)151 void handlemap_VkMemoryHeap(
152     VulkanHandleMapping* handlemap,
153     VkMemoryHeap* toMap)
154 {
155     (void)handlemap;
156     (void)toMap;
157 }
158 
handlemap_VkPhysicalDeviceMemoryProperties(VulkanHandleMapping * handlemap,VkPhysicalDeviceMemoryProperties * toMap)159 void handlemap_VkPhysicalDeviceMemoryProperties(
160     VulkanHandleMapping* handlemap,
161     VkPhysicalDeviceMemoryProperties* toMap)
162 {
163     (void)handlemap;
164     (void)toMap;
165     for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
166     {
167         handlemap_VkMemoryType(handlemap, (VkMemoryType*)(toMap->memoryTypes + i));
168     }
169     for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
170     {
171         handlemap_VkMemoryHeap(handlemap, (VkMemoryHeap*)(toMap->memoryHeaps + i));
172     }
173 }
174 
handlemap_VkDeviceQueueCreateInfo(VulkanHandleMapping * handlemap,VkDeviceQueueCreateInfo * toMap)175 void handlemap_VkDeviceQueueCreateInfo(
176     VulkanHandleMapping* handlemap,
177     VkDeviceQueueCreateInfo* toMap)
178 {
179     (void)handlemap;
180     (void)toMap;
181     if (toMap->pNext)
182     {
183         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
184     }
185 }
186 
handlemap_VkDeviceCreateInfo(VulkanHandleMapping * handlemap,VkDeviceCreateInfo * toMap)187 void handlemap_VkDeviceCreateInfo(
188     VulkanHandleMapping* handlemap,
189     VkDeviceCreateInfo* toMap)
190 {
191     (void)handlemap;
192     (void)toMap;
193     if (toMap->pNext)
194     {
195         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
196     }
197     if (toMap->pQueueCreateInfos)
198     {
199         for (uint32_t i = 0; i < (uint32_t)toMap->queueCreateInfoCount; ++i)
200         {
201             handlemap_VkDeviceQueueCreateInfo(handlemap, (VkDeviceQueueCreateInfo*)(toMap->pQueueCreateInfos + i));
202         }
203     }
204     if (toMap->pEnabledFeatures)
205     {
206         handlemap_VkPhysicalDeviceFeatures(handlemap, (VkPhysicalDeviceFeatures*)(toMap->pEnabledFeatures));
207     }
208 }
209 
handlemap_VkExtensionProperties(VulkanHandleMapping * handlemap,VkExtensionProperties * toMap)210 void handlemap_VkExtensionProperties(
211     VulkanHandleMapping* handlemap,
212     VkExtensionProperties* toMap)
213 {
214     (void)handlemap;
215     (void)toMap;
216 }
217 
handlemap_VkLayerProperties(VulkanHandleMapping * handlemap,VkLayerProperties * toMap)218 void handlemap_VkLayerProperties(
219     VulkanHandleMapping* handlemap,
220     VkLayerProperties* toMap)
221 {
222     (void)handlemap;
223     (void)toMap;
224 }
225 
handlemap_VkSubmitInfo(VulkanHandleMapping * handlemap,VkSubmitInfo * toMap)226 void handlemap_VkSubmitInfo(
227     VulkanHandleMapping* handlemap,
228     VkSubmitInfo* toMap)
229 {
230     (void)handlemap;
231     (void)toMap;
232     if (toMap->pNext)
233     {
234         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
235     }
236     if (toMap->pWaitSemaphores)
237     {
238         handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
239     }
240     if (toMap->pCommandBuffers)
241     {
242         handlemap->mapHandles_VkCommandBuffer((VkCommandBuffer*)toMap->pCommandBuffers, toMap->commandBufferCount);
243     }
244     if (toMap->pSignalSemaphores)
245     {
246         handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSignalSemaphores, toMap->signalSemaphoreCount);
247     }
248 }
249 
handlemap_VkMemoryAllocateInfo(VulkanHandleMapping * handlemap,VkMemoryAllocateInfo * toMap)250 void handlemap_VkMemoryAllocateInfo(
251     VulkanHandleMapping* handlemap,
252     VkMemoryAllocateInfo* toMap)
253 {
254     (void)handlemap;
255     (void)toMap;
256     if (toMap->pNext)
257     {
258         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
259     }
260 }
261 
handlemap_VkMappedMemoryRange(VulkanHandleMapping * handlemap,VkMappedMemoryRange * toMap)262 void handlemap_VkMappedMemoryRange(
263     VulkanHandleMapping* handlemap,
264     VkMappedMemoryRange* toMap)
265 {
266     (void)handlemap;
267     (void)toMap;
268     if (toMap->pNext)
269     {
270         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
271     }
272     handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
273 }
274 
handlemap_VkMemoryRequirements(VulkanHandleMapping * handlemap,VkMemoryRequirements * toMap)275 void handlemap_VkMemoryRequirements(
276     VulkanHandleMapping* handlemap,
277     VkMemoryRequirements* toMap)
278 {
279     (void)handlemap;
280     (void)toMap;
281 }
282 
handlemap_VkSparseImageFormatProperties(VulkanHandleMapping * handlemap,VkSparseImageFormatProperties * toMap)283 void handlemap_VkSparseImageFormatProperties(
284     VulkanHandleMapping* handlemap,
285     VkSparseImageFormatProperties* toMap)
286 {
287     (void)handlemap;
288     (void)toMap;
289     handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageGranularity));
290 }
291 
handlemap_VkSparseImageMemoryRequirements(VulkanHandleMapping * handlemap,VkSparseImageMemoryRequirements * toMap)292 void handlemap_VkSparseImageMemoryRequirements(
293     VulkanHandleMapping* handlemap,
294     VkSparseImageMemoryRequirements* toMap)
295 {
296     (void)handlemap;
297     (void)toMap;
298     handlemap_VkSparseImageFormatProperties(handlemap, (VkSparseImageFormatProperties*)(&toMap->formatProperties));
299 }
300 
handlemap_VkSparseMemoryBind(VulkanHandleMapping * handlemap,VkSparseMemoryBind * toMap)301 void handlemap_VkSparseMemoryBind(
302     VulkanHandleMapping* handlemap,
303     VkSparseMemoryBind* toMap)
304 {
305     (void)handlemap;
306     (void)toMap;
307     handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
308 }
309 
handlemap_VkSparseBufferMemoryBindInfo(VulkanHandleMapping * handlemap,VkSparseBufferMemoryBindInfo * toMap)310 void handlemap_VkSparseBufferMemoryBindInfo(
311     VulkanHandleMapping* handlemap,
312     VkSparseBufferMemoryBindInfo* toMap)
313 {
314     (void)handlemap;
315     (void)toMap;
316     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
317     if (toMap->pBinds)
318     {
319         for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
320         {
321             handlemap_VkSparseMemoryBind(handlemap, (VkSparseMemoryBind*)(toMap->pBinds + i));
322         }
323     }
324 }
325 
handlemap_VkSparseImageOpaqueMemoryBindInfo(VulkanHandleMapping * handlemap,VkSparseImageOpaqueMemoryBindInfo * toMap)326 void handlemap_VkSparseImageOpaqueMemoryBindInfo(
327     VulkanHandleMapping* handlemap,
328     VkSparseImageOpaqueMemoryBindInfo* toMap)
329 {
330     (void)handlemap;
331     (void)toMap;
332     handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
333     if (toMap->pBinds)
334     {
335         for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
336         {
337             handlemap_VkSparseMemoryBind(handlemap, (VkSparseMemoryBind*)(toMap->pBinds + i));
338         }
339     }
340 }
341 
handlemap_VkImageSubresource(VulkanHandleMapping * handlemap,VkImageSubresource * toMap)342 void handlemap_VkImageSubresource(
343     VulkanHandleMapping* handlemap,
344     VkImageSubresource* toMap)
345 {
346     (void)handlemap;
347     (void)toMap;
348 }
349 
handlemap_VkOffset3D(VulkanHandleMapping * handlemap,VkOffset3D * toMap)350 void handlemap_VkOffset3D(
351     VulkanHandleMapping* handlemap,
352     VkOffset3D* toMap)
353 {
354     (void)handlemap;
355     (void)toMap;
356 }
357 
handlemap_VkSparseImageMemoryBind(VulkanHandleMapping * handlemap,VkSparseImageMemoryBind * toMap)358 void handlemap_VkSparseImageMemoryBind(
359     VulkanHandleMapping* handlemap,
360     VkSparseImageMemoryBind* toMap)
361 {
362     (void)handlemap;
363     (void)toMap;
364     handlemap_VkImageSubresource(handlemap, (VkImageSubresource*)(&toMap->subresource));
365     handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->offset));
366     handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
367     handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
368 }
369 
handlemap_VkSparseImageMemoryBindInfo(VulkanHandleMapping * handlemap,VkSparseImageMemoryBindInfo * toMap)370 void handlemap_VkSparseImageMemoryBindInfo(
371     VulkanHandleMapping* handlemap,
372     VkSparseImageMemoryBindInfo* toMap)
373 {
374     (void)handlemap;
375     (void)toMap;
376     handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
377     if (toMap->pBinds)
378     {
379         for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
380         {
381             handlemap_VkSparseImageMemoryBind(handlemap, (VkSparseImageMemoryBind*)(toMap->pBinds + i));
382         }
383     }
384 }
385 
handlemap_VkBindSparseInfo(VulkanHandleMapping * handlemap,VkBindSparseInfo * toMap)386 void handlemap_VkBindSparseInfo(
387     VulkanHandleMapping* handlemap,
388     VkBindSparseInfo* toMap)
389 {
390     (void)handlemap;
391     (void)toMap;
392     if (toMap->pNext)
393     {
394         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
395     }
396     if (toMap->pWaitSemaphores)
397     {
398         handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
399     }
400     if (toMap->pBufferBinds)
401     {
402         for (uint32_t i = 0; i < (uint32_t)toMap->bufferBindCount; ++i)
403         {
404             handlemap_VkSparseBufferMemoryBindInfo(handlemap, (VkSparseBufferMemoryBindInfo*)(toMap->pBufferBinds + i));
405         }
406     }
407     if (toMap->pImageOpaqueBinds)
408     {
409         for (uint32_t i = 0; i < (uint32_t)toMap->imageOpaqueBindCount; ++i)
410         {
411             handlemap_VkSparseImageOpaqueMemoryBindInfo(handlemap, (VkSparseImageOpaqueMemoryBindInfo*)(toMap->pImageOpaqueBinds + i));
412         }
413     }
414     if (toMap->pImageBinds)
415     {
416         for (uint32_t i = 0; i < (uint32_t)toMap->imageBindCount; ++i)
417         {
418             handlemap_VkSparseImageMemoryBindInfo(handlemap, (VkSparseImageMemoryBindInfo*)(toMap->pImageBinds + i));
419         }
420     }
421     if (toMap->pSignalSemaphores)
422     {
423         handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSignalSemaphores, toMap->signalSemaphoreCount);
424     }
425 }
426 
handlemap_VkFenceCreateInfo(VulkanHandleMapping * handlemap,VkFenceCreateInfo * toMap)427 void handlemap_VkFenceCreateInfo(
428     VulkanHandleMapping* handlemap,
429     VkFenceCreateInfo* toMap)
430 {
431     (void)handlemap;
432     (void)toMap;
433     if (toMap->pNext)
434     {
435         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
436     }
437 }
438 
handlemap_VkSemaphoreCreateInfo(VulkanHandleMapping * handlemap,VkSemaphoreCreateInfo * toMap)439 void handlemap_VkSemaphoreCreateInfo(
440     VulkanHandleMapping* handlemap,
441     VkSemaphoreCreateInfo* toMap)
442 {
443     (void)handlemap;
444     (void)toMap;
445     if (toMap->pNext)
446     {
447         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
448     }
449 }
450 
handlemap_VkEventCreateInfo(VulkanHandleMapping * handlemap,VkEventCreateInfo * toMap)451 void handlemap_VkEventCreateInfo(
452     VulkanHandleMapping* handlemap,
453     VkEventCreateInfo* toMap)
454 {
455     (void)handlemap;
456     (void)toMap;
457     if (toMap->pNext)
458     {
459         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
460     }
461 }
462 
handlemap_VkQueryPoolCreateInfo(VulkanHandleMapping * handlemap,VkQueryPoolCreateInfo * toMap)463 void handlemap_VkQueryPoolCreateInfo(
464     VulkanHandleMapping* handlemap,
465     VkQueryPoolCreateInfo* toMap)
466 {
467     (void)handlemap;
468     (void)toMap;
469     if (toMap->pNext)
470     {
471         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
472     }
473 }
474 
handlemap_VkBufferCreateInfo(VulkanHandleMapping * handlemap,VkBufferCreateInfo * toMap)475 void handlemap_VkBufferCreateInfo(
476     VulkanHandleMapping* handlemap,
477     VkBufferCreateInfo* toMap)
478 {
479     (void)handlemap;
480     (void)toMap;
481     if (toMap->pNext)
482     {
483         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
484     }
485 }
486 
handlemap_VkBufferViewCreateInfo(VulkanHandleMapping * handlemap,VkBufferViewCreateInfo * toMap)487 void handlemap_VkBufferViewCreateInfo(
488     VulkanHandleMapping* handlemap,
489     VkBufferViewCreateInfo* toMap)
490 {
491     (void)handlemap;
492     (void)toMap;
493     if (toMap->pNext)
494     {
495         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
496     }
497     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
498 }
499 
handlemap_VkImageCreateInfo(VulkanHandleMapping * handlemap,VkImageCreateInfo * toMap)500 void handlemap_VkImageCreateInfo(
501     VulkanHandleMapping* handlemap,
502     VkImageCreateInfo* toMap)
503 {
504     (void)handlemap;
505     (void)toMap;
506     if (toMap->pNext)
507     {
508         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
509     }
510     handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
511 }
512 
handlemap_VkSubresourceLayout(VulkanHandleMapping * handlemap,VkSubresourceLayout * toMap)513 void handlemap_VkSubresourceLayout(
514     VulkanHandleMapping* handlemap,
515     VkSubresourceLayout* toMap)
516 {
517     (void)handlemap;
518     (void)toMap;
519 }
520 
handlemap_VkComponentMapping(VulkanHandleMapping * handlemap,VkComponentMapping * toMap)521 void handlemap_VkComponentMapping(
522     VulkanHandleMapping* handlemap,
523     VkComponentMapping* toMap)
524 {
525     (void)handlemap;
526     (void)toMap;
527 }
528 
handlemap_VkImageSubresourceRange(VulkanHandleMapping * handlemap,VkImageSubresourceRange * toMap)529 void handlemap_VkImageSubresourceRange(
530     VulkanHandleMapping* handlemap,
531     VkImageSubresourceRange* toMap)
532 {
533     (void)handlemap;
534     (void)toMap;
535 }
536 
handlemap_VkImageViewCreateInfo(VulkanHandleMapping * handlemap,VkImageViewCreateInfo * toMap)537 void handlemap_VkImageViewCreateInfo(
538     VulkanHandleMapping* handlemap,
539     VkImageViewCreateInfo* toMap)
540 {
541     (void)handlemap;
542     (void)toMap;
543     if (toMap->pNext)
544     {
545         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
546     }
547     handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
548     handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->components));
549     handlemap_VkImageSubresourceRange(handlemap, (VkImageSubresourceRange*)(&toMap->subresourceRange));
550 }
551 
handlemap_VkShaderModuleCreateInfo(VulkanHandleMapping * handlemap,VkShaderModuleCreateInfo * toMap)552 void handlemap_VkShaderModuleCreateInfo(
553     VulkanHandleMapping* handlemap,
554     VkShaderModuleCreateInfo* toMap)
555 {
556     (void)handlemap;
557     (void)toMap;
558     if (toMap->pNext)
559     {
560         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
561     }
562 }
563 
handlemap_VkPipelineCacheCreateInfo(VulkanHandleMapping * handlemap,VkPipelineCacheCreateInfo * toMap)564 void handlemap_VkPipelineCacheCreateInfo(
565     VulkanHandleMapping* handlemap,
566     VkPipelineCacheCreateInfo* toMap)
567 {
568     (void)handlemap;
569     (void)toMap;
570     if (toMap->pNext)
571     {
572         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
573     }
574 }
575 
handlemap_VkSpecializationMapEntry(VulkanHandleMapping * handlemap,VkSpecializationMapEntry * toMap)576 void handlemap_VkSpecializationMapEntry(
577     VulkanHandleMapping* handlemap,
578     VkSpecializationMapEntry* toMap)
579 {
580     (void)handlemap;
581     (void)toMap;
582 }
583 
handlemap_VkSpecializationInfo(VulkanHandleMapping * handlemap,VkSpecializationInfo * toMap)584 void handlemap_VkSpecializationInfo(
585     VulkanHandleMapping* handlemap,
586     VkSpecializationInfo* toMap)
587 {
588     (void)handlemap;
589     (void)toMap;
590     if (toMap->pMapEntries)
591     {
592         for (uint32_t i = 0; i < (uint32_t)toMap->mapEntryCount; ++i)
593         {
594             handlemap_VkSpecializationMapEntry(handlemap, (VkSpecializationMapEntry*)(toMap->pMapEntries + i));
595         }
596     }
597 }
598 
handlemap_VkPipelineShaderStageCreateInfo(VulkanHandleMapping * handlemap,VkPipelineShaderStageCreateInfo * toMap)599 void handlemap_VkPipelineShaderStageCreateInfo(
600     VulkanHandleMapping* handlemap,
601     VkPipelineShaderStageCreateInfo* toMap)
602 {
603     (void)handlemap;
604     (void)toMap;
605     if (toMap->pNext)
606     {
607         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
608     }
609     handlemap->mapHandles_VkShaderModule((VkShaderModule*)&toMap->module);
610     if (toMap->pSpecializationInfo)
611     {
612         handlemap_VkSpecializationInfo(handlemap, (VkSpecializationInfo*)(toMap->pSpecializationInfo));
613     }
614 }
615 
handlemap_VkVertexInputBindingDescription(VulkanHandleMapping * handlemap,VkVertexInputBindingDescription * toMap)616 void handlemap_VkVertexInputBindingDescription(
617     VulkanHandleMapping* handlemap,
618     VkVertexInputBindingDescription* toMap)
619 {
620     (void)handlemap;
621     (void)toMap;
622 }
623 
handlemap_VkVertexInputAttributeDescription(VulkanHandleMapping * handlemap,VkVertexInputAttributeDescription * toMap)624 void handlemap_VkVertexInputAttributeDescription(
625     VulkanHandleMapping* handlemap,
626     VkVertexInputAttributeDescription* toMap)
627 {
628     (void)handlemap;
629     (void)toMap;
630 }
631 
handlemap_VkPipelineVertexInputStateCreateInfo(VulkanHandleMapping * handlemap,VkPipelineVertexInputStateCreateInfo * toMap)632 void handlemap_VkPipelineVertexInputStateCreateInfo(
633     VulkanHandleMapping* handlemap,
634     VkPipelineVertexInputStateCreateInfo* toMap)
635 {
636     (void)handlemap;
637     (void)toMap;
638     if (toMap->pNext)
639     {
640         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
641     }
642     if (toMap->pVertexBindingDescriptions)
643     {
644         for (uint32_t i = 0; i < (uint32_t)toMap->vertexBindingDescriptionCount; ++i)
645         {
646             handlemap_VkVertexInputBindingDescription(handlemap, (VkVertexInputBindingDescription*)(toMap->pVertexBindingDescriptions + i));
647         }
648     }
649     if (toMap->pVertexAttributeDescriptions)
650     {
651         for (uint32_t i = 0; i < (uint32_t)toMap->vertexAttributeDescriptionCount; ++i)
652         {
653             handlemap_VkVertexInputAttributeDescription(handlemap, (VkVertexInputAttributeDescription*)(toMap->pVertexAttributeDescriptions + i));
654         }
655     }
656 }
657 
handlemap_VkPipelineInputAssemblyStateCreateInfo(VulkanHandleMapping * handlemap,VkPipelineInputAssemblyStateCreateInfo * toMap)658 void handlemap_VkPipelineInputAssemblyStateCreateInfo(
659     VulkanHandleMapping* handlemap,
660     VkPipelineInputAssemblyStateCreateInfo* toMap)
661 {
662     (void)handlemap;
663     (void)toMap;
664     if (toMap->pNext)
665     {
666         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
667     }
668 }
669 
handlemap_VkPipelineTessellationStateCreateInfo(VulkanHandleMapping * handlemap,VkPipelineTessellationStateCreateInfo * toMap)670 void handlemap_VkPipelineTessellationStateCreateInfo(
671     VulkanHandleMapping* handlemap,
672     VkPipelineTessellationStateCreateInfo* toMap)
673 {
674     (void)handlemap;
675     (void)toMap;
676     if (toMap->pNext)
677     {
678         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
679     }
680 }
681 
handlemap_VkViewport(VulkanHandleMapping * handlemap,VkViewport * toMap)682 void handlemap_VkViewport(
683     VulkanHandleMapping* handlemap,
684     VkViewport* toMap)
685 {
686     (void)handlemap;
687     (void)toMap;
688 }
689 
handlemap_VkOffset2D(VulkanHandleMapping * handlemap,VkOffset2D * toMap)690 void handlemap_VkOffset2D(
691     VulkanHandleMapping* handlemap,
692     VkOffset2D* toMap)
693 {
694     (void)handlemap;
695     (void)toMap;
696 }
697 
handlemap_VkExtent2D(VulkanHandleMapping * handlemap,VkExtent2D * toMap)698 void handlemap_VkExtent2D(
699     VulkanHandleMapping* handlemap,
700     VkExtent2D* toMap)
701 {
702     (void)handlemap;
703     (void)toMap;
704 }
705 
handlemap_VkRect2D(VulkanHandleMapping * handlemap,VkRect2D * toMap)706 void handlemap_VkRect2D(
707     VulkanHandleMapping* handlemap,
708     VkRect2D* toMap)
709 {
710     (void)handlemap;
711     (void)toMap;
712     handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->offset));
713     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->extent));
714 }
715 
handlemap_VkPipelineViewportStateCreateInfo(VulkanHandleMapping * handlemap,VkPipelineViewportStateCreateInfo * toMap)716 void handlemap_VkPipelineViewportStateCreateInfo(
717     VulkanHandleMapping* handlemap,
718     VkPipelineViewportStateCreateInfo* toMap)
719 {
720     (void)handlemap;
721     (void)toMap;
722     if (toMap->pNext)
723     {
724         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
725     }
726     if (toMap->pViewports)
727     {
728         for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
729         {
730             handlemap_VkViewport(handlemap, (VkViewport*)(toMap->pViewports + i));
731         }
732     }
733     if (toMap->pScissors)
734     {
735         for (uint32_t i = 0; i < (uint32_t)toMap->scissorCount; ++i)
736         {
737             handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pScissors + i));
738         }
739     }
740 }
741 
handlemap_VkPipelineRasterizationStateCreateInfo(VulkanHandleMapping * handlemap,VkPipelineRasterizationStateCreateInfo * toMap)742 void handlemap_VkPipelineRasterizationStateCreateInfo(
743     VulkanHandleMapping* handlemap,
744     VkPipelineRasterizationStateCreateInfo* toMap)
745 {
746     (void)handlemap;
747     (void)toMap;
748     if (toMap->pNext)
749     {
750         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
751     }
752 }
753 
handlemap_VkPipelineMultisampleStateCreateInfo(VulkanHandleMapping * handlemap,VkPipelineMultisampleStateCreateInfo * toMap)754 void handlemap_VkPipelineMultisampleStateCreateInfo(
755     VulkanHandleMapping* handlemap,
756     VkPipelineMultisampleStateCreateInfo* toMap)
757 {
758     (void)handlemap;
759     (void)toMap;
760     if (toMap->pNext)
761     {
762         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
763     }
764 }
765 
handlemap_VkStencilOpState(VulkanHandleMapping * handlemap,VkStencilOpState * toMap)766 void handlemap_VkStencilOpState(
767     VulkanHandleMapping* handlemap,
768     VkStencilOpState* toMap)
769 {
770     (void)handlemap;
771     (void)toMap;
772 }
773 
handlemap_VkPipelineDepthStencilStateCreateInfo(VulkanHandleMapping * handlemap,VkPipelineDepthStencilStateCreateInfo * toMap)774 void handlemap_VkPipelineDepthStencilStateCreateInfo(
775     VulkanHandleMapping* handlemap,
776     VkPipelineDepthStencilStateCreateInfo* toMap)
777 {
778     (void)handlemap;
779     (void)toMap;
780     if (toMap->pNext)
781     {
782         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
783     }
784     handlemap_VkStencilOpState(handlemap, (VkStencilOpState*)(&toMap->front));
785     handlemap_VkStencilOpState(handlemap, (VkStencilOpState*)(&toMap->back));
786 }
787 
handlemap_VkPipelineColorBlendAttachmentState(VulkanHandleMapping * handlemap,VkPipelineColorBlendAttachmentState * toMap)788 void handlemap_VkPipelineColorBlendAttachmentState(
789     VulkanHandleMapping* handlemap,
790     VkPipelineColorBlendAttachmentState* toMap)
791 {
792     (void)handlemap;
793     (void)toMap;
794 }
795 
handlemap_VkPipelineColorBlendStateCreateInfo(VulkanHandleMapping * handlemap,VkPipelineColorBlendStateCreateInfo * toMap)796 void handlemap_VkPipelineColorBlendStateCreateInfo(
797     VulkanHandleMapping* handlemap,
798     VkPipelineColorBlendStateCreateInfo* toMap)
799 {
800     (void)handlemap;
801     (void)toMap;
802     if (toMap->pNext)
803     {
804         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
805     }
806     if (toMap->pAttachments)
807     {
808         for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
809         {
810             handlemap_VkPipelineColorBlendAttachmentState(handlemap, (VkPipelineColorBlendAttachmentState*)(toMap->pAttachments + i));
811         }
812     }
813 }
814 
handlemap_VkPipelineDynamicStateCreateInfo(VulkanHandleMapping * handlemap,VkPipelineDynamicStateCreateInfo * toMap)815 void handlemap_VkPipelineDynamicStateCreateInfo(
816     VulkanHandleMapping* handlemap,
817     VkPipelineDynamicStateCreateInfo* toMap)
818 {
819     (void)handlemap;
820     (void)toMap;
821     if (toMap->pNext)
822     {
823         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
824     }
825 }
826 
handlemap_VkGraphicsPipelineCreateInfo(VulkanHandleMapping * handlemap,VkGraphicsPipelineCreateInfo * toMap)827 void handlemap_VkGraphicsPipelineCreateInfo(
828     VulkanHandleMapping* handlemap,
829     VkGraphicsPipelineCreateInfo* toMap)
830 {
831     (void)handlemap;
832     (void)toMap;
833     if (toMap->pNext)
834     {
835         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
836     }
837     if (toMap->pStages)
838     {
839         for (uint32_t i = 0; i < (uint32_t)toMap->stageCount; ++i)
840         {
841             handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(toMap->pStages + i));
842         }
843     }
844     if (toMap->pVertexInputState)
845     {
846         handlemap_VkPipelineVertexInputStateCreateInfo(handlemap, (VkPipelineVertexInputStateCreateInfo*)(toMap->pVertexInputState));
847     }
848     if (toMap->pInputAssemblyState)
849     {
850         handlemap_VkPipelineInputAssemblyStateCreateInfo(handlemap, (VkPipelineInputAssemblyStateCreateInfo*)(toMap->pInputAssemblyState));
851     }
852     if (toMap->pTessellationState)
853     {
854         handlemap_VkPipelineTessellationStateCreateInfo(handlemap, (VkPipelineTessellationStateCreateInfo*)(toMap->pTessellationState));
855     }
856     if (toMap->pViewportState)
857     {
858         handlemap_VkPipelineViewportStateCreateInfo(handlemap, (VkPipelineViewportStateCreateInfo*)(toMap->pViewportState));
859     }
860     if (toMap->pRasterizationState)
861     {
862         handlemap_VkPipelineRasterizationStateCreateInfo(handlemap, (VkPipelineRasterizationStateCreateInfo*)(toMap->pRasterizationState));
863     }
864     if (toMap->pMultisampleState)
865     {
866         handlemap_VkPipelineMultisampleStateCreateInfo(handlemap, (VkPipelineMultisampleStateCreateInfo*)(toMap->pMultisampleState));
867     }
868     if (toMap->pDepthStencilState)
869     {
870         handlemap_VkPipelineDepthStencilStateCreateInfo(handlemap, (VkPipelineDepthStencilStateCreateInfo*)(toMap->pDepthStencilState));
871     }
872     if (toMap->pColorBlendState)
873     {
874         handlemap_VkPipelineColorBlendStateCreateInfo(handlemap, (VkPipelineColorBlendStateCreateInfo*)(toMap->pColorBlendState));
875     }
876     if (toMap->pDynamicState)
877     {
878         handlemap_VkPipelineDynamicStateCreateInfo(handlemap, (VkPipelineDynamicStateCreateInfo*)(toMap->pDynamicState));
879     }
880     handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->layout);
881     handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
882     handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->basePipelineHandle);
883 }
884 
handlemap_VkComputePipelineCreateInfo(VulkanHandleMapping * handlemap,VkComputePipelineCreateInfo * toMap)885 void handlemap_VkComputePipelineCreateInfo(
886     VulkanHandleMapping* handlemap,
887     VkComputePipelineCreateInfo* toMap)
888 {
889     (void)handlemap;
890     (void)toMap;
891     if (toMap->pNext)
892     {
893         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
894     }
895     handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(&toMap->stage));
896     handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->layout);
897     handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->basePipelineHandle);
898 }
899 
handlemap_VkPushConstantRange(VulkanHandleMapping * handlemap,VkPushConstantRange * toMap)900 void handlemap_VkPushConstantRange(
901     VulkanHandleMapping* handlemap,
902     VkPushConstantRange* toMap)
903 {
904     (void)handlemap;
905     (void)toMap;
906 }
907 
handlemap_VkPipelineLayoutCreateInfo(VulkanHandleMapping * handlemap,VkPipelineLayoutCreateInfo * toMap)908 void handlemap_VkPipelineLayoutCreateInfo(
909     VulkanHandleMapping* handlemap,
910     VkPipelineLayoutCreateInfo* toMap)
911 {
912     (void)handlemap;
913     (void)toMap;
914     if (toMap->pNext)
915     {
916         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
917     }
918     if (toMap->pSetLayouts)
919     {
920         handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts, toMap->setLayoutCount);
921     }
922     if (toMap->pPushConstantRanges)
923     {
924         for (uint32_t i = 0; i < (uint32_t)toMap->pushConstantRangeCount; ++i)
925         {
926             handlemap_VkPushConstantRange(handlemap, (VkPushConstantRange*)(toMap->pPushConstantRanges + i));
927         }
928     }
929 }
930 
handlemap_VkSamplerCreateInfo(VulkanHandleMapping * handlemap,VkSamplerCreateInfo * toMap)931 void handlemap_VkSamplerCreateInfo(
932     VulkanHandleMapping* handlemap,
933     VkSamplerCreateInfo* toMap)
934 {
935     (void)handlemap;
936     (void)toMap;
937     if (toMap->pNext)
938     {
939         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
940     }
941 }
942 
handlemap_VkDescriptorSetLayoutBinding(VulkanHandleMapping * handlemap,VkDescriptorSetLayoutBinding * toMap)943 void handlemap_VkDescriptorSetLayoutBinding(
944     VulkanHandleMapping* handlemap,
945     VkDescriptorSetLayoutBinding* toMap)
946 {
947     (void)handlemap;
948     (void)toMap;
949     if (toMap->pImmutableSamplers)
950     {
951         handlemap->mapHandles_VkSampler((VkSampler*)toMap->pImmutableSamplers, toMap->descriptorCount);
952     }
953 }
954 
handlemap_VkDescriptorSetLayoutCreateInfo(VulkanHandleMapping * handlemap,VkDescriptorSetLayoutCreateInfo * toMap)955 void handlemap_VkDescriptorSetLayoutCreateInfo(
956     VulkanHandleMapping* handlemap,
957     VkDescriptorSetLayoutCreateInfo* toMap)
958 {
959     (void)handlemap;
960     (void)toMap;
961     if (toMap->pNext)
962     {
963         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
964     }
965     if (toMap->pBindings)
966     {
967         for (uint32_t i = 0; i < (uint32_t)toMap->bindingCount; ++i)
968         {
969             handlemap_VkDescriptorSetLayoutBinding(handlemap, (VkDescriptorSetLayoutBinding*)(toMap->pBindings + i));
970         }
971     }
972 }
973 
handlemap_VkDescriptorPoolSize(VulkanHandleMapping * handlemap,VkDescriptorPoolSize * toMap)974 void handlemap_VkDescriptorPoolSize(
975     VulkanHandleMapping* handlemap,
976     VkDescriptorPoolSize* toMap)
977 {
978     (void)handlemap;
979     (void)toMap;
980 }
981 
handlemap_VkDescriptorPoolCreateInfo(VulkanHandleMapping * handlemap,VkDescriptorPoolCreateInfo * toMap)982 void handlemap_VkDescriptorPoolCreateInfo(
983     VulkanHandleMapping* handlemap,
984     VkDescriptorPoolCreateInfo* toMap)
985 {
986     (void)handlemap;
987     (void)toMap;
988     if (toMap->pNext)
989     {
990         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
991     }
992     if (toMap->pPoolSizes)
993     {
994         for (uint32_t i = 0; i < (uint32_t)toMap->poolSizeCount; ++i)
995         {
996             handlemap_VkDescriptorPoolSize(handlemap, (VkDescriptorPoolSize*)(toMap->pPoolSizes + i));
997         }
998     }
999 }
1000 
handlemap_VkDescriptorSetAllocateInfo(VulkanHandleMapping * handlemap,VkDescriptorSetAllocateInfo * toMap)1001 void handlemap_VkDescriptorSetAllocateInfo(
1002     VulkanHandleMapping* handlemap,
1003     VkDescriptorSetAllocateInfo* toMap)
1004 {
1005     (void)handlemap;
1006     (void)toMap;
1007     if (toMap->pNext)
1008     {
1009         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1010     }
1011     handlemap->mapHandles_VkDescriptorPool((VkDescriptorPool*)&toMap->descriptorPool);
1012     if (toMap->pSetLayouts)
1013     {
1014         handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts, toMap->descriptorSetCount);
1015     }
1016 }
1017 
handlemap_VkDescriptorImageInfo(VulkanHandleMapping * handlemap,VkDescriptorImageInfo * toMap)1018 void handlemap_VkDescriptorImageInfo(
1019     VulkanHandleMapping* handlemap,
1020     VkDescriptorImageInfo* toMap)
1021 {
1022     (void)handlemap;
1023     (void)toMap;
1024     handlemap->mapHandles_VkSampler((VkSampler*)&toMap->sampler);
1025     handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
1026 }
1027 
handlemap_VkDescriptorBufferInfo(VulkanHandleMapping * handlemap,VkDescriptorBufferInfo * toMap)1028 void handlemap_VkDescriptorBufferInfo(
1029     VulkanHandleMapping* handlemap,
1030     VkDescriptorBufferInfo* toMap)
1031 {
1032     (void)handlemap;
1033     (void)toMap;
1034     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
1035 }
1036 
handlemap_VkWriteDescriptorSet(VulkanHandleMapping * handlemap,VkWriteDescriptorSet * toMap)1037 void handlemap_VkWriteDescriptorSet(
1038     VulkanHandleMapping* handlemap,
1039     VkWriteDescriptorSet* toMap)
1040 {
1041     (void)handlemap;
1042     (void)toMap;
1043     if (toMap->pNext)
1044     {
1045         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1046     }
1047     handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->dstSet);
1048     if (toMap->pImageInfo)
1049     {
1050         for (uint32_t i = 0; i < (uint32_t)toMap->descriptorCount; ++i)
1051         {
1052             handlemap_VkDescriptorImageInfo(handlemap, (VkDescriptorImageInfo*)(toMap->pImageInfo + i));
1053         }
1054     }
1055     if (toMap->pBufferInfo)
1056     {
1057         for (uint32_t i = 0; i < (uint32_t)toMap->descriptorCount; ++i)
1058         {
1059             handlemap_VkDescriptorBufferInfo(handlemap, (VkDescriptorBufferInfo*)(toMap->pBufferInfo + i));
1060         }
1061     }
1062     if (toMap->pTexelBufferView)
1063     {
1064         handlemap->mapHandles_VkBufferView((VkBufferView*)toMap->pTexelBufferView, toMap->descriptorCount);
1065     }
1066 }
1067 
handlemap_VkCopyDescriptorSet(VulkanHandleMapping * handlemap,VkCopyDescriptorSet * toMap)1068 void handlemap_VkCopyDescriptorSet(
1069     VulkanHandleMapping* handlemap,
1070     VkCopyDescriptorSet* toMap)
1071 {
1072     (void)handlemap;
1073     (void)toMap;
1074     if (toMap->pNext)
1075     {
1076         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1077     }
1078     handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->srcSet);
1079     handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->dstSet);
1080 }
1081 
handlemap_VkFramebufferCreateInfo(VulkanHandleMapping * handlemap,VkFramebufferCreateInfo * toMap)1082 void handlemap_VkFramebufferCreateInfo(
1083     VulkanHandleMapping* handlemap,
1084     VkFramebufferCreateInfo* toMap)
1085 {
1086     (void)handlemap;
1087     (void)toMap;
1088     if (toMap->pNext)
1089     {
1090         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1091     }
1092     handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
1093     if (toMap->pAttachments)
1094     {
1095         handlemap->mapHandles_VkImageView((VkImageView*)toMap->pAttachments, toMap->attachmentCount);
1096     }
1097 }
1098 
handlemap_VkAttachmentDescription(VulkanHandleMapping * handlemap,VkAttachmentDescription * toMap)1099 void handlemap_VkAttachmentDescription(
1100     VulkanHandleMapping* handlemap,
1101     VkAttachmentDescription* toMap)
1102 {
1103     (void)handlemap;
1104     (void)toMap;
1105 }
1106 
handlemap_VkAttachmentReference(VulkanHandleMapping * handlemap,VkAttachmentReference * toMap)1107 void handlemap_VkAttachmentReference(
1108     VulkanHandleMapping* handlemap,
1109     VkAttachmentReference* toMap)
1110 {
1111     (void)handlemap;
1112     (void)toMap;
1113 }
1114 
handlemap_VkSubpassDescription(VulkanHandleMapping * handlemap,VkSubpassDescription * toMap)1115 void handlemap_VkSubpassDescription(
1116     VulkanHandleMapping* handlemap,
1117     VkSubpassDescription* toMap)
1118 {
1119     (void)handlemap;
1120     (void)toMap;
1121     if (toMap->pInputAttachments)
1122     {
1123         for (uint32_t i = 0; i < (uint32_t)toMap->inputAttachmentCount; ++i)
1124         {
1125             handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pInputAttachments + i));
1126         }
1127     }
1128     if (toMap->pColorAttachments)
1129     {
1130         for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
1131         {
1132             handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pColorAttachments + i));
1133         }
1134     }
1135     if (toMap->pResolveAttachments)
1136     {
1137         for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
1138         {
1139             handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pResolveAttachments + i));
1140         }
1141     }
1142     if (toMap->pDepthStencilAttachment)
1143     {
1144         handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pDepthStencilAttachment));
1145     }
1146 }
1147 
handlemap_VkSubpassDependency(VulkanHandleMapping * handlemap,VkSubpassDependency * toMap)1148 void handlemap_VkSubpassDependency(
1149     VulkanHandleMapping* handlemap,
1150     VkSubpassDependency* toMap)
1151 {
1152     (void)handlemap;
1153     (void)toMap;
1154 }
1155 
handlemap_VkRenderPassCreateInfo(VulkanHandleMapping * handlemap,VkRenderPassCreateInfo * toMap)1156 void handlemap_VkRenderPassCreateInfo(
1157     VulkanHandleMapping* handlemap,
1158     VkRenderPassCreateInfo* toMap)
1159 {
1160     (void)handlemap;
1161     (void)toMap;
1162     if (toMap->pNext)
1163     {
1164         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1165     }
1166     if (toMap->pAttachments)
1167     {
1168         for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
1169         {
1170             handlemap_VkAttachmentDescription(handlemap, (VkAttachmentDescription*)(toMap->pAttachments + i));
1171         }
1172     }
1173     if (toMap->pSubpasses)
1174     {
1175         for (uint32_t i = 0; i < (uint32_t)toMap->subpassCount; ++i)
1176         {
1177             handlemap_VkSubpassDescription(handlemap, (VkSubpassDescription*)(toMap->pSubpasses + i));
1178         }
1179     }
1180     if (toMap->pDependencies)
1181     {
1182         for (uint32_t i = 0; i < (uint32_t)toMap->dependencyCount; ++i)
1183         {
1184             handlemap_VkSubpassDependency(handlemap, (VkSubpassDependency*)(toMap->pDependencies + i));
1185         }
1186     }
1187 }
1188 
handlemap_VkCommandPoolCreateInfo(VulkanHandleMapping * handlemap,VkCommandPoolCreateInfo * toMap)1189 void handlemap_VkCommandPoolCreateInfo(
1190     VulkanHandleMapping* handlemap,
1191     VkCommandPoolCreateInfo* toMap)
1192 {
1193     (void)handlemap;
1194     (void)toMap;
1195     if (toMap->pNext)
1196     {
1197         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1198     }
1199 }
1200 
handlemap_VkCommandBufferAllocateInfo(VulkanHandleMapping * handlemap,VkCommandBufferAllocateInfo * toMap)1201 void handlemap_VkCommandBufferAllocateInfo(
1202     VulkanHandleMapping* handlemap,
1203     VkCommandBufferAllocateInfo* toMap)
1204 {
1205     (void)handlemap;
1206     (void)toMap;
1207     if (toMap->pNext)
1208     {
1209         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1210     }
1211     handlemap->mapHandles_VkCommandPool((VkCommandPool*)&toMap->commandPool);
1212 }
1213 
handlemap_VkCommandBufferInheritanceInfo(VulkanHandleMapping * handlemap,VkCommandBufferInheritanceInfo * toMap)1214 void handlemap_VkCommandBufferInheritanceInfo(
1215     VulkanHandleMapping* handlemap,
1216     VkCommandBufferInheritanceInfo* toMap)
1217 {
1218     (void)handlemap;
1219     (void)toMap;
1220     if (toMap->pNext)
1221     {
1222         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1223     }
1224     handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
1225     handlemap->mapHandles_VkFramebuffer((VkFramebuffer*)&toMap->framebuffer);
1226 }
1227 
handlemap_VkCommandBufferBeginInfo(VulkanHandleMapping * handlemap,VkCommandBufferBeginInfo * toMap)1228 void handlemap_VkCommandBufferBeginInfo(
1229     VulkanHandleMapping* handlemap,
1230     VkCommandBufferBeginInfo* toMap)
1231 {
1232     (void)handlemap;
1233     (void)toMap;
1234     if (toMap->pNext)
1235     {
1236         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1237     }
1238     if (toMap->pInheritanceInfo)
1239     {
1240         handlemap_VkCommandBufferInheritanceInfo(handlemap, (VkCommandBufferInheritanceInfo*)(toMap->pInheritanceInfo));
1241     }
1242 }
1243 
handlemap_VkBufferCopy(VulkanHandleMapping * handlemap,VkBufferCopy * toMap)1244 void handlemap_VkBufferCopy(
1245     VulkanHandleMapping* handlemap,
1246     VkBufferCopy* toMap)
1247 {
1248     (void)handlemap;
1249     (void)toMap;
1250 }
1251 
handlemap_VkImageSubresourceLayers(VulkanHandleMapping * handlemap,VkImageSubresourceLayers * toMap)1252 void handlemap_VkImageSubresourceLayers(
1253     VulkanHandleMapping* handlemap,
1254     VkImageSubresourceLayers* toMap)
1255 {
1256     (void)handlemap;
1257     (void)toMap;
1258 }
1259 
handlemap_VkImageCopy(VulkanHandleMapping * handlemap,VkImageCopy * toMap)1260 void handlemap_VkImageCopy(
1261     VulkanHandleMapping* handlemap,
1262     VkImageCopy* toMap)
1263 {
1264     (void)handlemap;
1265     (void)toMap;
1266     handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
1267     handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
1268     handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
1269     handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
1270     handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
1271 }
1272 
handlemap_VkImageBlit(VulkanHandleMapping * handlemap,VkImageBlit * toMap)1273 void handlemap_VkImageBlit(
1274     VulkanHandleMapping* handlemap,
1275     VkImageBlit* toMap)
1276 {
1277     (void)handlemap;
1278     (void)toMap;
1279     handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
1280     for (uint32_t i = 0; i < (uint32_t)2; ++i)
1281     {
1282         handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->srcOffsets + i));
1283     }
1284     handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
1285     for (uint32_t i = 0; i < (uint32_t)2; ++i)
1286     {
1287         handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->dstOffsets + i));
1288     }
1289 }
1290 
handlemap_VkBufferImageCopy(VulkanHandleMapping * handlemap,VkBufferImageCopy * toMap)1291 void handlemap_VkBufferImageCopy(
1292     VulkanHandleMapping* handlemap,
1293     VkBufferImageCopy* toMap)
1294 {
1295     (void)handlemap;
1296     (void)toMap;
1297     handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->imageSubresource));
1298     handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->imageOffset));
1299     handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageExtent));
1300 }
1301 
handlemap_VkClearColorValue(VulkanHandleMapping * handlemap,VkClearColorValue * toMap)1302 void handlemap_VkClearColorValue(
1303     VulkanHandleMapping* handlemap,
1304     VkClearColorValue* toMap)
1305 {
1306     (void)handlemap;
1307     (void)toMap;
1308 }
1309 
handlemap_VkClearDepthStencilValue(VulkanHandleMapping * handlemap,VkClearDepthStencilValue * toMap)1310 void handlemap_VkClearDepthStencilValue(
1311     VulkanHandleMapping* handlemap,
1312     VkClearDepthStencilValue* toMap)
1313 {
1314     (void)handlemap;
1315     (void)toMap;
1316 }
1317 
handlemap_VkClearValue(VulkanHandleMapping * handlemap,VkClearValue * toMap)1318 void handlemap_VkClearValue(
1319     VulkanHandleMapping* handlemap,
1320     VkClearValue* toMap)
1321 {
1322     (void)handlemap;
1323     (void)toMap;
1324     handlemap_VkClearColorValue(handlemap, (VkClearColorValue*)(&toMap->color));
1325     handlemap_VkClearDepthStencilValue(handlemap, (VkClearDepthStencilValue*)(&toMap->depthStencil));
1326 }
1327 
handlemap_VkClearAttachment(VulkanHandleMapping * handlemap,VkClearAttachment * toMap)1328 void handlemap_VkClearAttachment(
1329     VulkanHandleMapping* handlemap,
1330     VkClearAttachment* toMap)
1331 {
1332     (void)handlemap;
1333     (void)toMap;
1334     handlemap_VkClearValue(handlemap, (VkClearValue*)(&toMap->clearValue));
1335 }
1336 
handlemap_VkClearRect(VulkanHandleMapping * handlemap,VkClearRect * toMap)1337 void handlemap_VkClearRect(
1338     VulkanHandleMapping* handlemap,
1339     VkClearRect* toMap)
1340 {
1341     (void)handlemap;
1342     (void)toMap;
1343     handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->rect));
1344 }
1345 
handlemap_VkImageResolve(VulkanHandleMapping * handlemap,VkImageResolve * toMap)1346 void handlemap_VkImageResolve(
1347     VulkanHandleMapping* handlemap,
1348     VkImageResolve* toMap)
1349 {
1350     (void)handlemap;
1351     (void)toMap;
1352     handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
1353     handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
1354     handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
1355     handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
1356     handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
1357 }
1358 
handlemap_VkMemoryBarrier(VulkanHandleMapping * handlemap,VkMemoryBarrier * toMap)1359 void handlemap_VkMemoryBarrier(
1360     VulkanHandleMapping* handlemap,
1361     VkMemoryBarrier* toMap)
1362 {
1363     (void)handlemap;
1364     (void)toMap;
1365     if (toMap->pNext)
1366     {
1367         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1368     }
1369 }
1370 
handlemap_VkBufferMemoryBarrier(VulkanHandleMapping * handlemap,VkBufferMemoryBarrier * toMap)1371 void handlemap_VkBufferMemoryBarrier(
1372     VulkanHandleMapping* handlemap,
1373     VkBufferMemoryBarrier* toMap)
1374 {
1375     (void)handlemap;
1376     (void)toMap;
1377     if (toMap->pNext)
1378     {
1379         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1380     }
1381     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
1382 }
1383 
handlemap_VkImageMemoryBarrier(VulkanHandleMapping * handlemap,VkImageMemoryBarrier * toMap)1384 void handlemap_VkImageMemoryBarrier(
1385     VulkanHandleMapping* handlemap,
1386     VkImageMemoryBarrier* toMap)
1387 {
1388     (void)handlemap;
1389     (void)toMap;
1390     if (toMap->pNext)
1391     {
1392         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1393     }
1394     handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
1395     handlemap_VkImageSubresourceRange(handlemap, (VkImageSubresourceRange*)(&toMap->subresourceRange));
1396 }
1397 
handlemap_VkRenderPassBeginInfo(VulkanHandleMapping * handlemap,VkRenderPassBeginInfo * toMap)1398 void handlemap_VkRenderPassBeginInfo(
1399     VulkanHandleMapping* handlemap,
1400     VkRenderPassBeginInfo* toMap)
1401 {
1402     (void)handlemap;
1403     (void)toMap;
1404     if (toMap->pNext)
1405     {
1406         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1407     }
1408     handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
1409     handlemap->mapHandles_VkFramebuffer((VkFramebuffer*)&toMap->framebuffer);
1410     handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->renderArea));
1411     if (toMap->pClearValues)
1412     {
1413         for (uint32_t i = 0; i < (uint32_t)toMap->clearValueCount; ++i)
1414         {
1415             handlemap_VkClearValue(handlemap, (VkClearValue*)(toMap->pClearValues + i));
1416         }
1417     }
1418 }
1419 
handlemap_VkDispatchIndirectCommand(VulkanHandleMapping * handlemap,VkDispatchIndirectCommand * toMap)1420 void handlemap_VkDispatchIndirectCommand(
1421     VulkanHandleMapping* handlemap,
1422     VkDispatchIndirectCommand* toMap)
1423 {
1424     (void)handlemap;
1425     (void)toMap;
1426 }
1427 
handlemap_VkDrawIndexedIndirectCommand(VulkanHandleMapping * handlemap,VkDrawIndexedIndirectCommand * toMap)1428 void handlemap_VkDrawIndexedIndirectCommand(
1429     VulkanHandleMapping* handlemap,
1430     VkDrawIndexedIndirectCommand* toMap)
1431 {
1432     (void)handlemap;
1433     (void)toMap;
1434 }
1435 
handlemap_VkDrawIndirectCommand(VulkanHandleMapping * handlemap,VkDrawIndirectCommand * toMap)1436 void handlemap_VkDrawIndirectCommand(
1437     VulkanHandleMapping* handlemap,
1438     VkDrawIndirectCommand* toMap)
1439 {
1440     (void)handlemap;
1441     (void)toMap;
1442 }
1443 
handlemap_VkBaseOutStructure(VulkanHandleMapping * handlemap,VkBaseOutStructure * toMap)1444 void handlemap_VkBaseOutStructure(
1445     VulkanHandleMapping* handlemap,
1446     VkBaseOutStructure* toMap)
1447 {
1448     (void)handlemap;
1449     (void)toMap;
1450     if (toMap->pNext)
1451     {
1452         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1453     }
1454 }
1455 
handlemap_VkBaseInStructure(VulkanHandleMapping * handlemap,VkBaseInStructure * toMap)1456 void handlemap_VkBaseInStructure(
1457     VulkanHandleMapping* handlemap,
1458     VkBaseInStructure* toMap)
1459 {
1460     (void)handlemap;
1461     (void)toMap;
1462     if (toMap->pNext)
1463     {
1464         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1465     }
1466 }
1467 
1468 #endif
1469 #ifdef VK_VERSION_1_1
handlemap_VkPhysicalDeviceSubgroupProperties(VulkanHandleMapping * handlemap,VkPhysicalDeviceSubgroupProperties * toMap)1470 void handlemap_VkPhysicalDeviceSubgroupProperties(
1471     VulkanHandleMapping* handlemap,
1472     VkPhysicalDeviceSubgroupProperties* toMap)
1473 {
1474     (void)handlemap;
1475     (void)toMap;
1476     if (toMap->pNext)
1477     {
1478         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1479     }
1480 }
1481 
handlemap_VkBindBufferMemoryInfo(VulkanHandleMapping * handlemap,VkBindBufferMemoryInfo * toMap)1482 void handlemap_VkBindBufferMemoryInfo(
1483     VulkanHandleMapping* handlemap,
1484     VkBindBufferMemoryInfo* toMap)
1485 {
1486     (void)handlemap;
1487     (void)toMap;
1488     if (toMap->pNext)
1489     {
1490         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1491     }
1492     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
1493     handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
1494 }
1495 
handlemap_VkBindImageMemoryInfo(VulkanHandleMapping * handlemap,VkBindImageMemoryInfo * toMap)1496 void handlemap_VkBindImageMemoryInfo(
1497     VulkanHandleMapping* handlemap,
1498     VkBindImageMemoryInfo* toMap)
1499 {
1500     (void)handlemap;
1501     (void)toMap;
1502     if (toMap->pNext)
1503     {
1504         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1505     }
1506     handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
1507     handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
1508 }
1509 
handlemap_VkPhysicalDevice16BitStorageFeatures(VulkanHandleMapping * handlemap,VkPhysicalDevice16BitStorageFeatures * toMap)1510 void handlemap_VkPhysicalDevice16BitStorageFeatures(
1511     VulkanHandleMapping* handlemap,
1512     VkPhysicalDevice16BitStorageFeatures* toMap)
1513 {
1514     (void)handlemap;
1515     (void)toMap;
1516     if (toMap->pNext)
1517     {
1518         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1519     }
1520 }
1521 
handlemap_VkMemoryDedicatedRequirements(VulkanHandleMapping * handlemap,VkMemoryDedicatedRequirements * toMap)1522 void handlemap_VkMemoryDedicatedRequirements(
1523     VulkanHandleMapping* handlemap,
1524     VkMemoryDedicatedRequirements* toMap)
1525 {
1526     (void)handlemap;
1527     (void)toMap;
1528     if (toMap->pNext)
1529     {
1530         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1531     }
1532 }
1533 
handlemap_VkMemoryDedicatedAllocateInfo(VulkanHandleMapping * handlemap,VkMemoryDedicatedAllocateInfo * toMap)1534 void handlemap_VkMemoryDedicatedAllocateInfo(
1535     VulkanHandleMapping* handlemap,
1536     VkMemoryDedicatedAllocateInfo* toMap)
1537 {
1538     (void)handlemap;
1539     (void)toMap;
1540     if (toMap->pNext)
1541     {
1542         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1543     }
1544     handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
1545     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
1546 }
1547 
handlemap_VkMemoryAllocateFlagsInfo(VulkanHandleMapping * handlemap,VkMemoryAllocateFlagsInfo * toMap)1548 void handlemap_VkMemoryAllocateFlagsInfo(
1549     VulkanHandleMapping* handlemap,
1550     VkMemoryAllocateFlagsInfo* toMap)
1551 {
1552     (void)handlemap;
1553     (void)toMap;
1554     if (toMap->pNext)
1555     {
1556         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1557     }
1558 }
1559 
handlemap_VkDeviceGroupRenderPassBeginInfo(VulkanHandleMapping * handlemap,VkDeviceGroupRenderPassBeginInfo * toMap)1560 void handlemap_VkDeviceGroupRenderPassBeginInfo(
1561     VulkanHandleMapping* handlemap,
1562     VkDeviceGroupRenderPassBeginInfo* toMap)
1563 {
1564     (void)handlemap;
1565     (void)toMap;
1566     if (toMap->pNext)
1567     {
1568         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1569     }
1570     if (toMap->pDeviceRenderAreas)
1571     {
1572         for (uint32_t i = 0; i < (uint32_t)toMap->deviceRenderAreaCount; ++i)
1573         {
1574             handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pDeviceRenderAreas + i));
1575         }
1576     }
1577 }
1578 
handlemap_VkDeviceGroupCommandBufferBeginInfo(VulkanHandleMapping * handlemap,VkDeviceGroupCommandBufferBeginInfo * toMap)1579 void handlemap_VkDeviceGroupCommandBufferBeginInfo(
1580     VulkanHandleMapping* handlemap,
1581     VkDeviceGroupCommandBufferBeginInfo* toMap)
1582 {
1583     (void)handlemap;
1584     (void)toMap;
1585     if (toMap->pNext)
1586     {
1587         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1588     }
1589 }
1590 
handlemap_VkDeviceGroupSubmitInfo(VulkanHandleMapping * handlemap,VkDeviceGroupSubmitInfo * toMap)1591 void handlemap_VkDeviceGroupSubmitInfo(
1592     VulkanHandleMapping* handlemap,
1593     VkDeviceGroupSubmitInfo* toMap)
1594 {
1595     (void)handlemap;
1596     (void)toMap;
1597     if (toMap->pNext)
1598     {
1599         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1600     }
1601 }
1602 
handlemap_VkDeviceGroupBindSparseInfo(VulkanHandleMapping * handlemap,VkDeviceGroupBindSparseInfo * toMap)1603 void handlemap_VkDeviceGroupBindSparseInfo(
1604     VulkanHandleMapping* handlemap,
1605     VkDeviceGroupBindSparseInfo* toMap)
1606 {
1607     (void)handlemap;
1608     (void)toMap;
1609     if (toMap->pNext)
1610     {
1611         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1612     }
1613 }
1614 
handlemap_VkBindBufferMemoryDeviceGroupInfo(VulkanHandleMapping * handlemap,VkBindBufferMemoryDeviceGroupInfo * toMap)1615 void handlemap_VkBindBufferMemoryDeviceGroupInfo(
1616     VulkanHandleMapping* handlemap,
1617     VkBindBufferMemoryDeviceGroupInfo* toMap)
1618 {
1619     (void)handlemap;
1620     (void)toMap;
1621     if (toMap->pNext)
1622     {
1623         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1624     }
1625 }
1626 
handlemap_VkBindImageMemoryDeviceGroupInfo(VulkanHandleMapping * handlemap,VkBindImageMemoryDeviceGroupInfo * toMap)1627 void handlemap_VkBindImageMemoryDeviceGroupInfo(
1628     VulkanHandleMapping* handlemap,
1629     VkBindImageMemoryDeviceGroupInfo* toMap)
1630 {
1631     (void)handlemap;
1632     (void)toMap;
1633     if (toMap->pNext)
1634     {
1635         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1636     }
1637     if (toMap->pSplitInstanceBindRegions)
1638     {
1639         for (uint32_t i = 0; i < (uint32_t)toMap->splitInstanceBindRegionCount; ++i)
1640         {
1641             handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pSplitInstanceBindRegions + i));
1642         }
1643     }
1644 }
1645 
handlemap_VkPhysicalDeviceGroupProperties(VulkanHandleMapping * handlemap,VkPhysicalDeviceGroupProperties * toMap)1646 void handlemap_VkPhysicalDeviceGroupProperties(
1647     VulkanHandleMapping* handlemap,
1648     VkPhysicalDeviceGroupProperties* toMap)
1649 {
1650     (void)handlemap;
1651     (void)toMap;
1652     if (toMap->pNext)
1653     {
1654         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1655     }
1656     handlemap->mapHandles_VkPhysicalDevice((VkPhysicalDevice*)toMap->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE);
1657 }
1658 
handlemap_VkDeviceGroupDeviceCreateInfo(VulkanHandleMapping * handlemap,VkDeviceGroupDeviceCreateInfo * toMap)1659 void handlemap_VkDeviceGroupDeviceCreateInfo(
1660     VulkanHandleMapping* handlemap,
1661     VkDeviceGroupDeviceCreateInfo* toMap)
1662 {
1663     (void)handlemap;
1664     (void)toMap;
1665     if (toMap->pNext)
1666     {
1667         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1668     }
1669     if (toMap->pPhysicalDevices)
1670     {
1671         handlemap->mapHandles_VkPhysicalDevice((VkPhysicalDevice*)toMap->pPhysicalDevices, toMap->physicalDeviceCount);
1672     }
1673 }
1674 
handlemap_VkBufferMemoryRequirementsInfo2(VulkanHandleMapping * handlemap,VkBufferMemoryRequirementsInfo2 * toMap)1675 void handlemap_VkBufferMemoryRequirementsInfo2(
1676     VulkanHandleMapping* handlemap,
1677     VkBufferMemoryRequirementsInfo2* toMap)
1678 {
1679     (void)handlemap;
1680     (void)toMap;
1681     if (toMap->pNext)
1682     {
1683         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1684     }
1685     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
1686 }
1687 
handlemap_VkImageMemoryRequirementsInfo2(VulkanHandleMapping * handlemap,VkImageMemoryRequirementsInfo2 * toMap)1688 void handlemap_VkImageMemoryRequirementsInfo2(
1689     VulkanHandleMapping* handlemap,
1690     VkImageMemoryRequirementsInfo2* toMap)
1691 {
1692     (void)handlemap;
1693     (void)toMap;
1694     if (toMap->pNext)
1695     {
1696         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1697     }
1698     handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
1699 }
1700 
handlemap_VkImageSparseMemoryRequirementsInfo2(VulkanHandleMapping * handlemap,VkImageSparseMemoryRequirementsInfo2 * toMap)1701 void handlemap_VkImageSparseMemoryRequirementsInfo2(
1702     VulkanHandleMapping* handlemap,
1703     VkImageSparseMemoryRequirementsInfo2* toMap)
1704 {
1705     (void)handlemap;
1706     (void)toMap;
1707     if (toMap->pNext)
1708     {
1709         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1710     }
1711     handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
1712 }
1713 
handlemap_VkMemoryRequirements2(VulkanHandleMapping * handlemap,VkMemoryRequirements2 * toMap)1714 void handlemap_VkMemoryRequirements2(
1715     VulkanHandleMapping* handlemap,
1716     VkMemoryRequirements2* toMap)
1717 {
1718     (void)handlemap;
1719     (void)toMap;
1720     if (toMap->pNext)
1721     {
1722         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1723     }
1724     handlemap_VkMemoryRequirements(handlemap, (VkMemoryRequirements*)(&toMap->memoryRequirements));
1725 }
1726 
handlemap_VkSparseImageMemoryRequirements2(VulkanHandleMapping * handlemap,VkSparseImageMemoryRequirements2 * toMap)1727 void handlemap_VkSparseImageMemoryRequirements2(
1728     VulkanHandleMapping* handlemap,
1729     VkSparseImageMemoryRequirements2* toMap)
1730 {
1731     (void)handlemap;
1732     (void)toMap;
1733     if (toMap->pNext)
1734     {
1735         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1736     }
1737     handlemap_VkSparseImageMemoryRequirements(handlemap, (VkSparseImageMemoryRequirements*)(&toMap->memoryRequirements));
1738 }
1739 
handlemap_VkPhysicalDeviceFeatures2(VulkanHandleMapping * handlemap,VkPhysicalDeviceFeatures2 * toMap)1740 void handlemap_VkPhysicalDeviceFeatures2(
1741     VulkanHandleMapping* handlemap,
1742     VkPhysicalDeviceFeatures2* toMap)
1743 {
1744     (void)handlemap;
1745     (void)toMap;
1746     if (toMap->pNext)
1747     {
1748         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1749     }
1750     handlemap_VkPhysicalDeviceFeatures(handlemap, (VkPhysicalDeviceFeatures*)(&toMap->features));
1751 }
1752 
handlemap_VkPhysicalDeviceProperties2(VulkanHandleMapping * handlemap,VkPhysicalDeviceProperties2 * toMap)1753 void handlemap_VkPhysicalDeviceProperties2(
1754     VulkanHandleMapping* handlemap,
1755     VkPhysicalDeviceProperties2* toMap)
1756 {
1757     (void)handlemap;
1758     (void)toMap;
1759     if (toMap->pNext)
1760     {
1761         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1762     }
1763     handlemap_VkPhysicalDeviceProperties(handlemap, (VkPhysicalDeviceProperties*)(&toMap->properties));
1764 }
1765 
handlemap_VkFormatProperties2(VulkanHandleMapping * handlemap,VkFormatProperties2 * toMap)1766 void handlemap_VkFormatProperties2(
1767     VulkanHandleMapping* handlemap,
1768     VkFormatProperties2* toMap)
1769 {
1770     (void)handlemap;
1771     (void)toMap;
1772     if (toMap->pNext)
1773     {
1774         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1775     }
1776     handlemap_VkFormatProperties(handlemap, (VkFormatProperties*)(&toMap->formatProperties));
1777 }
1778 
handlemap_VkImageFormatProperties2(VulkanHandleMapping * handlemap,VkImageFormatProperties2 * toMap)1779 void handlemap_VkImageFormatProperties2(
1780     VulkanHandleMapping* handlemap,
1781     VkImageFormatProperties2* toMap)
1782 {
1783     (void)handlemap;
1784     (void)toMap;
1785     if (toMap->pNext)
1786     {
1787         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1788     }
1789     handlemap_VkImageFormatProperties(handlemap, (VkImageFormatProperties*)(&toMap->imageFormatProperties));
1790 }
1791 
handlemap_VkPhysicalDeviceImageFormatInfo2(VulkanHandleMapping * handlemap,VkPhysicalDeviceImageFormatInfo2 * toMap)1792 void handlemap_VkPhysicalDeviceImageFormatInfo2(
1793     VulkanHandleMapping* handlemap,
1794     VkPhysicalDeviceImageFormatInfo2* toMap)
1795 {
1796     (void)handlemap;
1797     (void)toMap;
1798     if (toMap->pNext)
1799     {
1800         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1801     }
1802 }
1803 
handlemap_VkQueueFamilyProperties2(VulkanHandleMapping * handlemap,VkQueueFamilyProperties2 * toMap)1804 void handlemap_VkQueueFamilyProperties2(
1805     VulkanHandleMapping* handlemap,
1806     VkQueueFamilyProperties2* toMap)
1807 {
1808     (void)handlemap;
1809     (void)toMap;
1810     if (toMap->pNext)
1811     {
1812         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1813     }
1814     handlemap_VkQueueFamilyProperties(handlemap, (VkQueueFamilyProperties*)(&toMap->queueFamilyProperties));
1815 }
1816 
handlemap_VkPhysicalDeviceMemoryProperties2(VulkanHandleMapping * handlemap,VkPhysicalDeviceMemoryProperties2 * toMap)1817 void handlemap_VkPhysicalDeviceMemoryProperties2(
1818     VulkanHandleMapping* handlemap,
1819     VkPhysicalDeviceMemoryProperties2* toMap)
1820 {
1821     (void)handlemap;
1822     (void)toMap;
1823     if (toMap->pNext)
1824     {
1825         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1826     }
1827     handlemap_VkPhysicalDeviceMemoryProperties(handlemap, (VkPhysicalDeviceMemoryProperties*)(&toMap->memoryProperties));
1828 }
1829 
handlemap_VkSparseImageFormatProperties2(VulkanHandleMapping * handlemap,VkSparseImageFormatProperties2 * toMap)1830 void handlemap_VkSparseImageFormatProperties2(
1831     VulkanHandleMapping* handlemap,
1832     VkSparseImageFormatProperties2* toMap)
1833 {
1834     (void)handlemap;
1835     (void)toMap;
1836     if (toMap->pNext)
1837     {
1838         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1839     }
1840     handlemap_VkSparseImageFormatProperties(handlemap, (VkSparseImageFormatProperties*)(&toMap->properties));
1841 }
1842 
handlemap_VkPhysicalDeviceSparseImageFormatInfo2(VulkanHandleMapping * handlemap,VkPhysicalDeviceSparseImageFormatInfo2 * toMap)1843 void handlemap_VkPhysicalDeviceSparseImageFormatInfo2(
1844     VulkanHandleMapping* handlemap,
1845     VkPhysicalDeviceSparseImageFormatInfo2* toMap)
1846 {
1847     (void)handlemap;
1848     (void)toMap;
1849     if (toMap->pNext)
1850     {
1851         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1852     }
1853 }
1854 
handlemap_VkPhysicalDevicePointClippingProperties(VulkanHandleMapping * handlemap,VkPhysicalDevicePointClippingProperties * toMap)1855 void handlemap_VkPhysicalDevicePointClippingProperties(
1856     VulkanHandleMapping* handlemap,
1857     VkPhysicalDevicePointClippingProperties* toMap)
1858 {
1859     (void)handlemap;
1860     (void)toMap;
1861     if (toMap->pNext)
1862     {
1863         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1864     }
1865 }
1866 
handlemap_VkInputAttachmentAspectReference(VulkanHandleMapping * handlemap,VkInputAttachmentAspectReference * toMap)1867 void handlemap_VkInputAttachmentAspectReference(
1868     VulkanHandleMapping* handlemap,
1869     VkInputAttachmentAspectReference* toMap)
1870 {
1871     (void)handlemap;
1872     (void)toMap;
1873 }
1874 
handlemap_VkRenderPassInputAttachmentAspectCreateInfo(VulkanHandleMapping * handlemap,VkRenderPassInputAttachmentAspectCreateInfo * toMap)1875 void handlemap_VkRenderPassInputAttachmentAspectCreateInfo(
1876     VulkanHandleMapping* handlemap,
1877     VkRenderPassInputAttachmentAspectCreateInfo* toMap)
1878 {
1879     (void)handlemap;
1880     (void)toMap;
1881     if (toMap->pNext)
1882     {
1883         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1884     }
1885     if (toMap->pAspectReferences)
1886     {
1887         for (uint32_t i = 0; i < (uint32_t)toMap->aspectReferenceCount; ++i)
1888         {
1889             handlemap_VkInputAttachmentAspectReference(handlemap, (VkInputAttachmentAspectReference*)(toMap->pAspectReferences + i));
1890         }
1891     }
1892 }
1893 
handlemap_VkImageViewUsageCreateInfo(VulkanHandleMapping * handlemap,VkImageViewUsageCreateInfo * toMap)1894 void handlemap_VkImageViewUsageCreateInfo(
1895     VulkanHandleMapping* handlemap,
1896     VkImageViewUsageCreateInfo* toMap)
1897 {
1898     (void)handlemap;
1899     (void)toMap;
1900     if (toMap->pNext)
1901     {
1902         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1903     }
1904 }
1905 
handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(VulkanHandleMapping * handlemap,VkPipelineTessellationDomainOriginStateCreateInfo * toMap)1906 void handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(
1907     VulkanHandleMapping* handlemap,
1908     VkPipelineTessellationDomainOriginStateCreateInfo* toMap)
1909 {
1910     (void)handlemap;
1911     (void)toMap;
1912     if (toMap->pNext)
1913     {
1914         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1915     }
1916 }
1917 
handlemap_VkRenderPassMultiviewCreateInfo(VulkanHandleMapping * handlemap,VkRenderPassMultiviewCreateInfo * toMap)1918 void handlemap_VkRenderPassMultiviewCreateInfo(
1919     VulkanHandleMapping* handlemap,
1920     VkRenderPassMultiviewCreateInfo* toMap)
1921 {
1922     (void)handlemap;
1923     (void)toMap;
1924     if (toMap->pNext)
1925     {
1926         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1927     }
1928 }
1929 
handlemap_VkPhysicalDeviceMultiviewFeatures(VulkanHandleMapping * handlemap,VkPhysicalDeviceMultiviewFeatures * toMap)1930 void handlemap_VkPhysicalDeviceMultiviewFeatures(
1931     VulkanHandleMapping* handlemap,
1932     VkPhysicalDeviceMultiviewFeatures* toMap)
1933 {
1934     (void)handlemap;
1935     (void)toMap;
1936     if (toMap->pNext)
1937     {
1938         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1939     }
1940 }
1941 
handlemap_VkPhysicalDeviceMultiviewProperties(VulkanHandleMapping * handlemap,VkPhysicalDeviceMultiviewProperties * toMap)1942 void handlemap_VkPhysicalDeviceMultiviewProperties(
1943     VulkanHandleMapping* handlemap,
1944     VkPhysicalDeviceMultiviewProperties* toMap)
1945 {
1946     (void)handlemap;
1947     (void)toMap;
1948     if (toMap->pNext)
1949     {
1950         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1951     }
1952 }
1953 
handlemap_VkPhysicalDeviceVariablePointerFeatures(VulkanHandleMapping * handlemap,VkPhysicalDeviceVariablePointerFeatures * toMap)1954 void handlemap_VkPhysicalDeviceVariablePointerFeatures(
1955     VulkanHandleMapping* handlemap,
1956     VkPhysicalDeviceVariablePointerFeatures* toMap)
1957 {
1958     (void)handlemap;
1959     (void)toMap;
1960     if (toMap->pNext)
1961     {
1962         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1963     }
1964 }
1965 
handlemap_VkPhysicalDeviceProtectedMemoryFeatures(VulkanHandleMapping * handlemap,VkPhysicalDeviceProtectedMemoryFeatures * toMap)1966 void handlemap_VkPhysicalDeviceProtectedMemoryFeatures(
1967     VulkanHandleMapping* handlemap,
1968     VkPhysicalDeviceProtectedMemoryFeatures* toMap)
1969 {
1970     (void)handlemap;
1971     (void)toMap;
1972     if (toMap->pNext)
1973     {
1974         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1975     }
1976 }
1977 
handlemap_VkPhysicalDeviceProtectedMemoryProperties(VulkanHandleMapping * handlemap,VkPhysicalDeviceProtectedMemoryProperties * toMap)1978 void handlemap_VkPhysicalDeviceProtectedMemoryProperties(
1979     VulkanHandleMapping* handlemap,
1980     VkPhysicalDeviceProtectedMemoryProperties* toMap)
1981 {
1982     (void)handlemap;
1983     (void)toMap;
1984     if (toMap->pNext)
1985     {
1986         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1987     }
1988 }
1989 
handlemap_VkDeviceQueueInfo2(VulkanHandleMapping * handlemap,VkDeviceQueueInfo2 * toMap)1990 void handlemap_VkDeviceQueueInfo2(
1991     VulkanHandleMapping* handlemap,
1992     VkDeviceQueueInfo2* toMap)
1993 {
1994     (void)handlemap;
1995     (void)toMap;
1996     if (toMap->pNext)
1997     {
1998         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
1999     }
2000 }
2001 
handlemap_VkProtectedSubmitInfo(VulkanHandleMapping * handlemap,VkProtectedSubmitInfo * toMap)2002 void handlemap_VkProtectedSubmitInfo(
2003     VulkanHandleMapping* handlemap,
2004     VkProtectedSubmitInfo* toMap)
2005 {
2006     (void)handlemap;
2007     (void)toMap;
2008     if (toMap->pNext)
2009     {
2010         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2011     }
2012 }
2013 
handlemap_VkSamplerYcbcrConversionCreateInfo(VulkanHandleMapping * handlemap,VkSamplerYcbcrConversionCreateInfo * toMap)2014 void handlemap_VkSamplerYcbcrConversionCreateInfo(
2015     VulkanHandleMapping* handlemap,
2016     VkSamplerYcbcrConversionCreateInfo* toMap)
2017 {
2018     (void)handlemap;
2019     (void)toMap;
2020     if (toMap->pNext)
2021     {
2022         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2023     }
2024     handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->components));
2025 }
2026 
handlemap_VkSamplerYcbcrConversionInfo(VulkanHandleMapping * handlemap,VkSamplerYcbcrConversionInfo * toMap)2027 void handlemap_VkSamplerYcbcrConversionInfo(
2028     VulkanHandleMapping* handlemap,
2029     VkSamplerYcbcrConversionInfo* toMap)
2030 {
2031     (void)handlemap;
2032     (void)toMap;
2033     if (toMap->pNext)
2034     {
2035         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2036     }
2037     handlemap->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&toMap->conversion);
2038 }
2039 
handlemap_VkBindImagePlaneMemoryInfo(VulkanHandleMapping * handlemap,VkBindImagePlaneMemoryInfo * toMap)2040 void handlemap_VkBindImagePlaneMemoryInfo(
2041     VulkanHandleMapping* handlemap,
2042     VkBindImagePlaneMemoryInfo* toMap)
2043 {
2044     (void)handlemap;
2045     (void)toMap;
2046     if (toMap->pNext)
2047     {
2048         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2049     }
2050 }
2051 
handlemap_VkImagePlaneMemoryRequirementsInfo(VulkanHandleMapping * handlemap,VkImagePlaneMemoryRequirementsInfo * toMap)2052 void handlemap_VkImagePlaneMemoryRequirementsInfo(
2053     VulkanHandleMapping* handlemap,
2054     VkImagePlaneMemoryRequirementsInfo* toMap)
2055 {
2056     (void)handlemap;
2057     (void)toMap;
2058     if (toMap->pNext)
2059     {
2060         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2061     }
2062 }
2063 
handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(VulkanHandleMapping * handlemap,VkPhysicalDeviceSamplerYcbcrConversionFeatures * toMap)2064 void handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
2065     VulkanHandleMapping* handlemap,
2066     VkPhysicalDeviceSamplerYcbcrConversionFeatures* toMap)
2067 {
2068     (void)handlemap;
2069     (void)toMap;
2070     if (toMap->pNext)
2071     {
2072         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2073     }
2074 }
2075 
handlemap_VkSamplerYcbcrConversionImageFormatProperties(VulkanHandleMapping * handlemap,VkSamplerYcbcrConversionImageFormatProperties * toMap)2076 void handlemap_VkSamplerYcbcrConversionImageFormatProperties(
2077     VulkanHandleMapping* handlemap,
2078     VkSamplerYcbcrConversionImageFormatProperties* toMap)
2079 {
2080     (void)handlemap;
2081     (void)toMap;
2082     if (toMap->pNext)
2083     {
2084         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2085     }
2086 }
2087 
handlemap_VkDescriptorUpdateTemplateEntry(VulkanHandleMapping * handlemap,VkDescriptorUpdateTemplateEntry * toMap)2088 void handlemap_VkDescriptorUpdateTemplateEntry(
2089     VulkanHandleMapping* handlemap,
2090     VkDescriptorUpdateTemplateEntry* toMap)
2091 {
2092     (void)handlemap;
2093     (void)toMap;
2094 }
2095 
handlemap_VkDescriptorUpdateTemplateCreateInfo(VulkanHandleMapping * handlemap,VkDescriptorUpdateTemplateCreateInfo * toMap)2096 void handlemap_VkDescriptorUpdateTemplateCreateInfo(
2097     VulkanHandleMapping* handlemap,
2098     VkDescriptorUpdateTemplateCreateInfo* toMap)
2099 {
2100     (void)handlemap;
2101     (void)toMap;
2102     if (toMap->pNext)
2103     {
2104         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2105     }
2106     if (toMap->pDescriptorUpdateEntries)
2107     {
2108         for (uint32_t i = 0; i < (uint32_t)toMap->descriptorUpdateEntryCount; ++i)
2109         {
2110             handlemap_VkDescriptorUpdateTemplateEntry(handlemap, (VkDescriptorUpdateTemplateEntry*)(toMap->pDescriptorUpdateEntries + i));
2111         }
2112     }
2113     handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)&toMap->descriptorSetLayout);
2114     handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->pipelineLayout);
2115 }
2116 
handlemap_VkExternalMemoryProperties(VulkanHandleMapping * handlemap,VkExternalMemoryProperties * toMap)2117 void handlemap_VkExternalMemoryProperties(
2118     VulkanHandleMapping* handlemap,
2119     VkExternalMemoryProperties* toMap)
2120 {
2121     (void)handlemap;
2122     (void)toMap;
2123 }
2124 
handlemap_VkPhysicalDeviceExternalImageFormatInfo(VulkanHandleMapping * handlemap,VkPhysicalDeviceExternalImageFormatInfo * toMap)2125 void handlemap_VkPhysicalDeviceExternalImageFormatInfo(
2126     VulkanHandleMapping* handlemap,
2127     VkPhysicalDeviceExternalImageFormatInfo* toMap)
2128 {
2129     (void)handlemap;
2130     (void)toMap;
2131     if (toMap->pNext)
2132     {
2133         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2134     }
2135 }
2136 
handlemap_VkExternalImageFormatProperties(VulkanHandleMapping * handlemap,VkExternalImageFormatProperties * toMap)2137 void handlemap_VkExternalImageFormatProperties(
2138     VulkanHandleMapping* handlemap,
2139     VkExternalImageFormatProperties* toMap)
2140 {
2141     (void)handlemap;
2142     (void)toMap;
2143     if (toMap->pNext)
2144     {
2145         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2146     }
2147     handlemap_VkExternalMemoryProperties(handlemap, (VkExternalMemoryProperties*)(&toMap->externalMemoryProperties));
2148 }
2149 
handlemap_VkPhysicalDeviceExternalBufferInfo(VulkanHandleMapping * handlemap,VkPhysicalDeviceExternalBufferInfo * toMap)2150 void handlemap_VkPhysicalDeviceExternalBufferInfo(
2151     VulkanHandleMapping* handlemap,
2152     VkPhysicalDeviceExternalBufferInfo* toMap)
2153 {
2154     (void)handlemap;
2155     (void)toMap;
2156     if (toMap->pNext)
2157     {
2158         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2159     }
2160 }
2161 
handlemap_VkExternalBufferProperties(VulkanHandleMapping * handlemap,VkExternalBufferProperties * toMap)2162 void handlemap_VkExternalBufferProperties(
2163     VulkanHandleMapping* handlemap,
2164     VkExternalBufferProperties* toMap)
2165 {
2166     (void)handlemap;
2167     (void)toMap;
2168     if (toMap->pNext)
2169     {
2170         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2171     }
2172     handlemap_VkExternalMemoryProperties(handlemap, (VkExternalMemoryProperties*)(&toMap->externalMemoryProperties));
2173 }
2174 
handlemap_VkPhysicalDeviceIDProperties(VulkanHandleMapping * handlemap,VkPhysicalDeviceIDProperties * toMap)2175 void handlemap_VkPhysicalDeviceIDProperties(
2176     VulkanHandleMapping* handlemap,
2177     VkPhysicalDeviceIDProperties* toMap)
2178 {
2179     (void)handlemap;
2180     (void)toMap;
2181     if (toMap->pNext)
2182     {
2183         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2184     }
2185 }
2186 
handlemap_VkExternalMemoryImageCreateInfo(VulkanHandleMapping * handlemap,VkExternalMemoryImageCreateInfo * toMap)2187 void handlemap_VkExternalMemoryImageCreateInfo(
2188     VulkanHandleMapping* handlemap,
2189     VkExternalMemoryImageCreateInfo* toMap)
2190 {
2191     (void)handlemap;
2192     (void)toMap;
2193     if (toMap->pNext)
2194     {
2195         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2196     }
2197 }
2198 
handlemap_VkExternalMemoryBufferCreateInfo(VulkanHandleMapping * handlemap,VkExternalMemoryBufferCreateInfo * toMap)2199 void handlemap_VkExternalMemoryBufferCreateInfo(
2200     VulkanHandleMapping* handlemap,
2201     VkExternalMemoryBufferCreateInfo* toMap)
2202 {
2203     (void)handlemap;
2204     (void)toMap;
2205     if (toMap->pNext)
2206     {
2207         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2208     }
2209 }
2210 
handlemap_VkExportMemoryAllocateInfo(VulkanHandleMapping * handlemap,VkExportMemoryAllocateInfo * toMap)2211 void handlemap_VkExportMemoryAllocateInfo(
2212     VulkanHandleMapping* handlemap,
2213     VkExportMemoryAllocateInfo* toMap)
2214 {
2215     (void)handlemap;
2216     (void)toMap;
2217     if (toMap->pNext)
2218     {
2219         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2220     }
2221 }
2222 
handlemap_VkPhysicalDeviceExternalFenceInfo(VulkanHandleMapping * handlemap,VkPhysicalDeviceExternalFenceInfo * toMap)2223 void handlemap_VkPhysicalDeviceExternalFenceInfo(
2224     VulkanHandleMapping* handlemap,
2225     VkPhysicalDeviceExternalFenceInfo* toMap)
2226 {
2227     (void)handlemap;
2228     (void)toMap;
2229     if (toMap->pNext)
2230     {
2231         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2232     }
2233 }
2234 
handlemap_VkExternalFenceProperties(VulkanHandleMapping * handlemap,VkExternalFenceProperties * toMap)2235 void handlemap_VkExternalFenceProperties(
2236     VulkanHandleMapping* handlemap,
2237     VkExternalFenceProperties* toMap)
2238 {
2239     (void)handlemap;
2240     (void)toMap;
2241     if (toMap->pNext)
2242     {
2243         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2244     }
2245 }
2246 
handlemap_VkExportFenceCreateInfo(VulkanHandleMapping * handlemap,VkExportFenceCreateInfo * toMap)2247 void handlemap_VkExportFenceCreateInfo(
2248     VulkanHandleMapping* handlemap,
2249     VkExportFenceCreateInfo* toMap)
2250 {
2251     (void)handlemap;
2252     (void)toMap;
2253     if (toMap->pNext)
2254     {
2255         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2256     }
2257 }
2258 
handlemap_VkExportSemaphoreCreateInfo(VulkanHandleMapping * handlemap,VkExportSemaphoreCreateInfo * toMap)2259 void handlemap_VkExportSemaphoreCreateInfo(
2260     VulkanHandleMapping* handlemap,
2261     VkExportSemaphoreCreateInfo* toMap)
2262 {
2263     (void)handlemap;
2264     (void)toMap;
2265     if (toMap->pNext)
2266     {
2267         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2268     }
2269 }
2270 
handlemap_VkPhysicalDeviceExternalSemaphoreInfo(VulkanHandleMapping * handlemap,VkPhysicalDeviceExternalSemaphoreInfo * toMap)2271 void handlemap_VkPhysicalDeviceExternalSemaphoreInfo(
2272     VulkanHandleMapping* handlemap,
2273     VkPhysicalDeviceExternalSemaphoreInfo* toMap)
2274 {
2275     (void)handlemap;
2276     (void)toMap;
2277     if (toMap->pNext)
2278     {
2279         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2280     }
2281 }
2282 
handlemap_VkExternalSemaphoreProperties(VulkanHandleMapping * handlemap,VkExternalSemaphoreProperties * toMap)2283 void handlemap_VkExternalSemaphoreProperties(
2284     VulkanHandleMapping* handlemap,
2285     VkExternalSemaphoreProperties* toMap)
2286 {
2287     (void)handlemap;
2288     (void)toMap;
2289     if (toMap->pNext)
2290     {
2291         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2292     }
2293 }
2294 
handlemap_VkPhysicalDeviceMaintenance3Properties(VulkanHandleMapping * handlemap,VkPhysicalDeviceMaintenance3Properties * toMap)2295 void handlemap_VkPhysicalDeviceMaintenance3Properties(
2296     VulkanHandleMapping* handlemap,
2297     VkPhysicalDeviceMaintenance3Properties* toMap)
2298 {
2299     (void)handlemap;
2300     (void)toMap;
2301     if (toMap->pNext)
2302     {
2303         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2304     }
2305 }
2306 
handlemap_VkDescriptorSetLayoutSupport(VulkanHandleMapping * handlemap,VkDescriptorSetLayoutSupport * toMap)2307 void handlemap_VkDescriptorSetLayoutSupport(
2308     VulkanHandleMapping* handlemap,
2309     VkDescriptorSetLayoutSupport* toMap)
2310 {
2311     (void)handlemap;
2312     (void)toMap;
2313     if (toMap->pNext)
2314     {
2315         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2316     }
2317 }
2318 
handlemap_VkPhysicalDeviceShaderDrawParameterFeatures(VulkanHandleMapping * handlemap,VkPhysicalDeviceShaderDrawParameterFeatures * toMap)2319 void handlemap_VkPhysicalDeviceShaderDrawParameterFeatures(
2320     VulkanHandleMapping* handlemap,
2321     VkPhysicalDeviceShaderDrawParameterFeatures* toMap)
2322 {
2323     (void)handlemap;
2324     (void)toMap;
2325     if (toMap->pNext)
2326     {
2327         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2328     }
2329 }
2330 
2331 #endif
2332 #ifdef VK_KHR_surface
handlemap_VkSurfaceCapabilitiesKHR(VulkanHandleMapping * handlemap,VkSurfaceCapabilitiesKHR * toMap)2333 void handlemap_VkSurfaceCapabilitiesKHR(
2334     VulkanHandleMapping* handlemap,
2335     VkSurfaceCapabilitiesKHR* toMap)
2336 {
2337     (void)handlemap;
2338     (void)toMap;
2339     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->currentExtent));
2340     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minImageExtent));
2341     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxImageExtent));
2342 }
2343 
handlemap_VkSurfaceFormatKHR(VulkanHandleMapping * handlemap,VkSurfaceFormatKHR * toMap)2344 void handlemap_VkSurfaceFormatKHR(
2345     VulkanHandleMapping* handlemap,
2346     VkSurfaceFormatKHR* toMap)
2347 {
2348     (void)handlemap;
2349     (void)toMap;
2350 }
2351 
2352 #endif
2353 #ifdef VK_KHR_swapchain
handlemap_VkSwapchainCreateInfoKHR(VulkanHandleMapping * handlemap,VkSwapchainCreateInfoKHR * toMap)2354 void handlemap_VkSwapchainCreateInfoKHR(
2355     VulkanHandleMapping* handlemap,
2356     VkSwapchainCreateInfoKHR* toMap)
2357 {
2358     (void)handlemap;
2359     (void)toMap;
2360     if (toMap->pNext)
2361     {
2362         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2363     }
2364     handlemap->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&toMap->surface);
2365     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->imageExtent));
2366     handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->oldSwapchain);
2367 }
2368 
handlemap_VkPresentInfoKHR(VulkanHandleMapping * handlemap,VkPresentInfoKHR * toMap)2369 void handlemap_VkPresentInfoKHR(
2370     VulkanHandleMapping* handlemap,
2371     VkPresentInfoKHR* toMap)
2372 {
2373     (void)handlemap;
2374     (void)toMap;
2375     if (toMap->pNext)
2376     {
2377         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2378     }
2379     if (toMap->pWaitSemaphores)
2380     {
2381         handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
2382     }
2383     if (toMap->pSwapchains)
2384     {
2385         handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)toMap->pSwapchains, toMap->swapchainCount);
2386     }
2387 }
2388 
handlemap_VkImageSwapchainCreateInfoKHR(VulkanHandleMapping * handlemap,VkImageSwapchainCreateInfoKHR * toMap)2389 void handlemap_VkImageSwapchainCreateInfoKHR(
2390     VulkanHandleMapping* handlemap,
2391     VkImageSwapchainCreateInfoKHR* toMap)
2392 {
2393     (void)handlemap;
2394     (void)toMap;
2395     if (toMap->pNext)
2396     {
2397         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2398     }
2399     handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
2400 }
2401 
handlemap_VkBindImageMemorySwapchainInfoKHR(VulkanHandleMapping * handlemap,VkBindImageMemorySwapchainInfoKHR * toMap)2402 void handlemap_VkBindImageMemorySwapchainInfoKHR(
2403     VulkanHandleMapping* handlemap,
2404     VkBindImageMemorySwapchainInfoKHR* toMap)
2405 {
2406     (void)handlemap;
2407     (void)toMap;
2408     if (toMap->pNext)
2409     {
2410         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2411     }
2412     handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
2413 }
2414 
handlemap_VkAcquireNextImageInfoKHR(VulkanHandleMapping * handlemap,VkAcquireNextImageInfoKHR * toMap)2415 void handlemap_VkAcquireNextImageInfoKHR(
2416     VulkanHandleMapping* handlemap,
2417     VkAcquireNextImageInfoKHR* toMap)
2418 {
2419     (void)handlemap;
2420     (void)toMap;
2421     if (toMap->pNext)
2422     {
2423         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2424     }
2425     handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
2426     handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
2427     handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
2428 }
2429 
handlemap_VkDeviceGroupPresentCapabilitiesKHR(VulkanHandleMapping * handlemap,VkDeviceGroupPresentCapabilitiesKHR * toMap)2430 void handlemap_VkDeviceGroupPresentCapabilitiesKHR(
2431     VulkanHandleMapping* handlemap,
2432     VkDeviceGroupPresentCapabilitiesKHR* toMap)
2433 {
2434     (void)handlemap;
2435     (void)toMap;
2436     if (toMap->pNext)
2437     {
2438         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2439     }
2440 }
2441 
handlemap_VkDeviceGroupPresentInfoKHR(VulkanHandleMapping * handlemap,VkDeviceGroupPresentInfoKHR * toMap)2442 void handlemap_VkDeviceGroupPresentInfoKHR(
2443     VulkanHandleMapping* handlemap,
2444     VkDeviceGroupPresentInfoKHR* toMap)
2445 {
2446     (void)handlemap;
2447     (void)toMap;
2448     if (toMap->pNext)
2449     {
2450         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2451     }
2452 }
2453 
handlemap_VkDeviceGroupSwapchainCreateInfoKHR(VulkanHandleMapping * handlemap,VkDeviceGroupSwapchainCreateInfoKHR * toMap)2454 void handlemap_VkDeviceGroupSwapchainCreateInfoKHR(
2455     VulkanHandleMapping* handlemap,
2456     VkDeviceGroupSwapchainCreateInfoKHR* toMap)
2457 {
2458     (void)handlemap;
2459     (void)toMap;
2460     if (toMap->pNext)
2461     {
2462         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2463     }
2464 }
2465 
2466 #endif
2467 #ifdef VK_KHR_display
handlemap_VkDisplayPropertiesKHR(VulkanHandleMapping * handlemap,VkDisplayPropertiesKHR * toMap)2468 void handlemap_VkDisplayPropertiesKHR(
2469     VulkanHandleMapping* handlemap,
2470     VkDisplayPropertiesKHR* toMap)
2471 {
2472     (void)handlemap;
2473     (void)toMap;
2474     handlemap->mapHandles_VkDisplayKHR((VkDisplayKHR*)&toMap->display);
2475     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->physicalDimensions));
2476     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->physicalResolution));
2477 }
2478 
handlemap_VkDisplayModeParametersKHR(VulkanHandleMapping * handlemap,VkDisplayModeParametersKHR * toMap)2479 void handlemap_VkDisplayModeParametersKHR(
2480     VulkanHandleMapping* handlemap,
2481     VkDisplayModeParametersKHR* toMap)
2482 {
2483     (void)handlemap;
2484     (void)toMap;
2485     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->visibleRegion));
2486 }
2487 
handlemap_VkDisplayModePropertiesKHR(VulkanHandleMapping * handlemap,VkDisplayModePropertiesKHR * toMap)2488 void handlemap_VkDisplayModePropertiesKHR(
2489     VulkanHandleMapping* handlemap,
2490     VkDisplayModePropertiesKHR* toMap)
2491 {
2492     (void)handlemap;
2493     (void)toMap;
2494     handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->displayMode);
2495     handlemap_VkDisplayModeParametersKHR(handlemap, (VkDisplayModeParametersKHR*)(&toMap->parameters));
2496 }
2497 
handlemap_VkDisplayModeCreateInfoKHR(VulkanHandleMapping * handlemap,VkDisplayModeCreateInfoKHR * toMap)2498 void handlemap_VkDisplayModeCreateInfoKHR(
2499     VulkanHandleMapping* handlemap,
2500     VkDisplayModeCreateInfoKHR* toMap)
2501 {
2502     (void)handlemap;
2503     (void)toMap;
2504     if (toMap->pNext)
2505     {
2506         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2507     }
2508     handlemap_VkDisplayModeParametersKHR(handlemap, (VkDisplayModeParametersKHR*)(&toMap->parameters));
2509 }
2510 
handlemap_VkDisplayPlaneCapabilitiesKHR(VulkanHandleMapping * handlemap,VkDisplayPlaneCapabilitiesKHR * toMap)2511 void handlemap_VkDisplayPlaneCapabilitiesKHR(
2512     VulkanHandleMapping* handlemap,
2513     VkDisplayPlaneCapabilitiesKHR* toMap)
2514 {
2515     (void)handlemap;
2516     (void)toMap;
2517     handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->minSrcPosition));
2518     handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->maxSrcPosition));
2519     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minSrcExtent));
2520     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxSrcExtent));
2521     handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->minDstPosition));
2522     handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->maxDstPosition));
2523     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minDstExtent));
2524     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxDstExtent));
2525 }
2526 
handlemap_VkDisplayPlanePropertiesKHR(VulkanHandleMapping * handlemap,VkDisplayPlanePropertiesKHR * toMap)2527 void handlemap_VkDisplayPlanePropertiesKHR(
2528     VulkanHandleMapping* handlemap,
2529     VkDisplayPlanePropertiesKHR* toMap)
2530 {
2531     (void)handlemap;
2532     (void)toMap;
2533     handlemap->mapHandles_VkDisplayKHR((VkDisplayKHR*)&toMap->currentDisplay);
2534 }
2535 
handlemap_VkDisplaySurfaceCreateInfoKHR(VulkanHandleMapping * handlemap,VkDisplaySurfaceCreateInfoKHR * toMap)2536 void handlemap_VkDisplaySurfaceCreateInfoKHR(
2537     VulkanHandleMapping* handlemap,
2538     VkDisplaySurfaceCreateInfoKHR* toMap)
2539 {
2540     (void)handlemap;
2541     (void)toMap;
2542     if (toMap->pNext)
2543     {
2544         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2545     }
2546     handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->displayMode);
2547     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->imageExtent));
2548 }
2549 
2550 #endif
2551 #ifdef VK_KHR_display_swapchain
handlemap_VkDisplayPresentInfoKHR(VulkanHandleMapping * handlemap,VkDisplayPresentInfoKHR * toMap)2552 void handlemap_VkDisplayPresentInfoKHR(
2553     VulkanHandleMapping* handlemap,
2554     VkDisplayPresentInfoKHR* toMap)
2555 {
2556     (void)handlemap;
2557     (void)toMap;
2558     if (toMap->pNext)
2559     {
2560         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2561     }
2562     handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->srcRect));
2563     handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->dstRect));
2564 }
2565 
2566 #endif
2567 #ifdef VK_KHR_xlib_surface
handlemap_VkXlibSurfaceCreateInfoKHR(VulkanHandleMapping * handlemap,VkXlibSurfaceCreateInfoKHR * toMap)2568 void handlemap_VkXlibSurfaceCreateInfoKHR(
2569     VulkanHandleMapping* handlemap,
2570     VkXlibSurfaceCreateInfoKHR* toMap)
2571 {
2572     (void)handlemap;
2573     (void)toMap;
2574     if (toMap->pNext)
2575     {
2576         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2577     }
2578 }
2579 
2580 #endif
2581 #ifdef VK_KHR_xcb_surface
handlemap_VkXcbSurfaceCreateInfoKHR(VulkanHandleMapping * handlemap,VkXcbSurfaceCreateInfoKHR * toMap)2582 void handlemap_VkXcbSurfaceCreateInfoKHR(
2583     VulkanHandleMapping* handlemap,
2584     VkXcbSurfaceCreateInfoKHR* toMap)
2585 {
2586     (void)handlemap;
2587     (void)toMap;
2588     if (toMap->pNext)
2589     {
2590         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2591     }
2592 }
2593 
2594 #endif
2595 #ifdef VK_KHR_wayland_surface
handlemap_VkWaylandSurfaceCreateInfoKHR(VulkanHandleMapping * handlemap,VkWaylandSurfaceCreateInfoKHR * toMap)2596 void handlemap_VkWaylandSurfaceCreateInfoKHR(
2597     VulkanHandleMapping* handlemap,
2598     VkWaylandSurfaceCreateInfoKHR* toMap)
2599 {
2600     (void)handlemap;
2601     (void)toMap;
2602     if (toMap->pNext)
2603     {
2604         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2605     }
2606 }
2607 
2608 #endif
2609 #ifdef VK_KHR_mir_surface
handlemap_VkMirSurfaceCreateInfoKHR(VulkanHandleMapping * handlemap,VkMirSurfaceCreateInfoKHR * toMap)2610 void handlemap_VkMirSurfaceCreateInfoKHR(
2611     VulkanHandleMapping* handlemap,
2612     VkMirSurfaceCreateInfoKHR* toMap)
2613 {
2614     (void)handlemap;
2615     (void)toMap;
2616     if (toMap->pNext)
2617     {
2618         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2619     }
2620 }
2621 
2622 #endif
2623 #ifdef VK_KHR_android_surface
handlemap_VkAndroidSurfaceCreateInfoKHR(VulkanHandleMapping * handlemap,VkAndroidSurfaceCreateInfoKHR * toMap)2624 void handlemap_VkAndroidSurfaceCreateInfoKHR(
2625     VulkanHandleMapping* handlemap,
2626     VkAndroidSurfaceCreateInfoKHR* toMap)
2627 {
2628     (void)handlemap;
2629     (void)toMap;
2630     if (toMap->pNext)
2631     {
2632         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2633     }
2634 }
2635 
2636 #endif
2637 #ifdef VK_KHR_win32_surface
handlemap_VkWin32SurfaceCreateInfoKHR(VulkanHandleMapping * handlemap,VkWin32SurfaceCreateInfoKHR * toMap)2638 void handlemap_VkWin32SurfaceCreateInfoKHR(
2639     VulkanHandleMapping* handlemap,
2640     VkWin32SurfaceCreateInfoKHR* toMap)
2641 {
2642     (void)handlemap;
2643     (void)toMap;
2644     if (toMap->pNext)
2645     {
2646         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2647     }
2648 }
2649 
2650 #endif
2651 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
2652 #endif
2653 #ifdef VK_KHR_multiview
2654 #endif
2655 #ifdef VK_KHR_get_physical_device_properties2
2656 #endif
2657 #ifdef VK_KHR_device_group
2658 #endif
2659 #ifdef VK_KHR_shader_draw_parameters
2660 #endif
2661 #ifdef VK_KHR_maintenance1
2662 #endif
2663 #ifdef VK_KHR_device_group_creation
2664 #endif
2665 #ifdef VK_KHR_external_memory_capabilities
2666 #endif
2667 #ifdef VK_KHR_external_memory
2668 #endif
2669 #ifdef VK_KHR_external_memory_win32
handlemap_VkImportMemoryWin32HandleInfoKHR(VulkanHandleMapping * handlemap,VkImportMemoryWin32HandleInfoKHR * toMap)2670 void handlemap_VkImportMemoryWin32HandleInfoKHR(
2671     VulkanHandleMapping* handlemap,
2672     VkImportMemoryWin32HandleInfoKHR* toMap)
2673 {
2674     (void)handlemap;
2675     (void)toMap;
2676     if (toMap->pNext)
2677     {
2678         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2679     }
2680 }
2681 
handlemap_VkExportMemoryWin32HandleInfoKHR(VulkanHandleMapping * handlemap,VkExportMemoryWin32HandleInfoKHR * toMap)2682 void handlemap_VkExportMemoryWin32HandleInfoKHR(
2683     VulkanHandleMapping* handlemap,
2684     VkExportMemoryWin32HandleInfoKHR* toMap)
2685 {
2686     (void)handlemap;
2687     (void)toMap;
2688     if (toMap->pNext)
2689     {
2690         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2691     }
2692 }
2693 
handlemap_VkMemoryWin32HandlePropertiesKHR(VulkanHandleMapping * handlemap,VkMemoryWin32HandlePropertiesKHR * toMap)2694 void handlemap_VkMemoryWin32HandlePropertiesKHR(
2695     VulkanHandleMapping* handlemap,
2696     VkMemoryWin32HandlePropertiesKHR* toMap)
2697 {
2698     (void)handlemap;
2699     (void)toMap;
2700     if (toMap->pNext)
2701     {
2702         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2703     }
2704 }
2705 
handlemap_VkMemoryGetWin32HandleInfoKHR(VulkanHandleMapping * handlemap,VkMemoryGetWin32HandleInfoKHR * toMap)2706 void handlemap_VkMemoryGetWin32HandleInfoKHR(
2707     VulkanHandleMapping* handlemap,
2708     VkMemoryGetWin32HandleInfoKHR* toMap)
2709 {
2710     (void)handlemap;
2711     (void)toMap;
2712     if (toMap->pNext)
2713     {
2714         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2715     }
2716     handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
2717 }
2718 
2719 #endif
2720 #ifdef VK_KHR_external_memory_fd
handlemap_VkImportMemoryFdInfoKHR(VulkanHandleMapping * handlemap,VkImportMemoryFdInfoKHR * toMap)2721 void handlemap_VkImportMemoryFdInfoKHR(
2722     VulkanHandleMapping* handlemap,
2723     VkImportMemoryFdInfoKHR* toMap)
2724 {
2725     (void)handlemap;
2726     (void)toMap;
2727     if (toMap->pNext)
2728     {
2729         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2730     }
2731 }
2732 
handlemap_VkMemoryFdPropertiesKHR(VulkanHandleMapping * handlemap,VkMemoryFdPropertiesKHR * toMap)2733 void handlemap_VkMemoryFdPropertiesKHR(
2734     VulkanHandleMapping* handlemap,
2735     VkMemoryFdPropertiesKHR* toMap)
2736 {
2737     (void)handlemap;
2738     (void)toMap;
2739     if (toMap->pNext)
2740     {
2741         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2742     }
2743 }
2744 
handlemap_VkMemoryGetFdInfoKHR(VulkanHandleMapping * handlemap,VkMemoryGetFdInfoKHR * toMap)2745 void handlemap_VkMemoryGetFdInfoKHR(
2746     VulkanHandleMapping* handlemap,
2747     VkMemoryGetFdInfoKHR* toMap)
2748 {
2749     (void)handlemap;
2750     (void)toMap;
2751     if (toMap->pNext)
2752     {
2753         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2754     }
2755     handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
2756 }
2757 
2758 #endif
2759 #ifdef VK_KHR_win32_keyed_mutex
handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(VulkanHandleMapping * handlemap,VkWin32KeyedMutexAcquireReleaseInfoKHR * toMap)2760 void handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(
2761     VulkanHandleMapping* handlemap,
2762     VkWin32KeyedMutexAcquireReleaseInfoKHR* toMap)
2763 {
2764     (void)handlemap;
2765     (void)toMap;
2766     if (toMap->pNext)
2767     {
2768         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2769     }
2770     if (toMap->pAcquireSyncs)
2771     {
2772         handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pAcquireSyncs, toMap->acquireCount);
2773     }
2774     if (toMap->pReleaseSyncs)
2775     {
2776         handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pReleaseSyncs, toMap->releaseCount);
2777     }
2778 }
2779 
2780 #endif
2781 #ifdef VK_KHR_external_semaphore_capabilities
2782 #endif
2783 #ifdef VK_KHR_external_semaphore
2784 #endif
2785 #ifdef VK_KHR_external_semaphore_win32
handlemap_VkImportSemaphoreWin32HandleInfoKHR(VulkanHandleMapping * handlemap,VkImportSemaphoreWin32HandleInfoKHR * toMap)2786 void handlemap_VkImportSemaphoreWin32HandleInfoKHR(
2787     VulkanHandleMapping* handlemap,
2788     VkImportSemaphoreWin32HandleInfoKHR* toMap)
2789 {
2790     (void)handlemap;
2791     (void)toMap;
2792     if (toMap->pNext)
2793     {
2794         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2795     }
2796     handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
2797 }
2798 
handlemap_VkExportSemaphoreWin32HandleInfoKHR(VulkanHandleMapping * handlemap,VkExportSemaphoreWin32HandleInfoKHR * toMap)2799 void handlemap_VkExportSemaphoreWin32HandleInfoKHR(
2800     VulkanHandleMapping* handlemap,
2801     VkExportSemaphoreWin32HandleInfoKHR* toMap)
2802 {
2803     (void)handlemap;
2804     (void)toMap;
2805     if (toMap->pNext)
2806     {
2807         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2808     }
2809 }
2810 
handlemap_VkD3D12FenceSubmitInfoKHR(VulkanHandleMapping * handlemap,VkD3D12FenceSubmitInfoKHR * toMap)2811 void handlemap_VkD3D12FenceSubmitInfoKHR(
2812     VulkanHandleMapping* handlemap,
2813     VkD3D12FenceSubmitInfoKHR* toMap)
2814 {
2815     (void)handlemap;
2816     (void)toMap;
2817     if (toMap->pNext)
2818     {
2819         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2820     }
2821 }
2822 
handlemap_VkSemaphoreGetWin32HandleInfoKHR(VulkanHandleMapping * handlemap,VkSemaphoreGetWin32HandleInfoKHR * toMap)2823 void handlemap_VkSemaphoreGetWin32HandleInfoKHR(
2824     VulkanHandleMapping* handlemap,
2825     VkSemaphoreGetWin32HandleInfoKHR* toMap)
2826 {
2827     (void)handlemap;
2828     (void)toMap;
2829     if (toMap->pNext)
2830     {
2831         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2832     }
2833     handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
2834 }
2835 
2836 #endif
2837 #ifdef VK_KHR_external_semaphore_fd
handlemap_VkImportSemaphoreFdInfoKHR(VulkanHandleMapping * handlemap,VkImportSemaphoreFdInfoKHR * toMap)2838 void handlemap_VkImportSemaphoreFdInfoKHR(
2839     VulkanHandleMapping* handlemap,
2840     VkImportSemaphoreFdInfoKHR* toMap)
2841 {
2842     (void)handlemap;
2843     (void)toMap;
2844     if (toMap->pNext)
2845     {
2846         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2847     }
2848     handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
2849 }
2850 
handlemap_VkSemaphoreGetFdInfoKHR(VulkanHandleMapping * handlemap,VkSemaphoreGetFdInfoKHR * toMap)2851 void handlemap_VkSemaphoreGetFdInfoKHR(
2852     VulkanHandleMapping* handlemap,
2853     VkSemaphoreGetFdInfoKHR* toMap)
2854 {
2855     (void)handlemap;
2856     (void)toMap;
2857     if (toMap->pNext)
2858     {
2859         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2860     }
2861     handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
2862 }
2863 
2864 #endif
2865 #ifdef VK_KHR_push_descriptor
handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(VulkanHandleMapping * handlemap,VkPhysicalDevicePushDescriptorPropertiesKHR * toMap)2866 void handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(
2867     VulkanHandleMapping* handlemap,
2868     VkPhysicalDevicePushDescriptorPropertiesKHR* toMap)
2869 {
2870     (void)handlemap;
2871     (void)toMap;
2872     if (toMap->pNext)
2873     {
2874         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2875     }
2876 }
2877 
2878 #endif
2879 #ifdef VK_KHR_16bit_storage
2880 #endif
2881 #ifdef VK_KHR_incremental_present
handlemap_VkRectLayerKHR(VulkanHandleMapping * handlemap,VkRectLayerKHR * toMap)2882 void handlemap_VkRectLayerKHR(
2883     VulkanHandleMapping* handlemap,
2884     VkRectLayerKHR* toMap)
2885 {
2886     (void)handlemap;
2887     (void)toMap;
2888     handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->offset));
2889     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->extent));
2890 }
2891 
handlemap_VkPresentRegionKHR(VulkanHandleMapping * handlemap,VkPresentRegionKHR * toMap)2892 void handlemap_VkPresentRegionKHR(
2893     VulkanHandleMapping* handlemap,
2894     VkPresentRegionKHR* toMap)
2895 {
2896     (void)handlemap;
2897     (void)toMap;
2898     if (toMap->pRectangles)
2899     {
2900         for (uint32_t i = 0; i < (uint32_t)toMap->rectangleCount; ++i)
2901         {
2902             handlemap_VkRectLayerKHR(handlemap, (VkRectLayerKHR*)(toMap->pRectangles + i));
2903         }
2904     }
2905 }
2906 
handlemap_VkPresentRegionsKHR(VulkanHandleMapping * handlemap,VkPresentRegionsKHR * toMap)2907 void handlemap_VkPresentRegionsKHR(
2908     VulkanHandleMapping* handlemap,
2909     VkPresentRegionsKHR* toMap)
2910 {
2911     (void)handlemap;
2912     (void)toMap;
2913     if (toMap->pNext)
2914     {
2915         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2916     }
2917     if (toMap->pRegions)
2918     {
2919         for (uint32_t i = 0; i < (uint32_t)toMap->swapchainCount; ++i)
2920         {
2921             handlemap_VkPresentRegionKHR(handlemap, (VkPresentRegionKHR*)(toMap->pRegions + i));
2922         }
2923     }
2924 }
2925 
2926 #endif
2927 #ifdef VK_KHR_descriptor_update_template
2928 #endif
2929 #ifdef VK_KHR_create_renderpass2
handlemap_VkAttachmentDescription2KHR(VulkanHandleMapping * handlemap,VkAttachmentDescription2KHR * toMap)2930 void handlemap_VkAttachmentDescription2KHR(
2931     VulkanHandleMapping* handlemap,
2932     VkAttachmentDescription2KHR* toMap)
2933 {
2934     (void)handlemap;
2935     (void)toMap;
2936     if (toMap->pNext)
2937     {
2938         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2939     }
2940 }
2941 
handlemap_VkAttachmentReference2KHR(VulkanHandleMapping * handlemap,VkAttachmentReference2KHR * toMap)2942 void handlemap_VkAttachmentReference2KHR(
2943     VulkanHandleMapping* handlemap,
2944     VkAttachmentReference2KHR* toMap)
2945 {
2946     (void)handlemap;
2947     (void)toMap;
2948     if (toMap->pNext)
2949     {
2950         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2951     }
2952 }
2953 
handlemap_VkSubpassDescription2KHR(VulkanHandleMapping * handlemap,VkSubpassDescription2KHR * toMap)2954 void handlemap_VkSubpassDescription2KHR(
2955     VulkanHandleMapping* handlemap,
2956     VkSubpassDescription2KHR* toMap)
2957 {
2958     (void)handlemap;
2959     (void)toMap;
2960     if (toMap->pNext)
2961     {
2962         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
2963     }
2964     if (toMap->pInputAttachments)
2965     {
2966         for (uint32_t i = 0; i < (uint32_t)toMap->inputAttachmentCount; ++i)
2967         {
2968             handlemap_VkAttachmentReference2KHR(handlemap, (VkAttachmentReference2KHR*)(toMap->pInputAttachments + i));
2969         }
2970     }
2971     if (toMap->pColorAttachments)
2972     {
2973         for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
2974         {
2975             handlemap_VkAttachmentReference2KHR(handlemap, (VkAttachmentReference2KHR*)(toMap->pColorAttachments + i));
2976         }
2977     }
2978     if (toMap->pResolveAttachments)
2979     {
2980         for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
2981         {
2982             handlemap_VkAttachmentReference2KHR(handlemap, (VkAttachmentReference2KHR*)(toMap->pResolveAttachments + i));
2983         }
2984     }
2985     if (toMap->pDepthStencilAttachment)
2986     {
2987         handlemap_VkAttachmentReference2KHR(handlemap, (VkAttachmentReference2KHR*)(toMap->pDepthStencilAttachment));
2988     }
2989 }
2990 
handlemap_VkSubpassDependency2KHR(VulkanHandleMapping * handlemap,VkSubpassDependency2KHR * toMap)2991 void handlemap_VkSubpassDependency2KHR(
2992     VulkanHandleMapping* handlemap,
2993     VkSubpassDependency2KHR* toMap)
2994 {
2995     (void)handlemap;
2996     (void)toMap;
2997     if (toMap->pNext)
2998     {
2999         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3000     }
3001 }
3002 
handlemap_VkRenderPassCreateInfo2KHR(VulkanHandleMapping * handlemap,VkRenderPassCreateInfo2KHR * toMap)3003 void handlemap_VkRenderPassCreateInfo2KHR(
3004     VulkanHandleMapping* handlemap,
3005     VkRenderPassCreateInfo2KHR* toMap)
3006 {
3007     (void)handlemap;
3008     (void)toMap;
3009     if (toMap->pNext)
3010     {
3011         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3012     }
3013     if (toMap->pAttachments)
3014     {
3015         for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
3016         {
3017             handlemap_VkAttachmentDescription2KHR(handlemap, (VkAttachmentDescription2KHR*)(toMap->pAttachments + i));
3018         }
3019     }
3020     if (toMap->pSubpasses)
3021     {
3022         for (uint32_t i = 0; i < (uint32_t)toMap->subpassCount; ++i)
3023         {
3024             handlemap_VkSubpassDescription2KHR(handlemap, (VkSubpassDescription2KHR*)(toMap->pSubpasses + i));
3025         }
3026     }
3027     if (toMap->pDependencies)
3028     {
3029         for (uint32_t i = 0; i < (uint32_t)toMap->dependencyCount; ++i)
3030         {
3031             handlemap_VkSubpassDependency2KHR(handlemap, (VkSubpassDependency2KHR*)(toMap->pDependencies + i));
3032         }
3033     }
3034 }
3035 
handlemap_VkSubpassBeginInfoKHR(VulkanHandleMapping * handlemap,VkSubpassBeginInfoKHR * toMap)3036 void handlemap_VkSubpassBeginInfoKHR(
3037     VulkanHandleMapping* handlemap,
3038     VkSubpassBeginInfoKHR* toMap)
3039 {
3040     (void)handlemap;
3041     (void)toMap;
3042     if (toMap->pNext)
3043     {
3044         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3045     }
3046 }
3047 
handlemap_VkSubpassEndInfoKHR(VulkanHandleMapping * handlemap,VkSubpassEndInfoKHR * toMap)3048 void handlemap_VkSubpassEndInfoKHR(
3049     VulkanHandleMapping* handlemap,
3050     VkSubpassEndInfoKHR* toMap)
3051 {
3052     (void)handlemap;
3053     (void)toMap;
3054     if (toMap->pNext)
3055     {
3056         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3057     }
3058 }
3059 
3060 #endif
3061 #ifdef VK_KHR_shared_presentable_image
handlemap_VkSharedPresentSurfaceCapabilitiesKHR(VulkanHandleMapping * handlemap,VkSharedPresentSurfaceCapabilitiesKHR * toMap)3062 void handlemap_VkSharedPresentSurfaceCapabilitiesKHR(
3063     VulkanHandleMapping* handlemap,
3064     VkSharedPresentSurfaceCapabilitiesKHR* toMap)
3065 {
3066     (void)handlemap;
3067     (void)toMap;
3068     if (toMap->pNext)
3069     {
3070         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3071     }
3072 }
3073 
3074 #endif
3075 #ifdef VK_KHR_external_fence_capabilities
3076 #endif
3077 #ifdef VK_KHR_external_fence
3078 #endif
3079 #ifdef VK_KHR_external_fence_win32
handlemap_VkImportFenceWin32HandleInfoKHR(VulkanHandleMapping * handlemap,VkImportFenceWin32HandleInfoKHR * toMap)3080 void handlemap_VkImportFenceWin32HandleInfoKHR(
3081     VulkanHandleMapping* handlemap,
3082     VkImportFenceWin32HandleInfoKHR* toMap)
3083 {
3084     (void)handlemap;
3085     (void)toMap;
3086     if (toMap->pNext)
3087     {
3088         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3089     }
3090     handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
3091 }
3092 
handlemap_VkExportFenceWin32HandleInfoKHR(VulkanHandleMapping * handlemap,VkExportFenceWin32HandleInfoKHR * toMap)3093 void handlemap_VkExportFenceWin32HandleInfoKHR(
3094     VulkanHandleMapping* handlemap,
3095     VkExportFenceWin32HandleInfoKHR* toMap)
3096 {
3097     (void)handlemap;
3098     (void)toMap;
3099     if (toMap->pNext)
3100     {
3101         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3102     }
3103 }
3104 
handlemap_VkFenceGetWin32HandleInfoKHR(VulkanHandleMapping * handlemap,VkFenceGetWin32HandleInfoKHR * toMap)3105 void handlemap_VkFenceGetWin32HandleInfoKHR(
3106     VulkanHandleMapping* handlemap,
3107     VkFenceGetWin32HandleInfoKHR* toMap)
3108 {
3109     (void)handlemap;
3110     (void)toMap;
3111     if (toMap->pNext)
3112     {
3113         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3114     }
3115     handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
3116 }
3117 
3118 #endif
3119 #ifdef VK_KHR_external_fence_fd
handlemap_VkImportFenceFdInfoKHR(VulkanHandleMapping * handlemap,VkImportFenceFdInfoKHR * toMap)3120 void handlemap_VkImportFenceFdInfoKHR(
3121     VulkanHandleMapping* handlemap,
3122     VkImportFenceFdInfoKHR* toMap)
3123 {
3124     (void)handlemap;
3125     (void)toMap;
3126     if (toMap->pNext)
3127     {
3128         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3129     }
3130     handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
3131 }
3132 
handlemap_VkFenceGetFdInfoKHR(VulkanHandleMapping * handlemap,VkFenceGetFdInfoKHR * toMap)3133 void handlemap_VkFenceGetFdInfoKHR(
3134     VulkanHandleMapping* handlemap,
3135     VkFenceGetFdInfoKHR* toMap)
3136 {
3137     (void)handlemap;
3138     (void)toMap;
3139     if (toMap->pNext)
3140     {
3141         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3142     }
3143     handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
3144 }
3145 
3146 #endif
3147 #ifdef VK_KHR_maintenance2
3148 #endif
3149 #ifdef VK_KHR_get_surface_capabilities2
handlemap_VkPhysicalDeviceSurfaceInfo2KHR(VulkanHandleMapping * handlemap,VkPhysicalDeviceSurfaceInfo2KHR * toMap)3150 void handlemap_VkPhysicalDeviceSurfaceInfo2KHR(
3151     VulkanHandleMapping* handlemap,
3152     VkPhysicalDeviceSurfaceInfo2KHR* toMap)
3153 {
3154     (void)handlemap;
3155     (void)toMap;
3156     if (toMap->pNext)
3157     {
3158         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3159     }
3160     handlemap->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&toMap->surface);
3161 }
3162 
handlemap_VkSurfaceCapabilities2KHR(VulkanHandleMapping * handlemap,VkSurfaceCapabilities2KHR * toMap)3163 void handlemap_VkSurfaceCapabilities2KHR(
3164     VulkanHandleMapping* handlemap,
3165     VkSurfaceCapabilities2KHR* toMap)
3166 {
3167     (void)handlemap;
3168     (void)toMap;
3169     if (toMap->pNext)
3170     {
3171         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3172     }
3173     handlemap_VkSurfaceCapabilitiesKHR(handlemap, (VkSurfaceCapabilitiesKHR*)(&toMap->surfaceCapabilities));
3174 }
3175 
handlemap_VkSurfaceFormat2KHR(VulkanHandleMapping * handlemap,VkSurfaceFormat2KHR * toMap)3176 void handlemap_VkSurfaceFormat2KHR(
3177     VulkanHandleMapping* handlemap,
3178     VkSurfaceFormat2KHR* toMap)
3179 {
3180     (void)handlemap;
3181     (void)toMap;
3182     if (toMap->pNext)
3183     {
3184         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3185     }
3186     handlemap_VkSurfaceFormatKHR(handlemap, (VkSurfaceFormatKHR*)(&toMap->surfaceFormat));
3187 }
3188 
3189 #endif
3190 #ifdef VK_KHR_variable_pointers
3191 #endif
3192 #ifdef VK_KHR_get_display_properties2
handlemap_VkDisplayProperties2KHR(VulkanHandleMapping * handlemap,VkDisplayProperties2KHR * toMap)3193 void handlemap_VkDisplayProperties2KHR(
3194     VulkanHandleMapping* handlemap,
3195     VkDisplayProperties2KHR* toMap)
3196 {
3197     (void)handlemap;
3198     (void)toMap;
3199     if (toMap->pNext)
3200     {
3201         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3202     }
3203     handlemap_VkDisplayPropertiesKHR(handlemap, (VkDisplayPropertiesKHR*)(&toMap->displayProperties));
3204 }
3205 
handlemap_VkDisplayPlaneProperties2KHR(VulkanHandleMapping * handlemap,VkDisplayPlaneProperties2KHR * toMap)3206 void handlemap_VkDisplayPlaneProperties2KHR(
3207     VulkanHandleMapping* handlemap,
3208     VkDisplayPlaneProperties2KHR* toMap)
3209 {
3210     (void)handlemap;
3211     (void)toMap;
3212     if (toMap->pNext)
3213     {
3214         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3215     }
3216     handlemap_VkDisplayPlanePropertiesKHR(handlemap, (VkDisplayPlanePropertiesKHR*)(&toMap->displayPlaneProperties));
3217 }
3218 
handlemap_VkDisplayModeProperties2KHR(VulkanHandleMapping * handlemap,VkDisplayModeProperties2KHR * toMap)3219 void handlemap_VkDisplayModeProperties2KHR(
3220     VulkanHandleMapping* handlemap,
3221     VkDisplayModeProperties2KHR* toMap)
3222 {
3223     (void)handlemap;
3224     (void)toMap;
3225     if (toMap->pNext)
3226     {
3227         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3228     }
3229     handlemap_VkDisplayModePropertiesKHR(handlemap, (VkDisplayModePropertiesKHR*)(&toMap->displayModeProperties));
3230 }
3231 
handlemap_VkDisplayPlaneInfo2KHR(VulkanHandleMapping * handlemap,VkDisplayPlaneInfo2KHR * toMap)3232 void handlemap_VkDisplayPlaneInfo2KHR(
3233     VulkanHandleMapping* handlemap,
3234     VkDisplayPlaneInfo2KHR* toMap)
3235 {
3236     (void)handlemap;
3237     (void)toMap;
3238     if (toMap->pNext)
3239     {
3240         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3241     }
3242     handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->mode);
3243 }
3244 
handlemap_VkDisplayPlaneCapabilities2KHR(VulkanHandleMapping * handlemap,VkDisplayPlaneCapabilities2KHR * toMap)3245 void handlemap_VkDisplayPlaneCapabilities2KHR(
3246     VulkanHandleMapping* handlemap,
3247     VkDisplayPlaneCapabilities2KHR* toMap)
3248 {
3249     (void)handlemap;
3250     (void)toMap;
3251     if (toMap->pNext)
3252     {
3253         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3254     }
3255     handlemap_VkDisplayPlaneCapabilitiesKHR(handlemap, (VkDisplayPlaneCapabilitiesKHR*)(&toMap->capabilities));
3256 }
3257 
3258 #endif
3259 #ifdef VK_KHR_dedicated_allocation
3260 #endif
3261 #ifdef VK_KHR_storage_buffer_storage_class
3262 #endif
3263 #ifdef VK_KHR_relaxed_block_layout
3264 #endif
3265 #ifdef VK_KHR_get_memory_requirements2
3266 #endif
3267 #ifdef VK_KHR_image_format_list
handlemap_VkImageFormatListCreateInfoKHR(VulkanHandleMapping * handlemap,VkImageFormatListCreateInfoKHR * toMap)3268 void handlemap_VkImageFormatListCreateInfoKHR(
3269     VulkanHandleMapping* handlemap,
3270     VkImageFormatListCreateInfoKHR* toMap)
3271 {
3272     (void)handlemap;
3273     (void)toMap;
3274     if (toMap->pNext)
3275     {
3276         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3277     }
3278 }
3279 
3280 #endif
3281 #ifdef VK_KHR_sampler_ycbcr_conversion
3282 #endif
3283 #ifdef VK_KHR_bind_memory2
3284 #endif
3285 #ifdef VK_KHR_maintenance3
3286 #endif
3287 #ifdef VK_KHR_draw_indirect_count
3288 #endif
3289 #ifdef VK_KHR_8bit_storage
handlemap_VkPhysicalDevice8BitStorageFeaturesKHR(VulkanHandleMapping * handlemap,VkPhysicalDevice8BitStorageFeaturesKHR * toMap)3290 void handlemap_VkPhysicalDevice8BitStorageFeaturesKHR(
3291     VulkanHandleMapping* handlemap,
3292     VkPhysicalDevice8BitStorageFeaturesKHR* toMap)
3293 {
3294     (void)handlemap;
3295     (void)toMap;
3296     if (toMap->pNext)
3297     {
3298         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3299     }
3300 }
3301 
3302 #endif
3303 #ifdef VK_KHR_shader_float16_int8
handlemap_VkPhysicalDeviceShaderFloat16Int8Features(VulkanHandleMapping * handlemap,VkPhysicalDeviceShaderFloat16Int8Features * toMap)3304 void handlemap_VkPhysicalDeviceShaderFloat16Int8Features(
3305     VulkanHandleMapping* handlemap,
3306     VkPhysicalDeviceShaderFloat16Int8Features* toMap)
3307 {
3308     (void)handlemap;
3309     (void)toMap;
3310     if (toMap->pNext)
3311     {
3312         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3313     }
3314 }
3315 
3316 #endif
3317 #ifdef VK_ANDROID_native_buffer
handlemap_VkNativeBufferANDROID(VulkanHandleMapping * handlemap,VkNativeBufferANDROID * toMap)3318 void handlemap_VkNativeBufferANDROID(
3319     VulkanHandleMapping* handlemap,
3320     VkNativeBufferANDROID* toMap)
3321 {
3322     (void)handlemap;
3323     (void)toMap;
3324     if (toMap->pNext)
3325     {
3326         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3327     }
3328 }
3329 
3330 #endif
3331 #ifdef VK_EXT_debug_report
handlemap_VkDebugReportCallbackCreateInfoEXT(VulkanHandleMapping * handlemap,VkDebugReportCallbackCreateInfoEXT * toMap)3332 void handlemap_VkDebugReportCallbackCreateInfoEXT(
3333     VulkanHandleMapping* handlemap,
3334     VkDebugReportCallbackCreateInfoEXT* toMap)
3335 {
3336     (void)handlemap;
3337     (void)toMap;
3338     if (toMap->pNext)
3339     {
3340         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3341     }
3342 }
3343 
3344 #endif
3345 #ifdef VK_NV_glsl_shader
3346 #endif
3347 #ifdef VK_EXT_depth_range_unrestricted
3348 #endif
3349 #ifdef VK_IMG_filter_cubic
3350 #endif
3351 #ifdef VK_AMD_rasterization_order
handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(VulkanHandleMapping * handlemap,VkPipelineRasterizationStateRasterizationOrderAMD * toMap)3352 void handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(
3353     VulkanHandleMapping* handlemap,
3354     VkPipelineRasterizationStateRasterizationOrderAMD* toMap)
3355 {
3356     (void)handlemap;
3357     (void)toMap;
3358     if (toMap->pNext)
3359     {
3360         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3361     }
3362 }
3363 
3364 #endif
3365 #ifdef VK_AMD_shader_trinary_minmax
3366 #endif
3367 #ifdef VK_AMD_shader_explicit_vertex_parameter
3368 #endif
3369 #ifdef VK_EXT_debug_marker
handlemap_VkDebugMarkerObjectNameInfoEXT(VulkanHandleMapping * handlemap,VkDebugMarkerObjectNameInfoEXT * toMap)3370 void handlemap_VkDebugMarkerObjectNameInfoEXT(
3371     VulkanHandleMapping* handlemap,
3372     VkDebugMarkerObjectNameInfoEXT* toMap)
3373 {
3374     (void)handlemap;
3375     (void)toMap;
3376     if (toMap->pNext)
3377     {
3378         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3379     }
3380 }
3381 
handlemap_VkDebugMarkerObjectTagInfoEXT(VulkanHandleMapping * handlemap,VkDebugMarkerObjectTagInfoEXT * toMap)3382 void handlemap_VkDebugMarkerObjectTagInfoEXT(
3383     VulkanHandleMapping* handlemap,
3384     VkDebugMarkerObjectTagInfoEXT* toMap)
3385 {
3386     (void)handlemap;
3387     (void)toMap;
3388     if (toMap->pNext)
3389     {
3390         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3391     }
3392 }
3393 
handlemap_VkDebugMarkerMarkerInfoEXT(VulkanHandleMapping * handlemap,VkDebugMarkerMarkerInfoEXT * toMap)3394 void handlemap_VkDebugMarkerMarkerInfoEXT(
3395     VulkanHandleMapping* handlemap,
3396     VkDebugMarkerMarkerInfoEXT* toMap)
3397 {
3398     (void)handlemap;
3399     (void)toMap;
3400     if (toMap->pNext)
3401     {
3402         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3403     }
3404 }
3405 
3406 #endif
3407 #ifdef VK_AMD_gcn_shader
3408 #endif
3409 #ifdef VK_NV_dedicated_allocation
handlemap_VkDedicatedAllocationImageCreateInfoNV(VulkanHandleMapping * handlemap,VkDedicatedAllocationImageCreateInfoNV * toMap)3410 void handlemap_VkDedicatedAllocationImageCreateInfoNV(
3411     VulkanHandleMapping* handlemap,
3412     VkDedicatedAllocationImageCreateInfoNV* toMap)
3413 {
3414     (void)handlemap;
3415     (void)toMap;
3416     if (toMap->pNext)
3417     {
3418         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3419     }
3420 }
3421 
handlemap_VkDedicatedAllocationBufferCreateInfoNV(VulkanHandleMapping * handlemap,VkDedicatedAllocationBufferCreateInfoNV * toMap)3422 void handlemap_VkDedicatedAllocationBufferCreateInfoNV(
3423     VulkanHandleMapping* handlemap,
3424     VkDedicatedAllocationBufferCreateInfoNV* toMap)
3425 {
3426     (void)handlemap;
3427     (void)toMap;
3428     if (toMap->pNext)
3429     {
3430         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3431     }
3432 }
3433 
handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(VulkanHandleMapping * handlemap,VkDedicatedAllocationMemoryAllocateInfoNV * toMap)3434 void handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(
3435     VulkanHandleMapping* handlemap,
3436     VkDedicatedAllocationMemoryAllocateInfoNV* toMap)
3437 {
3438     (void)handlemap;
3439     (void)toMap;
3440     if (toMap->pNext)
3441     {
3442         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3443     }
3444     handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
3445     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
3446 }
3447 
3448 #endif
3449 #ifdef VK_AMD_draw_indirect_count
3450 #endif
3451 #ifdef VK_AMD_negative_viewport_height
3452 #endif
3453 #ifdef VK_AMD_gpu_shader_half_float
3454 #endif
3455 #ifdef VK_AMD_shader_ballot
3456 #endif
3457 #ifdef VK_AMD_texture_gather_bias_lod
handlemap_VkTextureLODGatherFormatPropertiesAMD(VulkanHandleMapping * handlemap,VkTextureLODGatherFormatPropertiesAMD * toMap)3458 void handlemap_VkTextureLODGatherFormatPropertiesAMD(
3459     VulkanHandleMapping* handlemap,
3460     VkTextureLODGatherFormatPropertiesAMD* toMap)
3461 {
3462     (void)handlemap;
3463     (void)toMap;
3464     if (toMap->pNext)
3465     {
3466         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3467     }
3468 }
3469 
3470 #endif
3471 #ifdef VK_AMD_shader_info
handlemap_VkShaderResourceUsageAMD(VulkanHandleMapping * handlemap,VkShaderResourceUsageAMD * toMap)3472 void handlemap_VkShaderResourceUsageAMD(
3473     VulkanHandleMapping* handlemap,
3474     VkShaderResourceUsageAMD* toMap)
3475 {
3476     (void)handlemap;
3477     (void)toMap;
3478 }
3479 
handlemap_VkShaderStatisticsInfoAMD(VulkanHandleMapping * handlemap,VkShaderStatisticsInfoAMD * toMap)3480 void handlemap_VkShaderStatisticsInfoAMD(
3481     VulkanHandleMapping* handlemap,
3482     VkShaderStatisticsInfoAMD* toMap)
3483 {
3484     (void)handlemap;
3485     (void)toMap;
3486     handlemap_VkShaderResourceUsageAMD(handlemap, (VkShaderResourceUsageAMD*)(&toMap->resourceUsage));
3487 }
3488 
3489 #endif
3490 #ifdef VK_AMD_shader_image_load_store_lod
3491 #endif
3492 #ifdef VK_IMG_format_pvrtc
3493 #endif
3494 #ifdef VK_NV_external_memory_capabilities
handlemap_VkExternalImageFormatPropertiesNV(VulkanHandleMapping * handlemap,VkExternalImageFormatPropertiesNV * toMap)3495 void handlemap_VkExternalImageFormatPropertiesNV(
3496     VulkanHandleMapping* handlemap,
3497     VkExternalImageFormatPropertiesNV* toMap)
3498 {
3499     (void)handlemap;
3500     (void)toMap;
3501     handlemap_VkImageFormatProperties(handlemap, (VkImageFormatProperties*)(&toMap->imageFormatProperties));
3502 }
3503 
3504 #endif
3505 #ifdef VK_NV_external_memory
handlemap_VkExternalMemoryImageCreateInfoNV(VulkanHandleMapping * handlemap,VkExternalMemoryImageCreateInfoNV * toMap)3506 void handlemap_VkExternalMemoryImageCreateInfoNV(
3507     VulkanHandleMapping* handlemap,
3508     VkExternalMemoryImageCreateInfoNV* toMap)
3509 {
3510     (void)handlemap;
3511     (void)toMap;
3512     if (toMap->pNext)
3513     {
3514         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3515     }
3516 }
3517 
handlemap_VkExportMemoryAllocateInfoNV(VulkanHandleMapping * handlemap,VkExportMemoryAllocateInfoNV * toMap)3518 void handlemap_VkExportMemoryAllocateInfoNV(
3519     VulkanHandleMapping* handlemap,
3520     VkExportMemoryAllocateInfoNV* toMap)
3521 {
3522     (void)handlemap;
3523     (void)toMap;
3524     if (toMap->pNext)
3525     {
3526         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3527     }
3528 }
3529 
3530 #endif
3531 #ifdef VK_NV_external_memory_win32
handlemap_VkImportMemoryWin32HandleInfoNV(VulkanHandleMapping * handlemap,VkImportMemoryWin32HandleInfoNV * toMap)3532 void handlemap_VkImportMemoryWin32HandleInfoNV(
3533     VulkanHandleMapping* handlemap,
3534     VkImportMemoryWin32HandleInfoNV* toMap)
3535 {
3536     (void)handlemap;
3537     (void)toMap;
3538     if (toMap->pNext)
3539     {
3540         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3541     }
3542 }
3543 
handlemap_VkExportMemoryWin32HandleInfoNV(VulkanHandleMapping * handlemap,VkExportMemoryWin32HandleInfoNV * toMap)3544 void handlemap_VkExportMemoryWin32HandleInfoNV(
3545     VulkanHandleMapping* handlemap,
3546     VkExportMemoryWin32HandleInfoNV* toMap)
3547 {
3548     (void)handlemap;
3549     (void)toMap;
3550     if (toMap->pNext)
3551     {
3552         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3553     }
3554 }
3555 
3556 #endif
3557 #ifdef VK_NV_win32_keyed_mutex
handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(VulkanHandleMapping * handlemap,VkWin32KeyedMutexAcquireReleaseInfoNV * toMap)3558 void handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(
3559     VulkanHandleMapping* handlemap,
3560     VkWin32KeyedMutexAcquireReleaseInfoNV* toMap)
3561 {
3562     (void)handlemap;
3563     (void)toMap;
3564     if (toMap->pNext)
3565     {
3566         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3567     }
3568     if (toMap->pAcquireSyncs)
3569     {
3570         handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pAcquireSyncs, toMap->acquireCount);
3571     }
3572     if (toMap->pReleaseSyncs)
3573     {
3574         handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pReleaseSyncs, toMap->releaseCount);
3575     }
3576 }
3577 
3578 #endif
3579 #ifdef VK_EXT_validation_flags
handlemap_VkValidationFlagsEXT(VulkanHandleMapping * handlemap,VkValidationFlagsEXT * toMap)3580 void handlemap_VkValidationFlagsEXT(
3581     VulkanHandleMapping* handlemap,
3582     VkValidationFlagsEXT* toMap)
3583 {
3584     (void)handlemap;
3585     (void)toMap;
3586     if (toMap->pNext)
3587     {
3588         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3589     }
3590 }
3591 
3592 #endif
3593 #ifdef VK_NN_vi_surface
handlemap_VkViSurfaceCreateInfoNN(VulkanHandleMapping * handlemap,VkViSurfaceCreateInfoNN * toMap)3594 void handlemap_VkViSurfaceCreateInfoNN(
3595     VulkanHandleMapping* handlemap,
3596     VkViSurfaceCreateInfoNN* toMap)
3597 {
3598     (void)handlemap;
3599     (void)toMap;
3600     if (toMap->pNext)
3601     {
3602         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3603     }
3604 }
3605 
3606 #endif
3607 #ifdef VK_EXT_shader_subgroup_ballot
3608 #endif
3609 #ifdef VK_EXT_shader_subgroup_vote
3610 #endif
3611 #ifdef VK_EXT_conditional_rendering
handlemap_VkConditionalRenderingBeginInfoEXT(VulkanHandleMapping * handlemap,VkConditionalRenderingBeginInfoEXT * toMap)3612 void handlemap_VkConditionalRenderingBeginInfoEXT(
3613     VulkanHandleMapping* handlemap,
3614     VkConditionalRenderingBeginInfoEXT* toMap)
3615 {
3616     (void)handlemap;
3617     (void)toMap;
3618     if (toMap->pNext)
3619     {
3620         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3621     }
3622     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
3623 }
3624 
handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(VulkanHandleMapping * handlemap,VkPhysicalDeviceConditionalRenderingFeaturesEXT * toMap)3625 void handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
3626     VulkanHandleMapping* handlemap,
3627     VkPhysicalDeviceConditionalRenderingFeaturesEXT* toMap)
3628 {
3629     (void)handlemap;
3630     (void)toMap;
3631     if (toMap->pNext)
3632     {
3633         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3634     }
3635 }
3636 
handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(VulkanHandleMapping * handlemap,VkCommandBufferInheritanceConditionalRenderingInfoEXT * toMap)3637 void handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
3638     VulkanHandleMapping* handlemap,
3639     VkCommandBufferInheritanceConditionalRenderingInfoEXT* toMap)
3640 {
3641     (void)handlemap;
3642     (void)toMap;
3643     if (toMap->pNext)
3644     {
3645         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3646     }
3647 }
3648 
3649 #endif
3650 #ifdef VK_NVX_device_generated_commands
handlemap_VkDeviceGeneratedCommandsFeaturesNVX(VulkanHandleMapping * handlemap,VkDeviceGeneratedCommandsFeaturesNVX * toMap)3651 void handlemap_VkDeviceGeneratedCommandsFeaturesNVX(
3652     VulkanHandleMapping* handlemap,
3653     VkDeviceGeneratedCommandsFeaturesNVX* toMap)
3654 {
3655     (void)handlemap;
3656     (void)toMap;
3657     if (toMap->pNext)
3658     {
3659         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3660     }
3661 }
3662 
handlemap_VkDeviceGeneratedCommandsLimitsNVX(VulkanHandleMapping * handlemap,VkDeviceGeneratedCommandsLimitsNVX * toMap)3663 void handlemap_VkDeviceGeneratedCommandsLimitsNVX(
3664     VulkanHandleMapping* handlemap,
3665     VkDeviceGeneratedCommandsLimitsNVX* toMap)
3666 {
3667     (void)handlemap;
3668     (void)toMap;
3669     if (toMap->pNext)
3670     {
3671         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3672     }
3673 }
3674 
handlemap_VkIndirectCommandsTokenNVX(VulkanHandleMapping * handlemap,VkIndirectCommandsTokenNVX * toMap)3675 void handlemap_VkIndirectCommandsTokenNVX(
3676     VulkanHandleMapping* handlemap,
3677     VkIndirectCommandsTokenNVX* toMap)
3678 {
3679     (void)handlemap;
3680     (void)toMap;
3681     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
3682 }
3683 
handlemap_VkIndirectCommandsLayoutTokenNVX(VulkanHandleMapping * handlemap,VkIndirectCommandsLayoutTokenNVX * toMap)3684 void handlemap_VkIndirectCommandsLayoutTokenNVX(
3685     VulkanHandleMapping* handlemap,
3686     VkIndirectCommandsLayoutTokenNVX* toMap)
3687 {
3688     (void)handlemap;
3689     (void)toMap;
3690 }
3691 
handlemap_VkIndirectCommandsLayoutCreateInfoNVX(VulkanHandleMapping * handlemap,VkIndirectCommandsLayoutCreateInfoNVX * toMap)3692 void handlemap_VkIndirectCommandsLayoutCreateInfoNVX(
3693     VulkanHandleMapping* handlemap,
3694     VkIndirectCommandsLayoutCreateInfoNVX* toMap)
3695 {
3696     (void)handlemap;
3697     (void)toMap;
3698     if (toMap->pNext)
3699     {
3700         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3701     }
3702     if (toMap->pTokens)
3703     {
3704         for (uint32_t i = 0; i < (uint32_t)toMap->tokenCount; ++i)
3705         {
3706             handlemap_VkIndirectCommandsLayoutTokenNVX(handlemap, (VkIndirectCommandsLayoutTokenNVX*)(toMap->pTokens + i));
3707         }
3708     }
3709 }
3710 
handlemap_VkCmdProcessCommandsInfoNVX(VulkanHandleMapping * handlemap,VkCmdProcessCommandsInfoNVX * toMap)3711 void handlemap_VkCmdProcessCommandsInfoNVX(
3712     VulkanHandleMapping* handlemap,
3713     VkCmdProcessCommandsInfoNVX* toMap)
3714 {
3715     (void)handlemap;
3716     (void)toMap;
3717     if (toMap->pNext)
3718     {
3719         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3720     }
3721     handlemap->mapHandles_VkObjectTableNVX((VkObjectTableNVX*)&toMap->objectTable);
3722     handlemap->mapHandles_VkIndirectCommandsLayoutNVX((VkIndirectCommandsLayoutNVX*)&toMap->indirectCommandsLayout);
3723     if (toMap->pIndirectCommandsTokens)
3724     {
3725         for (uint32_t i = 0; i < (uint32_t)toMap->indirectCommandsTokenCount; ++i)
3726         {
3727             handlemap_VkIndirectCommandsTokenNVX(handlemap, (VkIndirectCommandsTokenNVX*)(toMap->pIndirectCommandsTokens + i));
3728         }
3729     }
3730     handlemap->mapHandles_VkCommandBuffer((VkCommandBuffer*)&toMap->targetCommandBuffer);
3731     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->sequencesCountBuffer);
3732     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->sequencesIndexBuffer);
3733 }
3734 
handlemap_VkCmdReserveSpaceForCommandsInfoNVX(VulkanHandleMapping * handlemap,VkCmdReserveSpaceForCommandsInfoNVX * toMap)3735 void handlemap_VkCmdReserveSpaceForCommandsInfoNVX(
3736     VulkanHandleMapping* handlemap,
3737     VkCmdReserveSpaceForCommandsInfoNVX* toMap)
3738 {
3739     (void)handlemap;
3740     (void)toMap;
3741     if (toMap->pNext)
3742     {
3743         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3744     }
3745     handlemap->mapHandles_VkObjectTableNVX((VkObjectTableNVX*)&toMap->objectTable);
3746     handlemap->mapHandles_VkIndirectCommandsLayoutNVX((VkIndirectCommandsLayoutNVX*)&toMap->indirectCommandsLayout);
3747 }
3748 
handlemap_VkObjectTableCreateInfoNVX(VulkanHandleMapping * handlemap,VkObjectTableCreateInfoNVX * toMap)3749 void handlemap_VkObjectTableCreateInfoNVX(
3750     VulkanHandleMapping* handlemap,
3751     VkObjectTableCreateInfoNVX* toMap)
3752 {
3753     (void)handlemap;
3754     (void)toMap;
3755     if (toMap->pNext)
3756     {
3757         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3758     }
3759 }
3760 
handlemap_VkObjectTableEntryNVX(VulkanHandleMapping * handlemap,VkObjectTableEntryNVX * toMap)3761 void handlemap_VkObjectTableEntryNVX(
3762     VulkanHandleMapping* handlemap,
3763     VkObjectTableEntryNVX* toMap)
3764 {
3765     (void)handlemap;
3766     (void)toMap;
3767 }
3768 
handlemap_VkObjectTablePipelineEntryNVX(VulkanHandleMapping * handlemap,VkObjectTablePipelineEntryNVX * toMap)3769 void handlemap_VkObjectTablePipelineEntryNVX(
3770     VulkanHandleMapping* handlemap,
3771     VkObjectTablePipelineEntryNVX* toMap)
3772 {
3773     (void)handlemap;
3774     (void)toMap;
3775     handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->pipeline);
3776 }
3777 
handlemap_VkObjectTableDescriptorSetEntryNVX(VulkanHandleMapping * handlemap,VkObjectTableDescriptorSetEntryNVX * toMap)3778 void handlemap_VkObjectTableDescriptorSetEntryNVX(
3779     VulkanHandleMapping* handlemap,
3780     VkObjectTableDescriptorSetEntryNVX* toMap)
3781 {
3782     (void)handlemap;
3783     (void)toMap;
3784     handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->pipelineLayout);
3785     handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->descriptorSet);
3786 }
3787 
handlemap_VkObjectTableVertexBufferEntryNVX(VulkanHandleMapping * handlemap,VkObjectTableVertexBufferEntryNVX * toMap)3788 void handlemap_VkObjectTableVertexBufferEntryNVX(
3789     VulkanHandleMapping* handlemap,
3790     VkObjectTableVertexBufferEntryNVX* toMap)
3791 {
3792     (void)handlemap;
3793     (void)toMap;
3794     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
3795 }
3796 
handlemap_VkObjectTableIndexBufferEntryNVX(VulkanHandleMapping * handlemap,VkObjectTableIndexBufferEntryNVX * toMap)3797 void handlemap_VkObjectTableIndexBufferEntryNVX(
3798     VulkanHandleMapping* handlemap,
3799     VkObjectTableIndexBufferEntryNVX* toMap)
3800 {
3801     (void)handlemap;
3802     (void)toMap;
3803     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
3804 }
3805 
handlemap_VkObjectTablePushConstantEntryNVX(VulkanHandleMapping * handlemap,VkObjectTablePushConstantEntryNVX * toMap)3806 void handlemap_VkObjectTablePushConstantEntryNVX(
3807     VulkanHandleMapping* handlemap,
3808     VkObjectTablePushConstantEntryNVX* toMap)
3809 {
3810     (void)handlemap;
3811     (void)toMap;
3812     handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->pipelineLayout);
3813 }
3814 
3815 #endif
3816 #ifdef VK_NV_clip_space_w_scaling
handlemap_VkViewportWScalingNV(VulkanHandleMapping * handlemap,VkViewportWScalingNV * toMap)3817 void handlemap_VkViewportWScalingNV(
3818     VulkanHandleMapping* handlemap,
3819     VkViewportWScalingNV* toMap)
3820 {
3821     (void)handlemap;
3822     (void)toMap;
3823 }
3824 
handlemap_VkPipelineViewportWScalingStateCreateInfoNV(VulkanHandleMapping * handlemap,VkPipelineViewportWScalingStateCreateInfoNV * toMap)3825 void handlemap_VkPipelineViewportWScalingStateCreateInfoNV(
3826     VulkanHandleMapping* handlemap,
3827     VkPipelineViewportWScalingStateCreateInfoNV* toMap)
3828 {
3829     (void)handlemap;
3830     (void)toMap;
3831     if (toMap->pNext)
3832     {
3833         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3834     }
3835     if (toMap->pViewportWScalings)
3836     {
3837         for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
3838         {
3839             handlemap_VkViewportWScalingNV(handlemap, (VkViewportWScalingNV*)(toMap->pViewportWScalings + i));
3840         }
3841     }
3842 }
3843 
3844 #endif
3845 #ifdef VK_EXT_direct_mode_display
3846 #endif
3847 #ifdef VK_EXT_acquire_xlib_display
3848 #endif
3849 #ifdef VK_EXT_display_surface_counter
handlemap_VkSurfaceCapabilities2EXT(VulkanHandleMapping * handlemap,VkSurfaceCapabilities2EXT * toMap)3850 void handlemap_VkSurfaceCapabilities2EXT(
3851     VulkanHandleMapping* handlemap,
3852     VkSurfaceCapabilities2EXT* toMap)
3853 {
3854     (void)handlemap;
3855     (void)toMap;
3856     if (toMap->pNext)
3857     {
3858         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3859     }
3860     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->currentExtent));
3861     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minImageExtent));
3862     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxImageExtent));
3863 }
3864 
3865 #endif
3866 #ifdef VK_EXT_display_control
handlemap_VkDisplayPowerInfoEXT(VulkanHandleMapping * handlemap,VkDisplayPowerInfoEXT * toMap)3867 void handlemap_VkDisplayPowerInfoEXT(
3868     VulkanHandleMapping* handlemap,
3869     VkDisplayPowerInfoEXT* toMap)
3870 {
3871     (void)handlemap;
3872     (void)toMap;
3873     if (toMap->pNext)
3874     {
3875         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3876     }
3877 }
3878 
handlemap_VkDeviceEventInfoEXT(VulkanHandleMapping * handlemap,VkDeviceEventInfoEXT * toMap)3879 void handlemap_VkDeviceEventInfoEXT(
3880     VulkanHandleMapping* handlemap,
3881     VkDeviceEventInfoEXT* toMap)
3882 {
3883     (void)handlemap;
3884     (void)toMap;
3885     if (toMap->pNext)
3886     {
3887         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3888     }
3889 }
3890 
handlemap_VkDisplayEventInfoEXT(VulkanHandleMapping * handlemap,VkDisplayEventInfoEXT * toMap)3891 void handlemap_VkDisplayEventInfoEXT(
3892     VulkanHandleMapping* handlemap,
3893     VkDisplayEventInfoEXT* toMap)
3894 {
3895     (void)handlemap;
3896     (void)toMap;
3897     if (toMap->pNext)
3898     {
3899         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3900     }
3901 }
3902 
handlemap_VkSwapchainCounterCreateInfoEXT(VulkanHandleMapping * handlemap,VkSwapchainCounterCreateInfoEXT * toMap)3903 void handlemap_VkSwapchainCounterCreateInfoEXT(
3904     VulkanHandleMapping* handlemap,
3905     VkSwapchainCounterCreateInfoEXT* toMap)
3906 {
3907     (void)handlemap;
3908     (void)toMap;
3909     if (toMap->pNext)
3910     {
3911         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3912     }
3913 }
3914 
3915 #endif
3916 #ifdef VK_GOOGLE_display_timing
handlemap_VkRefreshCycleDurationGOOGLE(VulkanHandleMapping * handlemap,VkRefreshCycleDurationGOOGLE * toMap)3917 void handlemap_VkRefreshCycleDurationGOOGLE(
3918     VulkanHandleMapping* handlemap,
3919     VkRefreshCycleDurationGOOGLE* toMap)
3920 {
3921     (void)handlemap;
3922     (void)toMap;
3923 }
3924 
handlemap_VkPastPresentationTimingGOOGLE(VulkanHandleMapping * handlemap,VkPastPresentationTimingGOOGLE * toMap)3925 void handlemap_VkPastPresentationTimingGOOGLE(
3926     VulkanHandleMapping* handlemap,
3927     VkPastPresentationTimingGOOGLE* toMap)
3928 {
3929     (void)handlemap;
3930     (void)toMap;
3931 }
3932 
handlemap_VkPresentTimeGOOGLE(VulkanHandleMapping * handlemap,VkPresentTimeGOOGLE * toMap)3933 void handlemap_VkPresentTimeGOOGLE(
3934     VulkanHandleMapping* handlemap,
3935     VkPresentTimeGOOGLE* toMap)
3936 {
3937     (void)handlemap;
3938     (void)toMap;
3939 }
3940 
handlemap_VkPresentTimesInfoGOOGLE(VulkanHandleMapping * handlemap,VkPresentTimesInfoGOOGLE * toMap)3941 void handlemap_VkPresentTimesInfoGOOGLE(
3942     VulkanHandleMapping* handlemap,
3943     VkPresentTimesInfoGOOGLE* toMap)
3944 {
3945     (void)handlemap;
3946     (void)toMap;
3947     if (toMap->pNext)
3948     {
3949         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3950     }
3951     if (toMap->pTimes)
3952     {
3953         for (uint32_t i = 0; i < (uint32_t)toMap->swapchainCount; ++i)
3954         {
3955             handlemap_VkPresentTimeGOOGLE(handlemap, (VkPresentTimeGOOGLE*)(toMap->pTimes + i));
3956         }
3957     }
3958 }
3959 
3960 #endif
3961 #ifdef VK_NV_sample_mask_override_coverage
3962 #endif
3963 #ifdef VK_NV_geometry_shader_passthrough
3964 #endif
3965 #ifdef VK_NV_viewport_array2
3966 #endif
3967 #ifdef VK_NVX_multiview_per_view_attributes
handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(VulkanHandleMapping * handlemap,VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX * toMap)3968 void handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
3969     VulkanHandleMapping* handlemap,
3970     VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toMap)
3971 {
3972     (void)handlemap;
3973     (void)toMap;
3974     if (toMap->pNext)
3975     {
3976         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3977     }
3978 }
3979 
3980 #endif
3981 #ifdef VK_NV_viewport_swizzle
handlemap_VkViewportSwizzleNV(VulkanHandleMapping * handlemap,VkViewportSwizzleNV * toMap)3982 void handlemap_VkViewportSwizzleNV(
3983     VulkanHandleMapping* handlemap,
3984     VkViewportSwizzleNV* toMap)
3985 {
3986     (void)handlemap;
3987     (void)toMap;
3988 }
3989 
handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(VulkanHandleMapping * handlemap,VkPipelineViewportSwizzleStateCreateInfoNV * toMap)3990 void handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(
3991     VulkanHandleMapping* handlemap,
3992     VkPipelineViewportSwizzleStateCreateInfoNV* toMap)
3993 {
3994     (void)handlemap;
3995     (void)toMap;
3996     if (toMap->pNext)
3997     {
3998         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
3999     }
4000     if (toMap->pViewportSwizzles)
4001     {
4002         for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
4003         {
4004             handlemap_VkViewportSwizzleNV(handlemap, (VkViewportSwizzleNV*)(toMap->pViewportSwizzles + i));
4005         }
4006     }
4007 }
4008 
4009 #endif
4010 #ifdef VK_EXT_discard_rectangles
handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(VulkanHandleMapping * handlemap,VkPhysicalDeviceDiscardRectanglePropertiesEXT * toMap)4011 void handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
4012     VulkanHandleMapping* handlemap,
4013     VkPhysicalDeviceDiscardRectanglePropertiesEXT* toMap)
4014 {
4015     (void)handlemap;
4016     (void)toMap;
4017     if (toMap->pNext)
4018     {
4019         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4020     }
4021 }
4022 
handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(VulkanHandleMapping * handlemap,VkPipelineDiscardRectangleStateCreateInfoEXT * toMap)4023 void handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(
4024     VulkanHandleMapping* handlemap,
4025     VkPipelineDiscardRectangleStateCreateInfoEXT* toMap)
4026 {
4027     (void)handlemap;
4028     (void)toMap;
4029     if (toMap->pNext)
4030     {
4031         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4032     }
4033     if (toMap->pDiscardRectangles)
4034     {
4035         for (uint32_t i = 0; i < (uint32_t)toMap->discardRectangleCount; ++i)
4036         {
4037             handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pDiscardRectangles + i));
4038         }
4039     }
4040 }
4041 
4042 #endif
4043 #ifdef VK_EXT_conservative_rasterization
handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(VulkanHandleMapping * handlemap,VkPhysicalDeviceConservativeRasterizationPropertiesEXT * toMap)4044 void handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
4045     VulkanHandleMapping* handlemap,
4046     VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toMap)
4047 {
4048     (void)handlemap;
4049     (void)toMap;
4050     if (toMap->pNext)
4051     {
4052         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4053     }
4054 }
4055 
handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(VulkanHandleMapping * handlemap,VkPipelineRasterizationConservativeStateCreateInfoEXT * toMap)4056 void handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(
4057     VulkanHandleMapping* handlemap,
4058     VkPipelineRasterizationConservativeStateCreateInfoEXT* toMap)
4059 {
4060     (void)handlemap;
4061     (void)toMap;
4062     if (toMap->pNext)
4063     {
4064         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4065     }
4066 }
4067 
4068 #endif
4069 #ifdef VK_EXT_swapchain_colorspace
4070 #endif
4071 #ifdef VK_EXT_hdr_metadata
handlemap_VkXYColorEXT(VulkanHandleMapping * handlemap,VkXYColorEXT * toMap)4072 void handlemap_VkXYColorEXT(
4073     VulkanHandleMapping* handlemap,
4074     VkXYColorEXT* toMap)
4075 {
4076     (void)handlemap;
4077     (void)toMap;
4078 }
4079 
handlemap_VkHdrMetadataEXT(VulkanHandleMapping * handlemap,VkHdrMetadataEXT * toMap)4080 void handlemap_VkHdrMetadataEXT(
4081     VulkanHandleMapping* handlemap,
4082     VkHdrMetadataEXT* toMap)
4083 {
4084     (void)handlemap;
4085     (void)toMap;
4086     if (toMap->pNext)
4087     {
4088         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4089     }
4090     handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->displayPrimaryRed));
4091     handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->displayPrimaryGreen));
4092     handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->displayPrimaryBlue));
4093     handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->whitePoint));
4094 }
4095 
4096 #endif
4097 #ifdef VK_MVK_ios_surface
handlemap_VkIOSSurfaceCreateInfoMVK(VulkanHandleMapping * handlemap,VkIOSSurfaceCreateInfoMVK * toMap)4098 void handlemap_VkIOSSurfaceCreateInfoMVK(
4099     VulkanHandleMapping* handlemap,
4100     VkIOSSurfaceCreateInfoMVK* toMap)
4101 {
4102     (void)handlemap;
4103     (void)toMap;
4104     if (toMap->pNext)
4105     {
4106         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4107     }
4108 }
4109 
4110 #endif
4111 #ifdef VK_MVK_macos_surface
handlemap_VkMacOSSurfaceCreateInfoMVK(VulkanHandleMapping * handlemap,VkMacOSSurfaceCreateInfoMVK * toMap)4112 void handlemap_VkMacOSSurfaceCreateInfoMVK(
4113     VulkanHandleMapping* handlemap,
4114     VkMacOSSurfaceCreateInfoMVK* toMap)
4115 {
4116     (void)handlemap;
4117     (void)toMap;
4118     if (toMap->pNext)
4119     {
4120         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4121     }
4122 }
4123 
4124 #endif
4125 #ifdef VK_EXT_external_memory_dma_buf
4126 #endif
4127 #ifdef VK_EXT_queue_family_foreign
4128 #endif
4129 #ifdef VK_EXT_debug_utils
handlemap_VkDebugUtilsObjectNameInfoEXT(VulkanHandleMapping * handlemap,VkDebugUtilsObjectNameInfoEXT * toMap)4130 void handlemap_VkDebugUtilsObjectNameInfoEXT(
4131     VulkanHandleMapping* handlemap,
4132     VkDebugUtilsObjectNameInfoEXT* toMap)
4133 {
4134     (void)handlemap;
4135     (void)toMap;
4136     if (toMap->pNext)
4137     {
4138         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4139     }
4140 }
4141 
handlemap_VkDebugUtilsObjectTagInfoEXT(VulkanHandleMapping * handlemap,VkDebugUtilsObjectTagInfoEXT * toMap)4142 void handlemap_VkDebugUtilsObjectTagInfoEXT(
4143     VulkanHandleMapping* handlemap,
4144     VkDebugUtilsObjectTagInfoEXT* toMap)
4145 {
4146     (void)handlemap;
4147     (void)toMap;
4148     if (toMap->pNext)
4149     {
4150         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4151     }
4152 }
4153 
handlemap_VkDebugUtilsLabelEXT(VulkanHandleMapping * handlemap,VkDebugUtilsLabelEXT * toMap)4154 void handlemap_VkDebugUtilsLabelEXT(
4155     VulkanHandleMapping* handlemap,
4156     VkDebugUtilsLabelEXT* toMap)
4157 {
4158     (void)handlemap;
4159     (void)toMap;
4160     if (toMap->pNext)
4161     {
4162         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4163     }
4164 }
4165 
handlemap_VkDebugUtilsMessengerCallbackDataEXT(VulkanHandleMapping * handlemap,VkDebugUtilsMessengerCallbackDataEXT * toMap)4166 void handlemap_VkDebugUtilsMessengerCallbackDataEXT(
4167     VulkanHandleMapping* handlemap,
4168     VkDebugUtilsMessengerCallbackDataEXT* toMap)
4169 {
4170     (void)handlemap;
4171     (void)toMap;
4172     if (toMap->pNext)
4173     {
4174         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4175     }
4176     if (toMap->pQueueLabels)
4177     {
4178         for (uint32_t i = 0; i < (uint32_t)toMap->queueLabelCount; ++i)
4179         {
4180             handlemap_VkDebugUtilsLabelEXT(handlemap, (VkDebugUtilsLabelEXT*)(toMap->pQueueLabels + i));
4181         }
4182     }
4183     if (toMap->pCmdBufLabels)
4184     {
4185         for (uint32_t i = 0; i < (uint32_t)toMap->cmdBufLabelCount; ++i)
4186         {
4187             handlemap_VkDebugUtilsLabelEXT(handlemap, (VkDebugUtilsLabelEXT*)(toMap->pCmdBufLabels + i));
4188         }
4189     }
4190     if (toMap->pObjects)
4191     {
4192         for (uint32_t i = 0; i < (uint32_t)toMap->objectCount; ++i)
4193         {
4194             handlemap_VkDebugUtilsObjectNameInfoEXT(handlemap, (VkDebugUtilsObjectNameInfoEXT*)(toMap->pObjects + i));
4195         }
4196     }
4197 }
4198 
handlemap_VkDebugUtilsMessengerCreateInfoEXT(VulkanHandleMapping * handlemap,VkDebugUtilsMessengerCreateInfoEXT * toMap)4199 void handlemap_VkDebugUtilsMessengerCreateInfoEXT(
4200     VulkanHandleMapping* handlemap,
4201     VkDebugUtilsMessengerCreateInfoEXT* toMap)
4202 {
4203     (void)handlemap;
4204     (void)toMap;
4205     if (toMap->pNext)
4206     {
4207         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4208     }
4209 }
4210 
4211 #endif
4212 #ifdef VK_ANDROID_external_memory_android_hardware_buffer
handlemap_VkAndroidHardwareBufferUsageANDROID(VulkanHandleMapping * handlemap,VkAndroidHardwareBufferUsageANDROID * toMap)4213 void handlemap_VkAndroidHardwareBufferUsageANDROID(
4214     VulkanHandleMapping* handlemap,
4215     VkAndroidHardwareBufferUsageANDROID* toMap)
4216 {
4217     (void)handlemap;
4218     (void)toMap;
4219     if (toMap->pNext)
4220     {
4221         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4222     }
4223 }
4224 
handlemap_VkAndroidHardwareBufferPropertiesANDROID(VulkanHandleMapping * handlemap,VkAndroidHardwareBufferPropertiesANDROID * toMap)4225 void handlemap_VkAndroidHardwareBufferPropertiesANDROID(
4226     VulkanHandleMapping* handlemap,
4227     VkAndroidHardwareBufferPropertiesANDROID* toMap)
4228 {
4229     (void)handlemap;
4230     (void)toMap;
4231     if (toMap->pNext)
4232     {
4233         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4234     }
4235 }
4236 
handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(VulkanHandleMapping * handlemap,VkAndroidHardwareBufferFormatPropertiesANDROID * toMap)4237 void handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(
4238     VulkanHandleMapping* handlemap,
4239     VkAndroidHardwareBufferFormatPropertiesANDROID* toMap)
4240 {
4241     (void)handlemap;
4242     (void)toMap;
4243     if (toMap->pNext)
4244     {
4245         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4246     }
4247     handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->samplerYcbcrConversionComponents));
4248 }
4249 
handlemap_VkImportAndroidHardwareBufferInfoANDROID(VulkanHandleMapping * handlemap,VkImportAndroidHardwareBufferInfoANDROID * toMap)4250 void handlemap_VkImportAndroidHardwareBufferInfoANDROID(
4251     VulkanHandleMapping* handlemap,
4252     VkImportAndroidHardwareBufferInfoANDROID* toMap)
4253 {
4254     (void)handlemap;
4255     (void)toMap;
4256     if (toMap->pNext)
4257     {
4258         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4259     }
4260 }
4261 
handlemap_VkMemoryGetAndroidHardwareBufferInfoANDROID(VulkanHandleMapping * handlemap,VkMemoryGetAndroidHardwareBufferInfoANDROID * toMap)4262 void handlemap_VkMemoryGetAndroidHardwareBufferInfoANDROID(
4263     VulkanHandleMapping* handlemap,
4264     VkMemoryGetAndroidHardwareBufferInfoANDROID* toMap)
4265 {
4266     (void)handlemap;
4267     (void)toMap;
4268     if (toMap->pNext)
4269     {
4270         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4271     }
4272     handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
4273 }
4274 
handlemap_VkExternalFormatANDROID(VulkanHandleMapping * handlemap,VkExternalFormatANDROID * toMap)4275 void handlemap_VkExternalFormatANDROID(
4276     VulkanHandleMapping* handlemap,
4277     VkExternalFormatANDROID* toMap)
4278 {
4279     (void)handlemap;
4280     (void)toMap;
4281     if (toMap->pNext)
4282     {
4283         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4284     }
4285 }
4286 
4287 #endif
4288 #ifdef VK_EXT_sampler_filter_minmax
handlemap_VkSamplerReductionModeCreateInfoEXT(VulkanHandleMapping * handlemap,VkSamplerReductionModeCreateInfoEXT * toMap)4289 void handlemap_VkSamplerReductionModeCreateInfoEXT(
4290     VulkanHandleMapping* handlemap,
4291     VkSamplerReductionModeCreateInfoEXT* toMap)
4292 {
4293     (void)handlemap;
4294     (void)toMap;
4295     if (toMap->pNext)
4296     {
4297         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4298     }
4299 }
4300 
handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(VulkanHandleMapping * handlemap,VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT * toMap)4301 void handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
4302     VulkanHandleMapping* handlemap,
4303     VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* toMap)
4304 {
4305     (void)handlemap;
4306     (void)toMap;
4307     if (toMap->pNext)
4308     {
4309         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4310     }
4311 }
4312 
4313 #endif
4314 #ifdef VK_AMD_gpu_shader_int16
4315 #endif
4316 #ifdef VK_AMD_mixed_attachment_samples
4317 #endif
4318 #ifdef VK_AMD_shader_fragment_mask
4319 #endif
4320 #ifdef VK_EXT_shader_stencil_export
4321 #endif
4322 #ifdef VK_EXT_sample_locations
handlemap_VkSampleLocationEXT(VulkanHandleMapping * handlemap,VkSampleLocationEXT * toMap)4323 void handlemap_VkSampleLocationEXT(
4324     VulkanHandleMapping* handlemap,
4325     VkSampleLocationEXT* toMap)
4326 {
4327     (void)handlemap;
4328     (void)toMap;
4329 }
4330 
handlemap_VkSampleLocationsInfoEXT(VulkanHandleMapping * handlemap,VkSampleLocationsInfoEXT * toMap)4331 void handlemap_VkSampleLocationsInfoEXT(
4332     VulkanHandleMapping* handlemap,
4333     VkSampleLocationsInfoEXT* toMap)
4334 {
4335     (void)handlemap;
4336     (void)toMap;
4337     if (toMap->pNext)
4338     {
4339         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4340     }
4341     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->sampleLocationGridSize));
4342     if (toMap->pSampleLocations)
4343     {
4344         for (uint32_t i = 0; i < (uint32_t)toMap->sampleLocationsCount; ++i)
4345         {
4346             handlemap_VkSampleLocationEXT(handlemap, (VkSampleLocationEXT*)(toMap->pSampleLocations + i));
4347         }
4348     }
4349 }
4350 
handlemap_VkAttachmentSampleLocationsEXT(VulkanHandleMapping * handlemap,VkAttachmentSampleLocationsEXT * toMap)4351 void handlemap_VkAttachmentSampleLocationsEXT(
4352     VulkanHandleMapping* handlemap,
4353     VkAttachmentSampleLocationsEXT* toMap)
4354 {
4355     (void)handlemap;
4356     (void)toMap;
4357     handlemap_VkSampleLocationsInfoEXT(handlemap, (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
4358 }
4359 
handlemap_VkSubpassSampleLocationsEXT(VulkanHandleMapping * handlemap,VkSubpassSampleLocationsEXT * toMap)4360 void handlemap_VkSubpassSampleLocationsEXT(
4361     VulkanHandleMapping* handlemap,
4362     VkSubpassSampleLocationsEXT* toMap)
4363 {
4364     (void)handlemap;
4365     (void)toMap;
4366     handlemap_VkSampleLocationsInfoEXT(handlemap, (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
4367 }
4368 
handlemap_VkRenderPassSampleLocationsBeginInfoEXT(VulkanHandleMapping * handlemap,VkRenderPassSampleLocationsBeginInfoEXT * toMap)4369 void handlemap_VkRenderPassSampleLocationsBeginInfoEXT(
4370     VulkanHandleMapping* handlemap,
4371     VkRenderPassSampleLocationsBeginInfoEXT* toMap)
4372 {
4373     (void)handlemap;
4374     (void)toMap;
4375     if (toMap->pNext)
4376     {
4377         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4378     }
4379     if (toMap->pAttachmentInitialSampleLocations)
4380     {
4381         for (uint32_t i = 0; i < (uint32_t)toMap->attachmentInitialSampleLocationsCount; ++i)
4382         {
4383             handlemap_VkAttachmentSampleLocationsEXT(handlemap, (VkAttachmentSampleLocationsEXT*)(toMap->pAttachmentInitialSampleLocations + i));
4384         }
4385     }
4386     if (toMap->pPostSubpassSampleLocations)
4387     {
4388         for (uint32_t i = 0; i < (uint32_t)toMap->postSubpassSampleLocationsCount; ++i)
4389         {
4390             handlemap_VkSubpassSampleLocationsEXT(handlemap, (VkSubpassSampleLocationsEXT*)(toMap->pPostSubpassSampleLocations + i));
4391         }
4392     }
4393 }
4394 
handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(VulkanHandleMapping * handlemap,VkPipelineSampleLocationsStateCreateInfoEXT * toMap)4395 void handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(
4396     VulkanHandleMapping* handlemap,
4397     VkPipelineSampleLocationsStateCreateInfoEXT* toMap)
4398 {
4399     (void)handlemap;
4400     (void)toMap;
4401     if (toMap->pNext)
4402     {
4403         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4404     }
4405     handlemap_VkSampleLocationsInfoEXT(handlemap, (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
4406 }
4407 
handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(VulkanHandleMapping * handlemap,VkPhysicalDeviceSampleLocationsPropertiesEXT * toMap)4408 void handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(
4409     VulkanHandleMapping* handlemap,
4410     VkPhysicalDeviceSampleLocationsPropertiesEXT* toMap)
4411 {
4412     (void)handlemap;
4413     (void)toMap;
4414     if (toMap->pNext)
4415     {
4416         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4417     }
4418     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxSampleLocationGridSize));
4419 }
4420 
handlemap_VkMultisamplePropertiesEXT(VulkanHandleMapping * handlemap,VkMultisamplePropertiesEXT * toMap)4421 void handlemap_VkMultisamplePropertiesEXT(
4422     VulkanHandleMapping* handlemap,
4423     VkMultisamplePropertiesEXT* toMap)
4424 {
4425     (void)handlemap;
4426     (void)toMap;
4427     if (toMap->pNext)
4428     {
4429         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4430     }
4431     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxSampleLocationGridSize));
4432 }
4433 
4434 #endif
4435 #ifdef VK_EXT_blend_operation_advanced
handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(VulkanHandleMapping * handlemap,VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT * toMap)4436 void handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
4437     VulkanHandleMapping* handlemap,
4438     VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toMap)
4439 {
4440     (void)handlemap;
4441     (void)toMap;
4442     if (toMap->pNext)
4443     {
4444         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4445     }
4446 }
4447 
handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(VulkanHandleMapping * handlemap,VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT * toMap)4448 void handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
4449     VulkanHandleMapping* handlemap,
4450     VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toMap)
4451 {
4452     (void)handlemap;
4453     (void)toMap;
4454     if (toMap->pNext)
4455     {
4456         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4457     }
4458 }
4459 
handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(VulkanHandleMapping * handlemap,VkPipelineColorBlendAdvancedStateCreateInfoEXT * toMap)4460 void handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
4461     VulkanHandleMapping* handlemap,
4462     VkPipelineColorBlendAdvancedStateCreateInfoEXT* toMap)
4463 {
4464     (void)handlemap;
4465     (void)toMap;
4466     if (toMap->pNext)
4467     {
4468         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4469     }
4470 }
4471 
4472 #endif
4473 #ifdef VK_NV_fragment_coverage_to_color
handlemap_VkPipelineCoverageToColorStateCreateInfoNV(VulkanHandleMapping * handlemap,VkPipelineCoverageToColorStateCreateInfoNV * toMap)4474 void handlemap_VkPipelineCoverageToColorStateCreateInfoNV(
4475     VulkanHandleMapping* handlemap,
4476     VkPipelineCoverageToColorStateCreateInfoNV* toMap)
4477 {
4478     (void)handlemap;
4479     (void)toMap;
4480     if (toMap->pNext)
4481     {
4482         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4483     }
4484 }
4485 
4486 #endif
4487 #ifdef VK_NV_framebuffer_mixed_samples
handlemap_VkPipelineCoverageModulationStateCreateInfoNV(VulkanHandleMapping * handlemap,VkPipelineCoverageModulationStateCreateInfoNV * toMap)4488 void handlemap_VkPipelineCoverageModulationStateCreateInfoNV(
4489     VulkanHandleMapping* handlemap,
4490     VkPipelineCoverageModulationStateCreateInfoNV* toMap)
4491 {
4492     (void)handlemap;
4493     (void)toMap;
4494     if (toMap->pNext)
4495     {
4496         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4497     }
4498 }
4499 
4500 #endif
4501 #ifdef VK_NV_fill_rectangle
4502 #endif
4503 #ifdef VK_EXT_post_depth_coverage
4504 #endif
4505 #ifdef VK_EXT_validation_cache
handlemap_VkValidationCacheCreateInfoEXT(VulkanHandleMapping * handlemap,VkValidationCacheCreateInfoEXT * toMap)4506 void handlemap_VkValidationCacheCreateInfoEXT(
4507     VulkanHandleMapping* handlemap,
4508     VkValidationCacheCreateInfoEXT* toMap)
4509 {
4510     (void)handlemap;
4511     (void)toMap;
4512     if (toMap->pNext)
4513     {
4514         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4515     }
4516 }
4517 
handlemap_VkShaderModuleValidationCacheCreateInfoEXT(VulkanHandleMapping * handlemap,VkShaderModuleValidationCacheCreateInfoEXT * toMap)4518 void handlemap_VkShaderModuleValidationCacheCreateInfoEXT(
4519     VulkanHandleMapping* handlemap,
4520     VkShaderModuleValidationCacheCreateInfoEXT* toMap)
4521 {
4522     (void)handlemap;
4523     (void)toMap;
4524     if (toMap->pNext)
4525     {
4526         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4527     }
4528     handlemap->mapHandles_VkValidationCacheEXT((VkValidationCacheEXT*)&toMap->validationCache);
4529 }
4530 
4531 #endif
4532 #ifdef VK_EXT_descriptor_indexing
handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(VulkanHandleMapping * handlemap,VkDescriptorSetLayoutBindingFlagsCreateInfoEXT * toMap)4533 void handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
4534     VulkanHandleMapping* handlemap,
4535     VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* toMap)
4536 {
4537     (void)handlemap;
4538     (void)toMap;
4539     if (toMap->pNext)
4540     {
4541         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4542     }
4543 }
4544 
handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(VulkanHandleMapping * handlemap,VkPhysicalDeviceDescriptorIndexingFeaturesEXT * toMap)4545 void handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
4546     VulkanHandleMapping* handlemap,
4547     VkPhysicalDeviceDescriptorIndexingFeaturesEXT* toMap)
4548 {
4549     (void)handlemap;
4550     (void)toMap;
4551     if (toMap->pNext)
4552     {
4553         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4554     }
4555 }
4556 
handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(VulkanHandleMapping * handlemap,VkPhysicalDeviceDescriptorIndexingPropertiesEXT * toMap)4557 void handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
4558     VulkanHandleMapping* handlemap,
4559     VkPhysicalDeviceDescriptorIndexingPropertiesEXT* toMap)
4560 {
4561     (void)handlemap;
4562     (void)toMap;
4563     if (toMap->pNext)
4564     {
4565         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4566     }
4567 }
4568 
handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(VulkanHandleMapping * handlemap,VkDescriptorSetVariableDescriptorCountAllocateInfoEXT * toMap)4569 void handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
4570     VulkanHandleMapping* handlemap,
4571     VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* toMap)
4572 {
4573     (void)handlemap;
4574     (void)toMap;
4575     if (toMap->pNext)
4576     {
4577         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4578     }
4579 }
4580 
handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(VulkanHandleMapping * handlemap,VkDescriptorSetVariableDescriptorCountLayoutSupportEXT * toMap)4581 void handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
4582     VulkanHandleMapping* handlemap,
4583     VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* toMap)
4584 {
4585     (void)handlemap;
4586     (void)toMap;
4587     if (toMap->pNext)
4588     {
4589         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4590     }
4591 }
4592 
4593 #endif
4594 #ifdef VK_EXT_shader_viewport_index_layer
4595 #endif
4596 #ifdef VK_EXT_global_priority
handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(VulkanHandleMapping * handlemap,VkDeviceQueueGlobalPriorityCreateInfoEXT * toMap)4597 void handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(
4598     VulkanHandleMapping* handlemap,
4599     VkDeviceQueueGlobalPriorityCreateInfoEXT* toMap)
4600 {
4601     (void)handlemap;
4602     (void)toMap;
4603     if (toMap->pNext)
4604     {
4605         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4606     }
4607 }
4608 
4609 #endif
4610 #ifdef VK_EXT_external_memory_host
handlemap_VkImportMemoryHostPointerInfoEXT(VulkanHandleMapping * handlemap,VkImportMemoryHostPointerInfoEXT * toMap)4611 void handlemap_VkImportMemoryHostPointerInfoEXT(
4612     VulkanHandleMapping* handlemap,
4613     VkImportMemoryHostPointerInfoEXT* toMap)
4614 {
4615     (void)handlemap;
4616     (void)toMap;
4617     if (toMap->pNext)
4618     {
4619         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4620     }
4621 }
4622 
handlemap_VkMemoryHostPointerPropertiesEXT(VulkanHandleMapping * handlemap,VkMemoryHostPointerPropertiesEXT * toMap)4623 void handlemap_VkMemoryHostPointerPropertiesEXT(
4624     VulkanHandleMapping* handlemap,
4625     VkMemoryHostPointerPropertiesEXT* toMap)
4626 {
4627     (void)handlemap;
4628     (void)toMap;
4629     if (toMap->pNext)
4630     {
4631         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4632     }
4633 }
4634 
handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(VulkanHandleMapping * handlemap,VkPhysicalDeviceExternalMemoryHostPropertiesEXT * toMap)4635 void handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
4636     VulkanHandleMapping* handlemap,
4637     VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toMap)
4638 {
4639     (void)handlemap;
4640     (void)toMap;
4641     if (toMap->pNext)
4642     {
4643         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4644     }
4645 }
4646 
4647 #endif
4648 #ifdef VK_AMD_buffer_marker
4649 #endif
4650 #ifdef VK_AMD_shader_core_properties
handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(VulkanHandleMapping * handlemap,VkPhysicalDeviceShaderCorePropertiesAMD * toMap)4651 void handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(
4652     VulkanHandleMapping* handlemap,
4653     VkPhysicalDeviceShaderCorePropertiesAMD* toMap)
4654 {
4655     (void)handlemap;
4656     (void)toMap;
4657     if (toMap->pNext)
4658     {
4659         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4660     }
4661 }
4662 
4663 #endif
4664 #ifdef VK_EXT_vertex_attribute_divisor
handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(VulkanHandleMapping * handlemap,VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * toMap)4665 void handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
4666     VulkanHandleMapping* handlemap,
4667     VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toMap)
4668 {
4669     (void)handlemap;
4670     (void)toMap;
4671     if (toMap->pNext)
4672     {
4673         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4674     }
4675 }
4676 
handlemap_VkVertexInputBindingDivisorDescriptionEXT(VulkanHandleMapping * handlemap,VkVertexInputBindingDivisorDescriptionEXT * toMap)4677 void handlemap_VkVertexInputBindingDivisorDescriptionEXT(
4678     VulkanHandleMapping* handlemap,
4679     VkVertexInputBindingDivisorDescriptionEXT* toMap)
4680 {
4681     (void)handlemap;
4682     (void)toMap;
4683 }
4684 
handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(VulkanHandleMapping * handlemap,VkPipelineVertexInputDivisorStateCreateInfoEXT * toMap)4685 void handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(
4686     VulkanHandleMapping* handlemap,
4687     VkPipelineVertexInputDivisorStateCreateInfoEXT* toMap)
4688 {
4689     (void)handlemap;
4690     (void)toMap;
4691     if (toMap->pNext)
4692     {
4693         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4694     }
4695     if (toMap->pVertexBindingDivisors)
4696     {
4697         for (uint32_t i = 0; i < (uint32_t)toMap->vertexBindingDivisorCount; ++i)
4698         {
4699             handlemap_VkVertexInputBindingDivisorDescriptionEXT(handlemap, (VkVertexInputBindingDivisorDescriptionEXT*)(toMap->pVertexBindingDivisors + i));
4700         }
4701     }
4702 }
4703 
4704 #endif
4705 #ifdef VK_NV_shader_subgroup_partitioned
4706 #endif
4707 #ifdef VK_NV_device_diagnostic_checkpoints
handlemap_VkQueueFamilyCheckpointPropertiesNV(VulkanHandleMapping * handlemap,VkQueueFamilyCheckpointPropertiesNV * toMap)4708 void handlemap_VkQueueFamilyCheckpointPropertiesNV(
4709     VulkanHandleMapping* handlemap,
4710     VkQueueFamilyCheckpointPropertiesNV* toMap)
4711 {
4712     (void)handlemap;
4713     (void)toMap;
4714     if (toMap->pNext)
4715     {
4716         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4717     }
4718 }
4719 
handlemap_VkCheckpointDataNV(VulkanHandleMapping * handlemap,VkCheckpointDataNV * toMap)4720 void handlemap_VkCheckpointDataNV(
4721     VulkanHandleMapping* handlemap,
4722     VkCheckpointDataNV* toMap)
4723 {
4724     (void)handlemap;
4725     (void)toMap;
4726     if (toMap->pNext)
4727     {
4728         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4729     }
4730 }
4731 
4732 #endif
4733 #ifdef VK_GOOGLE_address_space
4734 #endif
4735 #ifdef VK_GOOGLE_color_buffer
handlemap_VkImportColorBufferGOOGLE(VulkanHandleMapping * handlemap,VkImportColorBufferGOOGLE * toMap)4736 void handlemap_VkImportColorBufferGOOGLE(
4737     VulkanHandleMapping* handlemap,
4738     VkImportColorBufferGOOGLE* toMap)
4739 {
4740     (void)handlemap;
4741     (void)toMap;
4742     if (toMap->pNext)
4743     {
4744         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4745     }
4746 }
4747 
handlemap_VkImportBufferGOOGLE(VulkanHandleMapping * handlemap,VkImportBufferGOOGLE * toMap)4748 void handlemap_VkImportBufferGOOGLE(
4749     VulkanHandleMapping* handlemap,
4750     VkImportBufferGOOGLE* toMap)
4751 {
4752     (void)handlemap;
4753     (void)toMap;
4754     if (toMap->pNext)
4755     {
4756         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4757     }
4758 }
4759 
handlemap_VkImportPhysicalAddressGOOGLE(VulkanHandleMapping * handlemap,VkImportPhysicalAddressGOOGLE * toMap)4760 void handlemap_VkImportPhysicalAddressGOOGLE(
4761     VulkanHandleMapping* handlemap,
4762     VkImportPhysicalAddressGOOGLE* toMap)
4763 {
4764     (void)handlemap;
4765     (void)toMap;
4766     if (toMap->pNext)
4767     {
4768         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
4769     }
4770 }
4771 
4772 #endif
4773 #ifdef VK_GOOGLE_sized_descriptor_update_template
4774 #endif
4775 #ifdef VK_GOOGLE_async_command_buffers
4776 #endif
4777 #ifdef VK_GOOGLE_create_resources_with_requirements
4778 #endif
4779 #ifdef VK_GOOGLE_address_space_info
4780 #endif
4781 #ifdef VK_GOOGLE_free_memory_sync
4782 #endif
4783 #ifdef VK_GOOGLE_async_queue_submit
4784 #endif
handlemap_extension_struct(VulkanHandleMapping * handlemap,void * structExtension_out)4785 void handlemap_extension_struct(
4786     VulkanHandleMapping* handlemap,
4787     void* structExtension_out)
4788 {
4789     if (!structExtension_out)
4790     {
4791         return;
4792     }
4793     uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
4794     switch(structType)
4795     {
4796 #ifdef VK_VERSION_1_1
4797         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
4798         {
4799             handlemap_VkPhysicalDeviceSubgroupProperties(handlemap, reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
4800             break;
4801         }
4802         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
4803         {
4804             handlemap_VkPhysicalDevice16BitStorageFeatures(handlemap, reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
4805             break;
4806         }
4807         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
4808         {
4809             handlemap_VkMemoryDedicatedRequirements(handlemap, reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
4810             break;
4811         }
4812         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
4813         {
4814             handlemap_VkMemoryDedicatedAllocateInfo(handlemap, reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
4815             break;
4816         }
4817         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
4818         {
4819             handlemap_VkMemoryAllocateFlagsInfo(handlemap, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
4820             break;
4821         }
4822         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
4823         {
4824             handlemap_VkDeviceGroupRenderPassBeginInfo(handlemap, reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
4825             break;
4826         }
4827         case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
4828         {
4829             handlemap_VkDeviceGroupCommandBufferBeginInfo(handlemap, reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
4830             break;
4831         }
4832         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
4833         {
4834             handlemap_VkDeviceGroupSubmitInfo(handlemap, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
4835             break;
4836         }
4837         case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
4838         {
4839             handlemap_VkDeviceGroupBindSparseInfo(handlemap, reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
4840             break;
4841         }
4842         case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
4843         {
4844             handlemap_VkBindBufferMemoryDeviceGroupInfo(handlemap, reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
4845             break;
4846         }
4847         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
4848         {
4849             handlemap_VkBindImageMemoryDeviceGroupInfo(handlemap, reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
4850             break;
4851         }
4852         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
4853         {
4854             handlemap_VkDeviceGroupDeviceCreateInfo(handlemap, reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
4855             break;
4856         }
4857         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
4858         {
4859             handlemap_VkPhysicalDeviceFeatures2(handlemap, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
4860             break;
4861         }
4862         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
4863         {
4864             handlemap_VkPhysicalDevicePointClippingProperties(handlemap, reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
4865             break;
4866         }
4867         case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
4868         {
4869             handlemap_VkRenderPassInputAttachmentAspectCreateInfo(handlemap, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
4870             break;
4871         }
4872         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
4873         {
4874             handlemap_VkImageViewUsageCreateInfo(handlemap, reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
4875             break;
4876         }
4877         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
4878         {
4879             handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(handlemap, reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
4880             break;
4881         }
4882         case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
4883         {
4884             handlemap_VkRenderPassMultiviewCreateInfo(handlemap, reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
4885             break;
4886         }
4887         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
4888         {
4889             handlemap_VkPhysicalDeviceMultiviewFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
4890             break;
4891         }
4892         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
4893         {
4894             handlemap_VkPhysicalDeviceMultiviewProperties(handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
4895             break;
4896         }
4897         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES:
4898         {
4899             handlemap_VkPhysicalDeviceVariablePointerFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceVariablePointerFeatures*>(structExtension_out));
4900             break;
4901         }
4902         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
4903         {
4904             handlemap_VkPhysicalDeviceProtectedMemoryFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
4905             break;
4906         }
4907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
4908         {
4909             handlemap_VkPhysicalDeviceProtectedMemoryProperties(handlemap, reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
4910             break;
4911         }
4912         case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
4913         {
4914             handlemap_VkProtectedSubmitInfo(handlemap, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
4915             break;
4916         }
4917         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
4918         {
4919             handlemap_VkSamplerYcbcrConversionInfo(handlemap, reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
4920             break;
4921         }
4922         case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
4923         {
4924             handlemap_VkBindImagePlaneMemoryInfo(handlemap, reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
4925             break;
4926         }
4927         case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
4928         {
4929             handlemap_VkImagePlaneMemoryRequirementsInfo(handlemap, reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
4930             break;
4931         }
4932         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
4933         {
4934             handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
4935             break;
4936         }
4937         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
4938         {
4939             handlemap_VkSamplerYcbcrConversionImageFormatProperties(handlemap, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
4940             break;
4941         }
4942         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
4943         {
4944             handlemap_VkPhysicalDeviceExternalImageFormatInfo(handlemap, reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
4945             break;
4946         }
4947         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
4948         {
4949             handlemap_VkExternalImageFormatProperties(handlemap, reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
4950             break;
4951         }
4952         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
4953         {
4954             handlemap_VkPhysicalDeviceIDProperties(handlemap, reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
4955             break;
4956         }
4957         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
4958         {
4959             handlemap_VkExternalMemoryImageCreateInfo(handlemap, reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
4960             break;
4961         }
4962         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
4963         {
4964             handlemap_VkExternalMemoryBufferCreateInfo(handlemap, reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
4965             break;
4966         }
4967         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
4968         {
4969             handlemap_VkExportMemoryAllocateInfo(handlemap, reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
4970             break;
4971         }
4972         case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
4973         {
4974             handlemap_VkExportFenceCreateInfo(handlemap, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
4975             break;
4976         }
4977         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
4978         {
4979             handlemap_VkExportSemaphoreCreateInfo(handlemap, reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
4980             break;
4981         }
4982         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
4983         {
4984             handlemap_VkPhysicalDeviceMaintenance3Properties(handlemap, reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
4985             break;
4986         }
4987         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES:
4988         {
4989             handlemap_VkPhysicalDeviceShaderDrawParameterFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures*>(structExtension_out));
4990             break;
4991         }
4992 #endif
4993 #ifdef VK_KHR_swapchain
4994         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
4995         {
4996             handlemap_VkImageSwapchainCreateInfoKHR(handlemap, reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
4997             break;
4998         }
4999         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
5000         {
5001             handlemap_VkBindImageMemorySwapchainInfoKHR(handlemap, reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
5002             break;
5003         }
5004         case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
5005         {
5006             handlemap_VkDeviceGroupPresentInfoKHR(handlemap, reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
5007             break;
5008         }
5009         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
5010         {
5011             handlemap_VkDeviceGroupSwapchainCreateInfoKHR(handlemap, reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
5012             break;
5013         }
5014 #endif
5015 #ifdef VK_KHR_display_swapchain
5016         case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
5017         {
5018             handlemap_VkDisplayPresentInfoKHR(handlemap, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
5019             break;
5020         }
5021 #endif
5022 #ifdef VK_KHR_external_memory_win32
5023         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
5024         {
5025             handlemap_VkImportMemoryWin32HandleInfoKHR(handlemap, reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
5026             break;
5027         }
5028         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
5029         {
5030             handlemap_VkExportMemoryWin32HandleInfoKHR(handlemap, reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
5031             break;
5032         }
5033 #endif
5034 #ifdef VK_KHR_external_memory_fd
5035         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
5036         {
5037             handlemap_VkImportMemoryFdInfoKHR(handlemap, reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
5038             break;
5039         }
5040 #endif
5041 #ifdef VK_KHR_win32_keyed_mutex
5042         case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
5043         {
5044             handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(handlemap, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
5045             break;
5046         }
5047 #endif
5048 #ifdef VK_KHR_external_semaphore_win32
5049         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
5050         {
5051             handlemap_VkExportSemaphoreWin32HandleInfoKHR(handlemap, reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
5052             break;
5053         }
5054         case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
5055         {
5056             handlemap_VkD3D12FenceSubmitInfoKHR(handlemap, reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
5057             break;
5058         }
5059 #endif
5060 #ifdef VK_KHR_push_descriptor
5061         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
5062         {
5063             handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(handlemap, reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
5064             break;
5065         }
5066 #endif
5067 #ifdef VK_KHR_incremental_present
5068         case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
5069         {
5070             handlemap_VkPresentRegionsKHR(handlemap, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
5071             break;
5072         }
5073 #endif
5074 #ifdef VK_KHR_shared_presentable_image
5075         case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
5076         {
5077             handlemap_VkSharedPresentSurfaceCapabilitiesKHR(handlemap, reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
5078             break;
5079         }
5080 #endif
5081 #ifdef VK_KHR_external_fence_win32
5082         case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
5083         {
5084             handlemap_VkExportFenceWin32HandleInfoKHR(handlemap, reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
5085             break;
5086         }
5087 #endif
5088 #ifdef VK_KHR_image_format_list
5089         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
5090         {
5091             handlemap_VkImageFormatListCreateInfoKHR(handlemap, reinterpret_cast<VkImageFormatListCreateInfoKHR*>(structExtension_out));
5092             break;
5093         }
5094 #endif
5095 #ifdef VK_KHR_8bit_storage
5096         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
5097         {
5098             handlemap_VkPhysicalDevice8BitStorageFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(structExtension_out));
5099             break;
5100         }
5101 #endif
5102 #ifdef VK_KHR_shader_float16_int8
5103         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
5104         {
5105             handlemap_VkPhysicalDeviceShaderFloat16Int8Features(handlemap, reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
5106             break;
5107         }
5108 #endif
5109 #ifdef VK_ANDROID_native_buffer
5110         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
5111         {
5112             handlemap_VkNativeBufferANDROID(handlemap, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
5113             break;
5114         }
5115 #endif
5116 #ifdef VK_EXT_debug_report
5117         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
5118         {
5119             handlemap_VkDebugReportCallbackCreateInfoEXT(handlemap, reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
5120             break;
5121         }
5122 #endif
5123 #ifdef VK_AMD_rasterization_order
5124         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
5125         {
5126             handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(handlemap, reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
5127             break;
5128         }
5129 #endif
5130 #ifdef VK_NV_dedicated_allocation
5131         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
5132         {
5133             handlemap_VkDedicatedAllocationImageCreateInfoNV(handlemap, reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
5134             break;
5135         }
5136         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
5137         {
5138             handlemap_VkDedicatedAllocationBufferCreateInfoNV(handlemap, reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
5139             break;
5140         }
5141         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
5142         {
5143             handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(handlemap, reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
5144             break;
5145         }
5146 #endif
5147 #ifdef VK_AMD_texture_gather_bias_lod
5148         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
5149         {
5150             handlemap_VkTextureLODGatherFormatPropertiesAMD(handlemap, reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
5151             break;
5152         }
5153 #endif
5154 #ifdef VK_NV_external_memory
5155         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
5156         {
5157             handlemap_VkExternalMemoryImageCreateInfoNV(handlemap, reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
5158             break;
5159         }
5160         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
5161         {
5162             handlemap_VkExportMemoryAllocateInfoNV(handlemap, reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
5163             break;
5164         }
5165 #endif
5166 #ifdef VK_NV_external_memory_win32
5167         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
5168         {
5169             handlemap_VkImportMemoryWin32HandleInfoNV(handlemap, reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
5170             break;
5171         }
5172         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
5173         {
5174             handlemap_VkExportMemoryWin32HandleInfoNV(handlemap, reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
5175             break;
5176         }
5177 #endif
5178 #ifdef VK_NV_win32_keyed_mutex
5179         case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
5180         {
5181             handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(handlemap, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
5182             break;
5183         }
5184 #endif
5185 #ifdef VK_EXT_validation_flags
5186         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
5187         {
5188             handlemap_VkValidationFlagsEXT(handlemap, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
5189             break;
5190         }
5191 #endif
5192 #ifdef VK_EXT_conditional_rendering
5193         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
5194         {
5195             handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
5196             break;
5197         }
5198         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
5199         {
5200             handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(handlemap, reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
5201             break;
5202         }
5203 #endif
5204 #ifdef VK_NV_clip_space_w_scaling
5205         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
5206         {
5207             handlemap_VkPipelineViewportWScalingStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
5208             break;
5209         }
5210 #endif
5211 #ifdef VK_EXT_display_control
5212         case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
5213         {
5214             handlemap_VkSwapchainCounterCreateInfoEXT(handlemap, reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
5215             break;
5216         }
5217 #endif
5218 #ifdef VK_GOOGLE_display_timing
5219         case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
5220         {
5221             handlemap_VkPresentTimesInfoGOOGLE(handlemap, reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
5222             break;
5223         }
5224 #endif
5225 #ifdef VK_NVX_multiview_per_view_attributes
5226         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
5227         {
5228             handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
5229             break;
5230         }
5231 #endif
5232 #ifdef VK_NV_viewport_swizzle
5233         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
5234         {
5235             handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
5236             break;
5237         }
5238 #endif
5239 #ifdef VK_EXT_discard_rectangles
5240         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
5241         {
5242             handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
5243             break;
5244         }
5245         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
5246         {
5247             handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
5248             break;
5249         }
5250 #endif
5251 #ifdef VK_EXT_conservative_rasterization
5252         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
5253         {
5254             handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
5255             break;
5256         }
5257         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
5258         {
5259             handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
5260             break;
5261         }
5262 #endif
5263 #ifdef VK_EXT_debug_utils
5264         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
5265         {
5266             handlemap_VkDebugUtilsMessengerCreateInfoEXT(handlemap, reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
5267             break;
5268         }
5269 #endif
5270 #ifdef VK_ANDROID_external_memory_android_hardware_buffer
5271         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
5272         {
5273             handlemap_VkAndroidHardwareBufferUsageANDROID(handlemap, reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
5274             break;
5275         }
5276         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
5277         {
5278             handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(handlemap, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
5279             break;
5280         }
5281         case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
5282         {
5283             handlemap_VkImportAndroidHardwareBufferInfoANDROID(handlemap, reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
5284             break;
5285         }
5286         case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
5287         {
5288             handlemap_VkExternalFormatANDROID(handlemap, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
5289             break;
5290         }
5291 #endif
5292 #ifdef VK_EXT_sampler_filter_minmax
5293         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
5294         {
5295             handlemap_VkSamplerReductionModeCreateInfoEXT(handlemap, reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(structExtension_out));
5296             break;
5297         }
5298         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
5299         {
5300             handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(structExtension_out));
5301             break;
5302         }
5303 #endif
5304 #ifdef VK_EXT_sample_locations
5305         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
5306         {
5307             handlemap_VkSampleLocationsInfoEXT(handlemap, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
5308             break;
5309         }
5310         case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
5311         {
5312             handlemap_VkRenderPassSampleLocationsBeginInfoEXT(handlemap, reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
5313             break;
5314         }
5315         case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
5316         {
5317             handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
5318             break;
5319         }
5320         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
5321         {
5322             handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
5323             break;
5324         }
5325 #endif
5326 #ifdef VK_EXT_blend_operation_advanced
5327         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
5328         {
5329             handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
5330             break;
5331         }
5332         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
5333         {
5334             handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
5335             break;
5336         }
5337         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
5338         {
5339             handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
5340             break;
5341         }
5342 #endif
5343 #ifdef VK_NV_fragment_coverage_to_color
5344         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
5345         {
5346             handlemap_VkPipelineCoverageToColorStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
5347             break;
5348         }
5349 #endif
5350 #ifdef VK_NV_framebuffer_mixed_samples
5351         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
5352         {
5353             handlemap_VkPipelineCoverageModulationStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
5354             break;
5355         }
5356 #endif
5357 #ifdef VK_EXT_validation_cache
5358         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
5359         {
5360             handlemap_VkShaderModuleValidationCacheCreateInfoEXT(handlemap, reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
5361             break;
5362         }
5363 #endif
5364 #ifdef VK_EXT_descriptor_indexing
5365         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
5366         {
5367             handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(handlemap, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(structExtension_out));
5368             break;
5369         }
5370         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
5371         {
5372             handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(structExtension_out));
5373             break;
5374         }
5375         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
5376         {
5377             handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(structExtension_out));
5378             break;
5379         }
5380         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
5381         {
5382             handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(handlemap, reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(structExtension_out));
5383             break;
5384         }
5385         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
5386         {
5387             handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(handlemap, reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(structExtension_out));
5388             break;
5389         }
5390 #endif
5391 #ifdef VK_EXT_global_priority
5392         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
5393         {
5394             handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(handlemap, reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
5395             break;
5396         }
5397 #endif
5398 #ifdef VK_EXT_external_memory_host
5399         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
5400         {
5401             handlemap_VkImportMemoryHostPointerInfoEXT(handlemap, reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
5402             break;
5403         }
5404         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
5405         {
5406             handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
5407             break;
5408         }
5409 #endif
5410 #ifdef VK_AMD_shader_core_properties
5411         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
5412         {
5413             handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(handlemap, reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
5414             break;
5415         }
5416 #endif
5417 #ifdef VK_EXT_vertex_attribute_divisor
5418         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
5419         {
5420             handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
5421             break;
5422         }
5423         case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
5424         {
5425             handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
5426             break;
5427         }
5428 #endif
5429 #ifdef VK_NV_device_diagnostic_checkpoints
5430         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
5431         {
5432             handlemap_VkQueueFamilyCheckpointPropertiesNV(handlemap, reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
5433             break;
5434         }
5435 #endif
5436 #ifdef VK_GOOGLE_color_buffer
5437         case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
5438         {
5439             handlemap_VkImportColorBufferGOOGLE(handlemap, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
5440             break;
5441         }
5442         case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
5443         {
5444             handlemap_VkImportBufferGOOGLE(handlemap, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
5445             break;
5446         }
5447         case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
5448         {
5449             handlemap_VkImportPhysicalAddressGOOGLE(handlemap, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
5450             break;
5451         }
5452 #endif
5453         default:
5454         {
5455             return;
5456         }
5457     }
5458 }
5459 
5460 
5461 } // namespace goldfish_vk
5462