system/vulkan_enc/goldfish_vk_handlemap_guest.cpp

// Copyright (C) 2018 The Android Open Source Project
// Copyright (C) 2018 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Autogenerated module goldfish_vk_handlemap_guest
// (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
// Please do not modify directly;
// re-run android/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR

#include "goldfish_vk_handlemap_guest.h"


#include "goldfish_vk_extension_structs_guest.h"
#include "goldfish_vk_private_defs.h"


namespace goldfish_vk {

void handlemap_extension_struct(
    VulkanHandleMapping* handlemap,
    void* structExtension_out);

#ifdef VK_VERSION_1_0
void handlemap_VkApplicationInfo(
    VulkanHandleMapping* handlemap,
    VkApplicationInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkInstanceCreateInfo(
    VulkanHandleMapping* handlemap,
    VkInstanceCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pApplicationInfo)
    {
        handlemap_VkApplicationInfo(handlemap, (VkApplicationInfo*)(toMap->pApplicationInfo));
    }
}

void handlemap_VkAllocationCallbacks(
    VulkanHandleMapping* handlemap,
    VkAllocationCallbacks* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkPhysicalDeviceFeatures(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceFeatures* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkFormatProperties(
    VulkanHandleMapping* handlemap,
    VkFormatProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkExtent3D(
    VulkanHandleMapping* handlemap,
    VkExtent3D* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkImageFormatProperties(
    VulkanHandleMapping* handlemap,
    VkImageFormatProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->maxExtent));
}

void handlemap_VkPhysicalDeviceLimits(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceLimits* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkPhysicalDeviceSparseProperties(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceSparseProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkPhysicalDeviceProperties(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkPhysicalDeviceLimits(handlemap, (VkPhysicalDeviceLimits*)(&toMap->limits));
    handlemap_VkPhysicalDeviceSparseProperties(handlemap, (VkPhysicalDeviceSparseProperties*)(&toMap->sparseProperties));
}

void handlemap_VkQueueFamilyProperties(
    VulkanHandleMapping* handlemap,
    VkQueueFamilyProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->minImageTransferGranularity));
}

void handlemap_VkMemoryType(
    VulkanHandleMapping* handlemap,
    VkMemoryType* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkMemoryHeap(
    VulkanHandleMapping* handlemap,
    VkMemoryHeap* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkPhysicalDeviceMemoryProperties(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceMemoryProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
    {
        handlemap_VkMemoryType(handlemap, (VkMemoryType*)(toMap->memoryTypes + i));
    }
    for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
    {
        handlemap_VkMemoryHeap(handlemap, (VkMemoryHeap*)(toMap->memoryHeaps + i));
    }
}

void handlemap_VkDeviceQueueCreateInfo(
    VulkanHandleMapping* handlemap,
    VkDeviceQueueCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkDeviceCreateInfo(
    VulkanHandleMapping* handlemap,
    VkDeviceCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pQueueCreateInfos)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->queueCreateInfoCount; ++i)
        {
            handlemap_VkDeviceQueueCreateInfo(handlemap, (VkDeviceQueueCreateInfo*)(toMap->pQueueCreateInfos + i));
        }
    }
    if (toMap->pEnabledFeatures)
    {
        handlemap_VkPhysicalDeviceFeatures(handlemap, (VkPhysicalDeviceFeatures*)(toMap->pEnabledFeatures));
    }
}

void handlemap_VkExtensionProperties(
    VulkanHandleMapping* handlemap,
    VkExtensionProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkLayerProperties(
    VulkanHandleMapping* handlemap,
    VkLayerProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkSubmitInfo(
    VulkanHandleMapping* handlemap,
    VkSubmitInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pWaitSemaphores)
    {
        handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
    }
    if (toMap->pCommandBuffers)
    {
        handlemap->mapHandles_VkCommandBuffer((VkCommandBuffer*)toMap->pCommandBuffers, toMap->commandBufferCount);
    }
    if (toMap->pSignalSemaphores)
    {
        handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSignalSemaphores, toMap->signalSemaphoreCount);
    }
}

void handlemap_VkMemoryAllocateInfo(
    VulkanHandleMapping* handlemap,
    VkMemoryAllocateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkMappedMemoryRange(
    VulkanHandleMapping* handlemap,
    VkMappedMemoryRange* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}

void handlemap_VkMemoryRequirements(
    VulkanHandleMapping* handlemap,
    VkMemoryRequirements* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkSparseImageFormatProperties(
    VulkanHandleMapping* handlemap,
    VkSparseImageFormatProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageGranularity));
}

void handlemap_VkSparseImageMemoryRequirements(
    VulkanHandleMapping* handlemap,
    VkSparseImageMemoryRequirements* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkSparseImageFormatProperties(handlemap, (VkSparseImageFormatProperties*)(&toMap->formatProperties));
}

void handlemap_VkSparseMemoryBind(
    VulkanHandleMapping* handlemap,
    VkSparseMemoryBind* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}

void handlemap_VkSparseBufferMemoryBindInfo(
    VulkanHandleMapping* handlemap,
    VkSparseBufferMemoryBindInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
    if (toMap->pBinds)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
        {
            handlemap_VkSparseMemoryBind(handlemap, (VkSparseMemoryBind*)(toMap->pBinds + i));
        }
    }
}

void handlemap_VkSparseImageOpaqueMemoryBindInfo(
    VulkanHandleMapping* handlemap,
    VkSparseImageOpaqueMemoryBindInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
    if (toMap->pBinds)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
        {
            handlemap_VkSparseMemoryBind(handlemap, (VkSparseMemoryBind*)(toMap->pBinds + i));
        }
    }
}

void handlemap_VkImageSubresource(
    VulkanHandleMapping* handlemap,
    VkImageSubresource* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkOffset3D(
    VulkanHandleMapping* handlemap,
    VkOffset3D* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkSparseImageMemoryBind(
    VulkanHandleMapping* handlemap,
    VkSparseImageMemoryBind* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkImageSubresource(handlemap, (VkImageSubresource*)(&toMap->subresource));
    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->offset));
    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}

void handlemap_VkSparseImageMemoryBindInfo(
    VulkanHandleMapping* handlemap,
    VkSparseImageMemoryBindInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
    if (toMap->pBinds)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
        {
            handlemap_VkSparseImageMemoryBind(handlemap, (VkSparseImageMemoryBind*)(toMap->pBinds + i));
        }
    }
}

void handlemap_VkBindSparseInfo(
    VulkanHandleMapping* handlemap,
    VkBindSparseInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pWaitSemaphores)
    {
        handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
    }
    if (toMap->pBufferBinds)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->bufferBindCount; ++i)
        {
            handlemap_VkSparseBufferMemoryBindInfo(handlemap, (VkSparseBufferMemoryBindInfo*)(toMap->pBufferBinds + i));
        }
    }
    if (toMap->pImageOpaqueBinds)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->imageOpaqueBindCount; ++i)
        {
            handlemap_VkSparseImageOpaqueMemoryBindInfo(handlemap, (VkSparseImageOpaqueMemoryBindInfo*)(toMap->pImageOpaqueBinds + i));
        }
    }
    if (toMap->pImageBinds)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->imageBindCount; ++i)
        {
            handlemap_VkSparseImageMemoryBindInfo(handlemap, (VkSparseImageMemoryBindInfo*)(toMap->pImageBinds + i));
        }
    }
    if (toMap->pSignalSemaphores)
    {
        handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSignalSemaphores, toMap->signalSemaphoreCount);
    }
}

void handlemap_VkFenceCreateInfo(
    VulkanHandleMapping* handlemap,
    VkFenceCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkSemaphoreCreateInfo(
    VulkanHandleMapping* handlemap,
    VkSemaphoreCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkEventCreateInfo(
    VulkanHandleMapping* handlemap,
    VkEventCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkQueryPoolCreateInfo(
    VulkanHandleMapping* handlemap,
    VkQueryPoolCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkBufferCreateInfo(
    VulkanHandleMapping* handlemap,
    VkBufferCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkBufferViewCreateInfo(
    VulkanHandleMapping* handlemap,
    VkBufferViewCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}

void handlemap_VkImageCreateInfo(
    VulkanHandleMapping* handlemap,
    VkImageCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
}

void handlemap_VkSubresourceLayout(
    VulkanHandleMapping* handlemap,
    VkSubresourceLayout* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkComponentMapping(
    VulkanHandleMapping* handlemap,
    VkComponentMapping* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkImageSubresourceRange(
    VulkanHandleMapping* handlemap,
    VkImageSubresourceRange* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkImageViewCreateInfo(
    VulkanHandleMapping* handlemap,
    VkImageViewCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
    handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->components));
    handlemap_VkImageSubresourceRange(handlemap, (VkImageSubresourceRange*)(&toMap->subresourceRange));
}

void handlemap_VkShaderModuleCreateInfo(
    VulkanHandleMapping* handlemap,
    VkShaderModuleCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPipelineCacheCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineCacheCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkSpecializationMapEntry(
    VulkanHandleMapping* handlemap,
    VkSpecializationMapEntry* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkSpecializationInfo(
    VulkanHandleMapping* handlemap,
    VkSpecializationInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pMapEntries)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->mapEntryCount; ++i)
        {
            handlemap_VkSpecializationMapEntry(handlemap, (VkSpecializationMapEntry*)(toMap->pMapEntries + i));
        }
    }
}

void handlemap_VkPipelineShaderStageCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineShaderStageCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkShaderModule((VkShaderModule*)&toMap->module);
    if (toMap->pSpecializationInfo)
    {
        handlemap_VkSpecializationInfo(handlemap, (VkSpecializationInfo*)(toMap->pSpecializationInfo));
    }
}

void handlemap_VkVertexInputBindingDescription(
    VulkanHandleMapping* handlemap,
    VkVertexInputBindingDescription* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkVertexInputAttributeDescription(
    VulkanHandleMapping* handlemap,
    VkVertexInputAttributeDescription* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkPipelineVertexInputStateCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineVertexInputStateCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pVertexBindingDescriptions)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->vertexBindingDescriptionCount; ++i)
        {
            handlemap_VkVertexInputBindingDescription(handlemap, (VkVertexInputBindingDescription*)(toMap->pVertexBindingDescriptions + i));
        }
    }
    if (toMap->pVertexAttributeDescriptions)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->vertexAttributeDescriptionCount; ++i)
        {
            handlemap_VkVertexInputAttributeDescription(handlemap, (VkVertexInputAttributeDescription*)(toMap->pVertexAttributeDescriptions + i));
        }
    }
}

void handlemap_VkPipelineInputAssemblyStateCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineInputAssemblyStateCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPipelineTessellationStateCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineTessellationStateCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkViewport(
    VulkanHandleMapping* handlemap,
    VkViewport* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkOffset2D(
    VulkanHandleMapping* handlemap,
    VkOffset2D* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkExtent2D(
    VulkanHandleMapping* handlemap,
    VkExtent2D* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkRect2D(
    VulkanHandleMapping* handlemap,
    VkRect2D* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->offset));
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->extent));
}

void handlemap_VkPipelineViewportStateCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineViewportStateCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pViewports)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
        {
            handlemap_VkViewport(handlemap, (VkViewport*)(toMap->pViewports + i));
        }
    }
    if (toMap->pScissors)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->scissorCount; ++i)
        {
            handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pScissors + i));
        }
    }
}

void handlemap_VkPipelineRasterizationStateCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineRasterizationStateCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPipelineMultisampleStateCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineMultisampleStateCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkStencilOpState(
    VulkanHandleMapping* handlemap,
    VkStencilOpState* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkPipelineDepthStencilStateCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineDepthStencilStateCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkStencilOpState(handlemap, (VkStencilOpState*)(&toMap->front));
    handlemap_VkStencilOpState(handlemap, (VkStencilOpState*)(&toMap->back));
}

void handlemap_VkPipelineColorBlendAttachmentState(
    VulkanHandleMapping* handlemap,
    VkPipelineColorBlendAttachmentState* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkPipelineColorBlendStateCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineColorBlendStateCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pAttachments)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
        {
            handlemap_VkPipelineColorBlendAttachmentState(handlemap, (VkPipelineColorBlendAttachmentState*)(toMap->pAttachments + i));
        }
    }
}

void handlemap_VkPipelineDynamicStateCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineDynamicStateCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkGraphicsPipelineCreateInfo(
    VulkanHandleMapping* handlemap,
    VkGraphicsPipelineCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pStages)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->stageCount; ++i)
        {
            handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(toMap->pStages + i));
        }
    }
    if (toMap->pVertexInputState)
    {
        handlemap_VkPipelineVertexInputStateCreateInfo(handlemap, (VkPipelineVertexInputStateCreateInfo*)(toMap->pVertexInputState));
    }
    if (toMap->pInputAssemblyState)
    {
        handlemap_VkPipelineInputAssemblyStateCreateInfo(handlemap, (VkPipelineInputAssemblyStateCreateInfo*)(toMap->pInputAssemblyState));
    }
    if (toMap->pTessellationState)
    {
        handlemap_VkPipelineTessellationStateCreateInfo(handlemap, (VkPipelineTessellationStateCreateInfo*)(toMap->pTessellationState));
    }
    if (toMap->pViewportState)
    {
        handlemap_VkPipelineViewportStateCreateInfo(handlemap, (VkPipelineViewportStateCreateInfo*)(toMap->pViewportState));
    }
    if (toMap->pRasterizationState)
    {
        handlemap_VkPipelineRasterizationStateCreateInfo(handlemap, (VkPipelineRasterizationStateCreateInfo*)(toMap->pRasterizationState));
    }
    if (toMap->pMultisampleState)
    {
        handlemap_VkPipelineMultisampleStateCreateInfo(handlemap, (VkPipelineMultisampleStateCreateInfo*)(toMap->pMultisampleState));
    }
    if (toMap->pDepthStencilState)
    {
        handlemap_VkPipelineDepthStencilStateCreateInfo(handlemap, (VkPipelineDepthStencilStateCreateInfo*)(toMap->pDepthStencilState));
    }
    if (toMap->pColorBlendState)
    {
        handlemap_VkPipelineColorBlendStateCreateInfo(handlemap, (VkPipelineColorBlendStateCreateInfo*)(toMap->pColorBlendState));
    }
    if (toMap->pDynamicState)
    {
        handlemap_VkPipelineDynamicStateCreateInfo(handlemap, (VkPipelineDynamicStateCreateInfo*)(toMap->pDynamicState));
    }
    handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->layout);
    handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
    handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->basePipelineHandle);
}

void handlemap_VkComputePipelineCreateInfo(
    VulkanHandleMapping* handlemap,
    VkComputePipelineCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(&toMap->stage));
    handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->layout);
    handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->basePipelineHandle);
}

void handlemap_VkPushConstantRange(
    VulkanHandleMapping* handlemap,
    VkPushConstantRange* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkPipelineLayoutCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineLayoutCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pSetLayouts)
    {
        handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts, toMap->setLayoutCount);
    }
    if (toMap->pPushConstantRanges)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->pushConstantRangeCount; ++i)
        {
            handlemap_VkPushConstantRange(handlemap, (VkPushConstantRange*)(toMap->pPushConstantRanges + i));
        }
    }
}

void handlemap_VkSamplerCreateInfo(
    VulkanHandleMapping* handlemap,
    VkSamplerCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkDescriptorSetLayoutBinding(
    VulkanHandleMapping* handlemap,
    VkDescriptorSetLayoutBinding* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pImmutableSamplers)
    {
        handlemap->mapHandles_VkSampler((VkSampler*)toMap->pImmutableSamplers, toMap->descriptorCount);
    }
}

void handlemap_VkDescriptorSetLayoutCreateInfo(
    VulkanHandleMapping* handlemap,
    VkDescriptorSetLayoutCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pBindings)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->bindingCount; ++i)
        {
            handlemap_VkDescriptorSetLayoutBinding(handlemap, (VkDescriptorSetLayoutBinding*)(toMap->pBindings + i));
        }
    }
}

void handlemap_VkDescriptorPoolSize(
    VulkanHandleMapping* handlemap,
    VkDescriptorPoolSize* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkDescriptorPoolCreateInfo(
    VulkanHandleMapping* handlemap,
    VkDescriptorPoolCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pPoolSizes)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->poolSizeCount; ++i)
        {
            handlemap_VkDescriptorPoolSize(handlemap, (VkDescriptorPoolSize*)(toMap->pPoolSizes + i));
        }
    }
}

void handlemap_VkDescriptorSetAllocateInfo(
    VulkanHandleMapping* handlemap,
    VkDescriptorSetAllocateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkDescriptorPool((VkDescriptorPool*)&toMap->descriptorPool);
    if (toMap->pSetLayouts)
    {
        handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts, toMap->descriptorSetCount);
    }
}

void handlemap_VkDescriptorImageInfo(
    VulkanHandleMapping* handlemap,
    VkDescriptorImageInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap->mapHandles_VkSampler((VkSampler*)&toMap->sampler);
    handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
}

void handlemap_VkDescriptorBufferInfo(
    VulkanHandleMapping* handlemap,
    VkDescriptorBufferInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}

void handlemap_VkWriteDescriptorSet(
    VulkanHandleMapping* handlemap,
    VkWriteDescriptorSet* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->dstSet);
    if (toMap->pImageInfo)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->descriptorCount; ++i)
        {
            handlemap_VkDescriptorImageInfo(handlemap, (VkDescriptorImageInfo*)(toMap->pImageInfo + i));
        }
    }
    if (toMap->pBufferInfo)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->descriptorCount; ++i)
        {
            handlemap_VkDescriptorBufferInfo(handlemap, (VkDescriptorBufferInfo*)(toMap->pBufferInfo + i));
        }
    }
    if (toMap->pTexelBufferView)
    {
        handlemap->mapHandles_VkBufferView((VkBufferView*)toMap->pTexelBufferView, toMap->descriptorCount);
    }
}

void handlemap_VkCopyDescriptorSet(
    VulkanHandleMapping* handlemap,
    VkCopyDescriptorSet* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->srcSet);
    handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->dstSet);
}

void handlemap_VkFramebufferCreateInfo(
    VulkanHandleMapping* handlemap,
    VkFramebufferCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
    if (toMap->pAttachments)
    {
        handlemap->mapHandles_VkImageView((VkImageView*)toMap->pAttachments, toMap->attachmentCount);
    }
}

void handlemap_VkAttachmentDescription(
    VulkanHandleMapping* handlemap,
    VkAttachmentDescription* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkAttachmentReference(
    VulkanHandleMapping* handlemap,
    VkAttachmentReference* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkSubpassDescription(
    VulkanHandleMapping* handlemap,
    VkSubpassDescription* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pInputAttachments)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->inputAttachmentCount; ++i)
        {
            handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pInputAttachments + i));
        }
    }
    if (toMap->pColorAttachments)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
        {
            handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pColorAttachments + i));
        }
    }
    if (toMap->pResolveAttachments)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
        {
            handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pResolveAttachments + i));
        }
    }
    if (toMap->pDepthStencilAttachment)
    {
        handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pDepthStencilAttachment));
    }
}

void handlemap_VkSubpassDependency(
    VulkanHandleMapping* handlemap,
    VkSubpassDependency* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkRenderPassCreateInfo(
    VulkanHandleMapping* handlemap,
    VkRenderPassCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pAttachments)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
        {
            handlemap_VkAttachmentDescription(handlemap, (VkAttachmentDescription*)(toMap->pAttachments + i));
        }
    }
    if (toMap->pSubpasses)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->subpassCount; ++i)
        {
            handlemap_VkSubpassDescription(handlemap, (VkSubpassDescription*)(toMap->pSubpasses + i));
        }
    }
    if (toMap->pDependencies)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->dependencyCount; ++i)
        {
            handlemap_VkSubpassDependency(handlemap, (VkSubpassDependency*)(toMap->pDependencies + i));
        }
    }
}

void handlemap_VkCommandPoolCreateInfo(
    VulkanHandleMapping* handlemap,
    VkCommandPoolCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkCommandBufferAllocateInfo(
    VulkanHandleMapping* handlemap,
    VkCommandBufferAllocateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkCommandPool((VkCommandPool*)&toMap->commandPool);
}

void handlemap_VkCommandBufferInheritanceInfo(
    VulkanHandleMapping* handlemap,
    VkCommandBufferInheritanceInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
    handlemap->mapHandles_VkFramebuffer((VkFramebuffer*)&toMap->framebuffer);
}

void handlemap_VkCommandBufferBeginInfo(
    VulkanHandleMapping* handlemap,
    VkCommandBufferBeginInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pInheritanceInfo)
    {
        handlemap_VkCommandBufferInheritanceInfo(handlemap, (VkCommandBufferInheritanceInfo*)(toMap->pInheritanceInfo));
    }
}

void handlemap_VkBufferCopy(
    VulkanHandleMapping* handlemap,
    VkBufferCopy* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkImageSubresourceLayers(
    VulkanHandleMapping* handlemap,
    VkImageSubresourceLayers* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkImageCopy(
    VulkanHandleMapping* handlemap,
    VkImageCopy* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
}

void handlemap_VkImageBlit(
    VulkanHandleMapping* handlemap,
    VkImageBlit* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i)
    {
        handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->srcOffsets + i));
    }
    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
    for (uint32_t i = 0; i < (uint32_t)2; ++i)
    {
        handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->dstOffsets + i));
    }
}

void handlemap_VkBufferImageCopy(
    VulkanHandleMapping* handlemap,
    VkBufferImageCopy* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->imageSubresource));
    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->imageOffset));
    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageExtent));
}

void handlemap_VkClearColorValue(
    VulkanHandleMapping* handlemap,
    VkClearColorValue* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkClearDepthStencilValue(
    VulkanHandleMapping* handlemap,
    VkClearDepthStencilValue* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkClearValue(
    VulkanHandleMapping* handlemap,
    VkClearValue* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkClearColorValue(handlemap, (VkClearColorValue*)(&toMap->color));
    handlemap_VkClearDepthStencilValue(handlemap, (VkClearDepthStencilValue*)(&toMap->depthStencil));
}

void handlemap_VkClearAttachment(
    VulkanHandleMapping* handlemap,
    VkClearAttachment* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkClearValue(handlemap, (VkClearValue*)(&toMap->clearValue));
}

void handlemap_VkClearRect(
    VulkanHandleMapping* handlemap,
    VkClearRect* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->rect));
}

void handlemap_VkImageResolve(
    VulkanHandleMapping* handlemap,
    VkImageResolve* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
    handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
}

void handlemap_VkMemoryBarrier(
    VulkanHandleMapping* handlemap,
    VkMemoryBarrier* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkBufferMemoryBarrier(
    VulkanHandleMapping* handlemap,
    VkBufferMemoryBarrier* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}

void handlemap_VkImageMemoryBarrier(
    VulkanHandleMapping* handlemap,
    VkImageMemoryBarrier* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
    handlemap_VkImageSubresourceRange(handlemap, (VkImageSubresourceRange*)(&toMap->subresourceRange));
}

void handlemap_VkRenderPassBeginInfo(
    VulkanHandleMapping* handlemap,
    VkRenderPassBeginInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
    handlemap->mapHandles_VkFramebuffer((VkFramebuffer*)&toMap->framebuffer);
    handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->renderArea));
    if (toMap->pClearValues)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->clearValueCount; ++i)
        {
            handlemap_VkClearValue(handlemap, (VkClearValue*)(toMap->pClearValues + i));
        }
    }
}

void handlemap_VkDispatchIndirectCommand(
    VulkanHandleMapping* handlemap,
    VkDispatchIndirectCommand* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkDrawIndexedIndirectCommand(
    VulkanHandleMapping* handlemap,
    VkDrawIndexedIndirectCommand* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkDrawIndirectCommand(
    VulkanHandleMapping* handlemap,
    VkDrawIndirectCommand* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkBaseOutStructure(
    VulkanHandleMapping* handlemap,
    VkBaseOutStructure* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkBaseInStructure(
    VulkanHandleMapping* handlemap,
    VkBaseInStructure* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

#endif
#ifdef VK_VERSION_1_1
void handlemap_VkPhysicalDeviceSubgroupProperties(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceSubgroupProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkBindBufferMemoryInfo(
    VulkanHandleMapping* handlemap,
    VkBindBufferMemoryInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}

void handlemap_VkBindImageMemoryInfo(
    VulkanHandleMapping* handlemap,
    VkBindImageMemoryInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}

void handlemap_VkPhysicalDevice16BitStorageFeatures(
    VulkanHandleMapping* handlemap,
    VkPhysicalDevice16BitStorageFeatures* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkMemoryDedicatedRequirements(
    VulkanHandleMapping* handlemap,
    VkMemoryDedicatedRequirements* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkMemoryDedicatedAllocateInfo(
    VulkanHandleMapping* handlemap,
    VkMemoryDedicatedAllocateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}

void handlemap_VkMemoryAllocateFlagsInfo(
    VulkanHandleMapping* handlemap,
    VkMemoryAllocateFlagsInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkDeviceGroupRenderPassBeginInfo(
    VulkanHandleMapping* handlemap,
    VkDeviceGroupRenderPassBeginInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pDeviceRenderAreas)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->deviceRenderAreaCount; ++i)
        {
            handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pDeviceRenderAreas + i));
        }
    }
}

void handlemap_VkDeviceGroupCommandBufferBeginInfo(
    VulkanHandleMapping* handlemap,
    VkDeviceGroupCommandBufferBeginInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkDeviceGroupSubmitInfo(
    VulkanHandleMapping* handlemap,
    VkDeviceGroupSubmitInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkDeviceGroupBindSparseInfo(
    VulkanHandleMapping* handlemap,
    VkDeviceGroupBindSparseInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkBindBufferMemoryDeviceGroupInfo(
    VulkanHandleMapping* handlemap,
    VkBindBufferMemoryDeviceGroupInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkBindImageMemoryDeviceGroupInfo(
    VulkanHandleMapping* handlemap,
    VkBindImageMemoryDeviceGroupInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pSplitInstanceBindRegions)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->splitInstanceBindRegionCount; ++i)
        {
            handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pSplitInstanceBindRegions + i));
        }
    }
}

void handlemap_VkPhysicalDeviceGroupProperties(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceGroupProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkPhysicalDevice((VkPhysicalDevice*)toMap->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE);
}

void handlemap_VkDeviceGroupDeviceCreateInfo(
    VulkanHandleMapping* handlemap,
    VkDeviceGroupDeviceCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pPhysicalDevices)
    {
        handlemap->mapHandles_VkPhysicalDevice((VkPhysicalDevice*)toMap->pPhysicalDevices, toMap->physicalDeviceCount);
    }
}

void handlemap_VkBufferMemoryRequirementsInfo2(
    VulkanHandleMapping* handlemap,
    VkBufferMemoryRequirementsInfo2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}

void handlemap_VkImageMemoryRequirementsInfo2(
    VulkanHandleMapping* handlemap,
    VkImageMemoryRequirementsInfo2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
}

void handlemap_VkImageSparseMemoryRequirementsInfo2(
    VulkanHandleMapping* handlemap,
    VkImageSparseMemoryRequirementsInfo2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
}

void handlemap_VkMemoryRequirements2(
    VulkanHandleMapping* handlemap,
    VkMemoryRequirements2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkMemoryRequirements(handlemap, (VkMemoryRequirements*)(&toMap->memoryRequirements));
}

void handlemap_VkSparseImageMemoryRequirements2(
    VulkanHandleMapping* handlemap,
    VkSparseImageMemoryRequirements2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkSparseImageMemoryRequirements(handlemap, (VkSparseImageMemoryRequirements*)(&toMap->memoryRequirements));
}

void handlemap_VkPhysicalDeviceFeatures2(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceFeatures2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkPhysicalDeviceFeatures(handlemap, (VkPhysicalDeviceFeatures*)(&toMap->features));
}

void handlemap_VkPhysicalDeviceProperties2(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceProperties2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkPhysicalDeviceProperties(handlemap, (VkPhysicalDeviceProperties*)(&toMap->properties));
}

void handlemap_VkFormatProperties2(
    VulkanHandleMapping* handlemap,
    VkFormatProperties2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkFormatProperties(handlemap, (VkFormatProperties*)(&toMap->formatProperties));
}

void handlemap_VkImageFormatProperties2(
    VulkanHandleMapping* handlemap,
    VkImageFormatProperties2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkImageFormatProperties(handlemap, (VkImageFormatProperties*)(&toMap->imageFormatProperties));
}

void handlemap_VkPhysicalDeviceImageFormatInfo2(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceImageFormatInfo2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkQueueFamilyProperties2(
    VulkanHandleMapping* handlemap,
    VkQueueFamilyProperties2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkQueueFamilyProperties(handlemap, (VkQueueFamilyProperties*)(&toMap->queueFamilyProperties));
}

void handlemap_VkPhysicalDeviceMemoryProperties2(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceMemoryProperties2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkPhysicalDeviceMemoryProperties(handlemap, (VkPhysicalDeviceMemoryProperties*)(&toMap->memoryProperties));
}

void handlemap_VkSparseImageFormatProperties2(
    VulkanHandleMapping* handlemap,
    VkSparseImageFormatProperties2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkSparseImageFormatProperties(handlemap, (VkSparseImageFormatProperties*)(&toMap->properties));
}

void handlemap_VkPhysicalDeviceSparseImageFormatInfo2(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceSparseImageFormatInfo2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPhysicalDevicePointClippingProperties(
    VulkanHandleMapping* handlemap,
    VkPhysicalDevicePointClippingProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkInputAttachmentAspectReference(
    VulkanHandleMapping* handlemap,
    VkInputAttachmentAspectReference* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkRenderPassInputAttachmentAspectCreateInfo(
    VulkanHandleMapping* handlemap,
    VkRenderPassInputAttachmentAspectCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pAspectReferences)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->aspectReferenceCount; ++i)
        {
            handlemap_VkInputAttachmentAspectReference(handlemap, (VkInputAttachmentAspectReference*)(toMap->pAspectReferences + i));
        }
    }
}

void handlemap_VkImageViewUsageCreateInfo(
    VulkanHandleMapping* handlemap,
    VkImageViewUsageCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(
    VulkanHandleMapping* handlemap,
    VkPipelineTessellationDomainOriginStateCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkRenderPassMultiviewCreateInfo(
    VulkanHandleMapping* handlemap,
    VkRenderPassMultiviewCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPhysicalDeviceMultiviewFeatures(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceMultiviewFeatures* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPhysicalDeviceMultiviewProperties(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceMultiviewProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPhysicalDeviceVariablePointerFeatures(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceVariablePointerFeatures* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPhysicalDeviceProtectedMemoryFeatures(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceProtectedMemoryFeatures* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPhysicalDeviceProtectedMemoryProperties(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceProtectedMemoryProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkDeviceQueueInfo2(
    VulkanHandleMapping* handlemap,
    VkDeviceQueueInfo2* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkProtectedSubmitInfo(
    VulkanHandleMapping* handlemap,
    VkProtectedSubmitInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkSamplerYcbcrConversionCreateInfo(
    VulkanHandleMapping* handlemap,
    VkSamplerYcbcrConversionCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->components));
}

void handlemap_VkSamplerYcbcrConversionInfo(
    VulkanHandleMapping* handlemap,
    VkSamplerYcbcrConversionInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&toMap->conversion);
}

void handlemap_VkBindImagePlaneMemoryInfo(
    VulkanHandleMapping* handlemap,
    VkBindImagePlaneMemoryInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkImagePlaneMemoryRequirementsInfo(
    VulkanHandleMapping* handlemap,
    VkImagePlaneMemoryRequirementsInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceSamplerYcbcrConversionFeatures* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkSamplerYcbcrConversionImageFormatProperties(
    VulkanHandleMapping* handlemap,
    VkSamplerYcbcrConversionImageFormatProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkDescriptorUpdateTemplateEntry(
    VulkanHandleMapping* handlemap,
    VkDescriptorUpdateTemplateEntry* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkDescriptorUpdateTemplateCreateInfo(
    VulkanHandleMapping* handlemap,
    VkDescriptorUpdateTemplateCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pDescriptorUpdateEntries)
    {
        for (uint32_t i = 0; i < (uint32_t)toMap->descriptorUpdateEntryCount; ++i)
        {
            handlemap_VkDescriptorUpdateTemplateEntry(handlemap, (VkDescriptorUpdateTemplateEntry*)(toMap->pDescriptorUpdateEntries + i));
        }
    }
    handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)&toMap->descriptorSetLayout);
    handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->pipelineLayout);
}

void handlemap_VkExternalMemoryProperties(
    VulkanHandleMapping* handlemap,
    VkExternalMemoryProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
}

void handlemap_VkPhysicalDeviceExternalImageFormatInfo(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceExternalImageFormatInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkExternalImageFormatProperties(
    VulkanHandleMapping* handlemap,
    VkExternalImageFormatProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkExternalMemoryProperties(handlemap, (VkExternalMemoryProperties*)(&toMap->externalMemoryProperties));
}

void handlemap_VkPhysicalDeviceExternalBufferInfo(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceExternalBufferInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkExternalBufferProperties(
    VulkanHandleMapping* handlemap,
    VkExternalBufferProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkExternalMemoryProperties(handlemap, (VkExternalMemoryProperties*)(&toMap->externalMemoryProperties));
}

void handlemap_VkPhysicalDeviceIDProperties(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceIDProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkExternalMemoryImageCreateInfo(
    VulkanHandleMapping* handlemap,
    VkExternalMemoryImageCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkExternalMemoryBufferCreateInfo(
    VulkanHandleMapping* handlemap,
    VkExternalMemoryBufferCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkExportMemoryAllocateInfo(
    VulkanHandleMapping* handlemap,
    VkExportMemoryAllocateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPhysicalDeviceExternalFenceInfo(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceExternalFenceInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkExternalFenceProperties(
    VulkanHandleMapping* handlemap,
    VkExternalFenceProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkExportFenceCreateInfo(
    VulkanHandleMapping* handlemap,
    VkExportFenceCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkExportSemaphoreCreateInfo(
    VulkanHandleMapping* handlemap,
    VkExportSemaphoreCreateInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPhysicalDeviceExternalSemaphoreInfo(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceExternalSemaphoreInfo* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkExternalSemaphoreProperties(
    VulkanHandleMapping* handlemap,
    VkExternalSemaphoreProperties* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPhysicalDeviceMaintenance3Properties(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceMaintenance3Properties* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkDescriptorSetLayoutSupport(
    VulkanHandleMapping* handlemap,
    VkDescriptorSetLayoutSupport* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkPhysicalDeviceShaderDrawParameterFeatures(
    VulkanHandleMapping* handlemap,
    VkPhysicalDeviceShaderDrawParameterFeatures* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

#endif
#ifdef VK_KHR_surface
void handlemap_VkSurfaceCapabilitiesKHR(
    VulkanHandleMapping* handlemap,
    VkSurfaceCapabilitiesKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->currentExtent));
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minImageExtent));
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxImageExtent));
}

void handlemap_VkSurfaceFormatKHR(
    VulkanHandleMapping* handlemap,
    VkSurfaceFormatKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
}

#endif
#ifdef VK_KHR_swapchain
void handlemap_VkSwapchainCreateInfoKHR(
    VulkanHandleMapping* handlemap,
    VkSwapchainCreateInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&toMap->surface);
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->imageExtent));
    handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->oldSwapchain);
}

void handlemap_VkPresentInfoKHR(
    VulkanHandleMapping* handlemap,
    VkPresentInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pWaitSemaphores)
    {
        handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
    }
    if (toMap->pSwapchains)
    {
        handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)toMap->pSwapchains, toMap->swapchainCount);
    }
}

void handlemap_VkImageSwapchainCreateInfoKHR(
    VulkanHandleMapping* handlemap,
    VkImageSwapchainCreateInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
}

void handlemap_VkBindImageMemorySwapchainInfoKHR(
    VulkanHandleMapping* handlemap,
    VkBindImageMemorySwapchainInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
}

void handlemap_VkAcquireNextImageInfoKHR(
    VulkanHandleMapping* handlemap,
    VkAcquireNextImageInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
    handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
    handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
}

void handlemap_VkDeviceGroupPresentCapabilitiesKHR(
    VulkanHandleMapping* handlemap,
    VkDeviceGroupPresentCapabilitiesKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkDeviceGroupPresentInfoKHR(
    VulkanHandleMapping* handlemap,
    VkDeviceGroupPresentInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkDeviceGroupSwapchainCreateInfoKHR(
    VulkanHandleMapping* handlemap,
    VkDeviceGroupSwapchainCreateInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

#endif
#ifdef VK_KHR_display
void handlemap_VkDisplayPropertiesKHR(
    VulkanHandleMapping* handlemap,
    VkDisplayPropertiesKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap->mapHandles_VkDisplayKHR((VkDisplayKHR*)&toMap->display);
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->physicalDimensions));
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->physicalResolution));
}

void handlemap_VkDisplayModeParametersKHR(
    VulkanHandleMapping* handlemap,
    VkDisplayModeParametersKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->visibleRegion));
}

void handlemap_VkDisplayModePropertiesKHR(
    VulkanHandleMapping* handlemap,
    VkDisplayModePropertiesKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->displayMode);
    handlemap_VkDisplayModeParametersKHR(handlemap, (VkDisplayModeParametersKHR*)(&toMap->parameters));
}

void handlemap_VkDisplayModeCreateInfoKHR(
    VulkanHandleMapping* handlemap,
    VkDisplayModeCreateInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkDisplayModeParametersKHR(handlemap, (VkDisplayModeParametersKHR*)(&toMap->parameters));
}

void handlemap_VkDisplayPlaneCapabilitiesKHR(
    VulkanHandleMapping* handlemap,
    VkDisplayPlaneCapabilitiesKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->minSrcPosition));
    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->maxSrcPosition));
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minSrcExtent));
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxSrcExtent));
    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->minDstPosition));
    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->maxDstPosition));
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minDstExtent));
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxDstExtent));
}

void handlemap_VkDisplayPlanePropertiesKHR(
    VulkanHandleMapping* handlemap,
    VkDisplayPlanePropertiesKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    handlemap->mapHandles_VkDisplayKHR((VkDisplayKHR*)&toMap->currentDisplay);
}

void handlemap_VkDisplaySurfaceCreateInfoKHR(
    VulkanHandleMapping* handlemap,
    VkDisplaySurfaceCreateInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->displayMode);
    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->imageExtent));
}

#endif
#ifdef VK_KHR_display_swapchain
void handlemap_VkDisplayPresentInfoKHR(
    VulkanHandleMapping* handlemap,
    VkDisplayPresentInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->srcRect));
    handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->dstRect));
}

#endif
#ifdef VK_KHR_xlib_surface
void handlemap_VkXlibSurfaceCreateInfoKHR(
    VulkanHandleMapping* handlemap,
    VkXlibSurfaceCreateInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

#endif
#ifdef VK_KHR_xcb_surface
void handlemap_VkXcbSurfaceCreateInfoKHR(
    VulkanHandleMapping* handlemap,
    VkXcbSurfaceCreateInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

#endif
#ifdef VK_KHR_wayland_surface
void handlemap_VkWaylandSurfaceCreateInfoKHR(
    VulkanHandleMapping* handlemap,
    VkWaylandSurfaceCreateInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

#endif
#ifdef VK_KHR_mir_surface
void handlemap_VkMirSurfaceCreateInfoKHR(
    VulkanHandleMapping* handlemap,
    VkMirSurfaceCreateInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

#endif
#ifdef VK_KHR_android_surface
void handlemap_VkAndroidSurfaceCreateInfoKHR(
    VulkanHandleMapping* handlemap,
    VkAndroidSurfaceCreateInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

#endif
#ifdef VK_KHR_win32_surface
void handlemap_VkWin32SurfaceCreateInfoKHR(
    VulkanHandleMapping* handlemap,
    VkWin32SurfaceCreateInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_multiview
#endif
#ifdef VK_KHR_get_physical_device_properties2
#endif
#ifdef VK_KHR_device_group
#endif
#ifdef VK_KHR_shader_draw_parameters
#endif
#ifdef VK_KHR_maintenance1
#endif
#ifdef VK_KHR_device_group_creation
#endif
#ifdef VK_KHR_external_memory_capabilities
#endif
#ifdef VK_KHR_external_memory
#endif
#ifdef VK_KHR_external_memory_win32
void handlemap_VkImportMemoryWin32HandleInfoKHR(
    VulkanHandleMapping* handlemap,
    VkImportMemoryWin32HandleInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkExportMemoryWin32HandleInfoKHR(
    VulkanHandleMapping* handlemap,
    VkExportMemoryWin32HandleInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkMemoryWin32HandlePropertiesKHR(
    VulkanHandleMapping* handlemap,
    VkMemoryWin32HandlePropertiesKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkMemoryGetWin32HandleInfoKHR(
    VulkanHandleMapping* handlemap,
    VkMemoryGetWin32HandleInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}

#endif
#ifdef VK_KHR_external_memory_fd
void handlemap_VkImportMemoryFdInfoKHR(
    VulkanHandleMapping* handlemap,
    VkImportMemoryFdInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkMemoryFdPropertiesKHR(
    VulkanHandleMapping* handlemap,
    VkMemoryFdPropertiesKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkMemoryGetFdInfoKHR(
    VulkanHandleMapping* handlemap,
    VkMemoryGetFdInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}

#endif
#ifdef VK_KHR_win32_keyed_mutex
void handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(
    VulkanHandleMapping* handlemap,
    VkWin32KeyedMutexAcquireReleaseInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    if (toMap->pAcquireSyncs)
    {
        handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pAcquireSyncs, toMap->acquireCount);
    }
    if (toMap->pReleaseSyncs)
    {
        handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pReleaseSyncs, toMap->releaseCount);
    }
}

#endif
#ifdef VK_KHR_external_semaphore_capabilities
#endif
#ifdef VK_KHR_external_semaphore
#endif
#ifdef VK_KHR_external_semaphore_win32
void handlemap_VkImportSemaphoreWin32HandleInfoKHR(
    VulkanHandleMapping* handlemap,
    VkImportSemaphoreWin32HandleInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
    handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
}

void handlemap_VkExportSemaphoreWin32HandleInfoKHR(
    VulkanHandleMapping* handlemap,
    VkExportSemaphoreWin32HandleInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkD3D12FenceSubmitInfoKHR(
    VulkanHandleMapping* handlemap,
    VkD3D12FenceSubmitInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;
    if (toMap->pNext)
    {
        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
    }
}

void handlemap_VkSemaphoreGetWin32HandleInfoKHR(
    VulkanHandleMapping* handlemap,
    VkSemaphoreGetWin32HandleInfoKHR* toMap)
{
    (void)handlemap;
    (void)toMap;