/*
 * Copyright 2015, The Android Open Source Project
 *
 * 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.
 *
 * THIS FILE WAS GENERATED BY apic. DO NOT EDIT.
 */


#include "vulkan_exports.h"
#include "vulkan_extras.h"
#include "vulkan_types.h"
#include "vulkan_layer_extras.h"
#include "vulkan_imports.h"
#include "vulkan_spy.h"

extern "C" {
// For this to function on Android the entry-point names for GetDeviceProcAddr
// and GetInstanceProcAddr must be ${layer_name}/Get*ProcAddr.
// This is a bit surprising given that we *MUST* also export
// vkEnumerate*Layers without any prefix.
VK_LAYER_EXPORT VKAPI_ATTR gapii::PFN_vkVoidFunction VKAPI_CALL
VkGraphicsSpyGetDeviceProcAddr(gapii::VkDevice dev, const char *funcName) {
    return gapii::vkGetDeviceProcAddr(dev, funcName);
}
VK_LAYER_EXPORT VKAPI_ATTR gapii::PFN_vkVoidFunction VKAPI_CALL
VkGraphicsSpyGetInstanceProcAddr(gapii::VkInstance instance, const char *funcName) {
    return gapii::vkGetInstanceProcAddr(instance, funcName);
}
// Documentation is sparse for android, looking at libvulkan.so
// These 4 function must be defined in order for this to even
// be considered for loading.
VK_LAYER_EXPORT VKAPI_ATTR uint32_t VKAPI_CALL
vkEnumerateInstanceLayerProperties(uint32_t *pCount,
gapii::VkLayerProperties *pProperties) {
    return gapii::vkEnumerateInstanceLayerProperties(pCount, pProperties);
}
// On Android this must also be defined, even if we have 0
// layers to expose.
VK_LAYER_EXPORT VKAPI_ATTR uint32_t VKAPI_CALL
vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,
gapii::VkExtensionProperties *pProperties) {
    return gapii::vkEnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
}
VK_LAYER_EXPORT VKAPI_ATTR uint32_t VKAPI_CALL
vkEnumerateDeviceLayerProperties(gapii::VkPhysicalDevice device, uint32_t *pCount,
gapii::VkLayerProperties *pProperties) {
    return gapii::vkEnumerateInstanceLayerProperties(pCount, pProperties);
}
// On android this must also be defined, even if we have 0
// layers to expose.
VK_LAYER_EXPORT VKAPI_ATTR uint32_t VKAPI_CALL
vkEnumerateDeviceExtensionProperties(gapii::VkPhysicalDevice device, const char *pLayerName, uint32_t *pCount,
gapii::VkExtensionProperties *pProperties) {
    return gapii::vkEnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
}
}
namespace gapii {
uint32_t VulkanSpy::SpyOverride_vkEnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
    if (pProperties == NULL) {
        *pCount = 1;
        return VkResult::VK_SUCCESS;
    }
    if (pCount == 0) {
        return VkResult::VK_INCOMPLETE;
    }
    *pCount = 1;
    memset(pProperties, 0x00, sizeof(*pProperties));
    strcpy((char*)pProperties->mlayerName, "VkGraphicsSpy");
    pProperties->mspecVersion = VK_VERSION_MAJOR(1) | VK_VERSION_MINOR(0) | 5;
    pProperties->mimplementationVersion = 1;
    strcpy((char*)pProperties->mdescription, "vulkan_trace");
    return VkResult::VK_SUCCESS;
}
uint32_t VulkanSpy::SpyOverride_vkEnumerateDeviceLayerProperties(VkPhysicalDevice dev, uint32_t *pCount, VkLayerProperties *pProperties) {
    if (pProperties == NULL) {
        *pCount = 1;
        return VkResult::VK_SUCCESS;
    }
    if (pCount == 0) {
        return VkResult::VK_INCOMPLETE;
    }
    *pCount = 1;
    memset(pProperties, 0x00, sizeof(*pProperties));
    strcpy((char*)pProperties->mlayerName, "VkGraphicsSpy");
    pProperties->mspecVersion = VK_VERSION_MAJOR(1) | VK_VERSION_MINOR(0) | 5;
    pProperties->mimplementationVersion = 1;
    strcpy((char*)pProperties->mdescription, "vulkan_trace");
    return VkResult::VK_SUCCESS;
}
PFN_vkVoidFunction VulkanSpy::SpyOverride_vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
    if(!strcmp(pName, "vkCreateAndroidSurfaceKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateAndroidSurfaceKHR);
    if(!strcmp(pName, "vkCreateInstance"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateInstance);
    if(!strcmp(pName, "vkDestroyInstance"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyInstance);
    if(!strcmp(pName, "vkEnumeratePhysicalDevices"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkEnumeratePhysicalDevices);
    if(!strcmp(pName, "vkGetPhysicalDeviceFeatures"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceFeatures);
    if(!strcmp(pName, "vkGetPhysicalDeviceFormatProperties"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceFormatProperties);
    if(!strcmp(pName, "vkGetPhysicalDeviceImageFormatProperties"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceImageFormatProperties);
    if(!strcmp(pName, "vkGetPhysicalDeviceProperties"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceProperties);
    if(!strcmp(pName, "vkGetPhysicalDeviceQueueFamilyProperties"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceQueueFamilyProperties);
    if(!strcmp(pName, "vkGetPhysicalDeviceMemoryProperties"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceMemoryProperties);
    if(!strcmp(pName, "vkGetInstanceProcAddr"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetInstanceProcAddr);
    if(!strcmp(pName, "vkCreateDevice"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateDevice);
    if(!strcmp(pName, "vkEnumerateDeviceExtensionProperties"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkEnumerateDeviceExtensionProperties);
    if(!strcmp(pName, "vkEnumerateDeviceLayerProperties"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkEnumerateDeviceLayerProperties);
    if(!strcmp(pName, "vkGetPhysicalDeviceSparseImageFormatProperties"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceSparseImageFormatProperties);
    if(!strcmp(pName, "vkDestroySurfaceKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroySurfaceKHR);
    if(!strcmp(pName, "vkGetPhysicalDeviceSurfaceSupportKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceSurfaceSupportKHR);
    if(!strcmp(pName, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
    if(!strcmp(pName, "vkGetPhysicalDeviceSurfaceFormatsKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceSurfaceFormatsKHR);
    if(!strcmp(pName, "vkGetPhysicalDeviceSurfacePresentModesKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceSurfacePresentModesKHR);
    if(!strcmp(pName, "vkGetPhysicalDeviceDisplayPropertiesKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceDisplayPropertiesKHR);
    if(!strcmp(pName, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPhysicalDeviceDisplayPlanePropertiesKHR);
    if(!strcmp(pName, "vkGetDisplayPlaneSupportedDisplaysKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetDisplayPlaneSupportedDisplaysKHR);
    if(!strcmp(pName, "vkGetDisplayModePropertiesKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetDisplayModePropertiesKHR);
    if(!strcmp(pName, "vkCreateDisplayModeKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateDisplayModeKHR);
    if(!strcmp(pName, "vkGetDisplayPlaneCapabilitiesKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetDisplayPlaneCapabilitiesKHR);
    if(!strcmp(pName, "vkCreateDisplayPlaneSurfaceKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateDisplayPlaneSurfaceKHR);
    if(!strcmp(pName, "vkCreateDebugReportCallbackEXT"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateDebugReportCallbackEXT);
    if(!strcmp(pName, "vkDestroyDebugReportCallbackEXT"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyDebugReportCallbackEXT);
    if(!strcmp(pName, "vkDebugReportMessageEXT"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDebugReportMessageEXT);
    if (!strcmp(pName, "vkEnumerateInstanceExtensionProperties")) {
        return reinterpret_cast<PFN_vkVoidFunction>(mImports.mInstanceFunctions[instance].vkEnumerateInstanceExtensionProperties);
    }
    return nullptr;
}
PFN_vkVoidFunction VulkanSpy::SpyOverride_vkGetDeviceProcAddr(VkDevice device, const char* pName) {
    if(!strcmp(pName, "vkGetSwapchainGrallocUsageANDROID"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetSwapchainGrallocUsageANDROID);
    if(!strcmp(pName, "vkAcquireImageANDROID"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkAcquireImageANDROID);
    if(!strcmp(pName, "vkQueueSignalReleaseImageANDROID"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkQueueSignalReleaseImageANDROID);
    if(!strcmp(pName, "vkGetDeviceProcAddr"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetDeviceProcAddr);
    if(!strcmp(pName, "vkDestroyDevice"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyDevice);
    if(!strcmp(pName, "vkGetDeviceQueue"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetDeviceQueue);
    if(!strcmp(pName, "vkQueueSubmit"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkQueueSubmit);
    if(!strcmp(pName, "vkQueueWaitIdle"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkQueueWaitIdle);
    if(!strcmp(pName, "vkDeviceWaitIdle"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDeviceWaitIdle);
    if(!strcmp(pName, "vkAllocateMemory"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkAllocateMemory);
    if(!strcmp(pName, "vkFreeMemory"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkFreeMemory);
    if(!strcmp(pName, "vkMapMemory"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkMapMemory);
    if(!strcmp(pName, "vkUnmapMemory"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkUnmapMemory);
    if(!strcmp(pName, "vkFlushMappedMemoryRanges"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkFlushMappedMemoryRanges);
    if(!strcmp(pName, "vkInvalidateMappedMemoryRanges"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkInvalidateMappedMemoryRanges);
    if(!strcmp(pName, "vkGetDeviceMemoryCommitment"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetDeviceMemoryCommitment);
    if(!strcmp(pName, "vkBindBufferMemory"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkBindBufferMemory);
    if(!strcmp(pName, "vkBindImageMemory"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkBindImageMemory);
    if(!strcmp(pName, "vkGetBufferMemoryRequirements"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetBufferMemoryRequirements);
    if(!strcmp(pName, "vkGetImageMemoryRequirements"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetImageMemoryRequirements);
    if(!strcmp(pName, "vkGetImageSparseMemoryRequirements"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetImageSparseMemoryRequirements);
    if(!strcmp(pName, "vkQueueBindSparse"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkQueueBindSparse);
    if(!strcmp(pName, "vkCreateFence"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateFence);
    if(!strcmp(pName, "vkDestroyFence"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyFence);
    if(!strcmp(pName, "vkResetFences"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkResetFences);
    if(!strcmp(pName, "vkGetFenceStatus"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetFenceStatus);
    if(!strcmp(pName, "vkWaitForFences"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkWaitForFences);
    if(!strcmp(pName, "vkCreateSemaphore"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateSemaphore);
    if(!strcmp(pName, "vkDestroySemaphore"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroySemaphore);
    if(!strcmp(pName, "vkCreateEvent"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateEvent);
    if(!strcmp(pName, "vkDestroyEvent"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyEvent);
    if(!strcmp(pName, "vkGetEventStatus"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetEventStatus);
    if(!strcmp(pName, "vkSetEvent"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkSetEvent);
    if(!strcmp(pName, "vkResetEvent"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkResetEvent);
    if(!strcmp(pName, "vkCreateQueryPool"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateQueryPool);
    if(!strcmp(pName, "vkDestroyQueryPool"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyQueryPool);
    if(!strcmp(pName, "vkGetQueryPoolResults"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetQueryPoolResults);
    if(!strcmp(pName, "vkCreateBuffer"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateBuffer);
    if(!strcmp(pName, "vkDestroyBuffer"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyBuffer);
    if(!strcmp(pName, "vkCreateBufferView"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateBufferView);
    if(!strcmp(pName, "vkDestroyBufferView"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyBufferView);
    if(!strcmp(pName, "vkCreateImage"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateImage);
    if(!strcmp(pName, "vkDestroyImage"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyImage);
    if(!strcmp(pName, "vkGetImageSubresourceLayout"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetImageSubresourceLayout);
    if(!strcmp(pName, "vkCreateImageView"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateImageView);
    if(!strcmp(pName, "vkDestroyImageView"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyImageView);
    if(!strcmp(pName, "vkCreateShaderModule"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateShaderModule);
    if(!strcmp(pName, "vkDestroyShaderModule"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyShaderModule);
    if(!strcmp(pName, "vkCreatePipelineCache"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreatePipelineCache);
    if(!strcmp(pName, "vkDestroyPipelineCache"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyPipelineCache);
    if(!strcmp(pName, "vkGetPipelineCacheData"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetPipelineCacheData);
    if(!strcmp(pName, "vkMergePipelineCaches"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkMergePipelineCaches);
    if(!strcmp(pName, "vkCreateGraphicsPipelines"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateGraphicsPipelines);
    if(!strcmp(pName, "vkCreateComputePipelines"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateComputePipelines);
    if(!strcmp(pName, "vkDestroyPipeline"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyPipeline);
    if(!strcmp(pName, "vkCreatePipelineLayout"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreatePipelineLayout);
    if(!strcmp(pName, "vkDestroyPipelineLayout"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyPipelineLayout);
    if(!strcmp(pName, "vkCreateSampler"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateSampler);
    if(!strcmp(pName, "vkDestroySampler"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroySampler);
    if(!strcmp(pName, "vkCreateDescriptorSetLayout"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateDescriptorSetLayout);
    if(!strcmp(pName, "vkDestroyDescriptorSetLayout"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyDescriptorSetLayout);
    if(!strcmp(pName, "vkCreateDescriptorPool"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateDescriptorPool);
    if(!strcmp(pName, "vkDestroyDescriptorPool"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyDescriptorPool);
    if(!strcmp(pName, "vkResetDescriptorPool"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkResetDescriptorPool);
    if(!strcmp(pName, "vkAllocateDescriptorSets"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkAllocateDescriptorSets);
    if(!strcmp(pName, "vkFreeDescriptorSets"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkFreeDescriptorSets);
    if(!strcmp(pName, "vkUpdateDescriptorSets"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkUpdateDescriptorSets);
    if(!strcmp(pName, "vkCreateFramebuffer"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateFramebuffer);
    if(!strcmp(pName, "vkDestroyFramebuffer"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyFramebuffer);
    if(!strcmp(pName, "vkCreateRenderPass"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateRenderPass);
    if(!strcmp(pName, "vkDestroyRenderPass"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyRenderPass);
    if(!strcmp(pName, "vkGetRenderAreaGranularity"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetRenderAreaGranularity);
    if(!strcmp(pName, "vkCreateCommandPool"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateCommandPool);
    if(!strcmp(pName, "vkDestroyCommandPool"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroyCommandPool);
    if(!strcmp(pName, "vkResetCommandPool"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkResetCommandPool);
    if(!strcmp(pName, "vkAllocateCommandBuffers"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkAllocateCommandBuffers);
    if(!strcmp(pName, "vkFreeCommandBuffers"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkFreeCommandBuffers);
    if(!strcmp(pName, "vkBeginCommandBuffer"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkBeginCommandBuffer);
    if(!strcmp(pName, "vkEndCommandBuffer"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkEndCommandBuffer);
    if(!strcmp(pName, "vkResetCommandBuffer"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkResetCommandBuffer);
    if(!strcmp(pName, "vkCmdBindPipeline"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdBindPipeline);
    if(!strcmp(pName, "vkCmdSetViewport"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdSetViewport);
    if(!strcmp(pName, "vkCmdSetScissor"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdSetScissor);
    if(!strcmp(pName, "vkCmdSetLineWidth"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdSetLineWidth);
    if(!strcmp(pName, "vkCmdSetDepthBias"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdSetDepthBias);
    if(!strcmp(pName, "vkCmdSetBlendConstants"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdSetBlendConstants);
    if(!strcmp(pName, "vkCmdSetDepthBounds"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdSetDepthBounds);
    if(!strcmp(pName, "vkCmdSetStencilCompareMask"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdSetStencilCompareMask);
    if(!strcmp(pName, "vkCmdSetStencilWriteMask"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdSetStencilWriteMask);
    if(!strcmp(pName, "vkCmdSetStencilReference"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdSetStencilReference);
    if(!strcmp(pName, "vkCmdBindDescriptorSets"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdBindDescriptorSets);
    if(!strcmp(pName, "vkCmdBindIndexBuffer"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdBindIndexBuffer);
    if(!strcmp(pName, "vkCmdBindVertexBuffers"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdBindVertexBuffers);
    if(!strcmp(pName, "vkCmdDraw"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdDraw);
    if(!strcmp(pName, "vkCmdDrawIndexed"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdDrawIndexed);
    if(!strcmp(pName, "vkCmdDrawIndirect"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdDrawIndirect);
    if(!strcmp(pName, "vkCmdDrawIndexedIndirect"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdDrawIndexedIndirect);
    if(!strcmp(pName, "vkCmdDispatch"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdDispatch);
    if(!strcmp(pName, "vkCmdDispatchIndirect"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdDispatchIndirect);
    if(!strcmp(pName, "vkCmdCopyBuffer"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdCopyBuffer);
    if(!strcmp(pName, "vkCmdCopyImage"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdCopyImage);
    if(!strcmp(pName, "vkCmdBlitImage"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdBlitImage);
    if(!strcmp(pName, "vkCmdCopyBufferToImage"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdCopyBufferToImage);
    if(!strcmp(pName, "vkCmdCopyImageToBuffer"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdCopyImageToBuffer);
    if(!strcmp(pName, "vkCmdUpdateBuffer"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdUpdateBuffer);
    if(!strcmp(pName, "vkCmdFillBuffer"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdFillBuffer);
    if(!strcmp(pName, "vkCmdClearColorImage"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdClearColorImage);
    if(!strcmp(pName, "vkCmdClearDepthStencilImage"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdClearDepthStencilImage);
    if(!strcmp(pName, "vkCmdClearAttachments"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdClearAttachments);
    if(!strcmp(pName, "vkCmdResolveImage"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdResolveImage);
    if(!strcmp(pName, "vkCmdSetEvent"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdSetEvent);
    if(!strcmp(pName, "vkCmdResetEvent"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdResetEvent);
    if(!strcmp(pName, "vkCmdWaitEvents"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdWaitEvents);
    if(!strcmp(pName, "vkCmdPipelineBarrier"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdPipelineBarrier);
    if(!strcmp(pName, "vkCmdBeginQuery"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdBeginQuery);
    if(!strcmp(pName, "vkCmdEndQuery"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdEndQuery);
    if(!strcmp(pName, "vkCmdResetQueryPool"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdResetQueryPool);
    if(!strcmp(pName, "vkCmdWriteTimestamp"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdWriteTimestamp);
    if(!strcmp(pName, "vkCmdCopyQueryPoolResults"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdCopyQueryPoolResults);
    if(!strcmp(pName, "vkCmdPushConstants"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdPushConstants);
    if(!strcmp(pName, "vkCmdBeginRenderPass"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdBeginRenderPass);
    if(!strcmp(pName, "vkCmdNextSubpass"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdNextSubpass);
    if(!strcmp(pName, "vkCmdEndRenderPass"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdEndRenderPass);
    if(!strcmp(pName, "vkCmdExecuteCommands"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCmdExecuteCommands);
    if(!strcmp(pName, "vkCreateSwapchainKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateSwapchainKHR);
    if(!strcmp(pName, "vkDestroySwapchainKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkDestroySwapchainKHR);
    if(!strcmp(pName, "vkGetSwapchainImagesKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkGetSwapchainImagesKHR);
    if(!strcmp(pName, "vkAcquireNextImageKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkAcquireNextImageKHR);
    if(!strcmp(pName, "vkQueuePresentKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkQueuePresentKHR);
    if(!strcmp(pName, "vkCreateSharedSwapchainsKHR"))
    return reinterpret_cast<PFN_vkVoidFunction>(gapii::vkCreateSharedSwapchainsKHR);
    return nullptr;
}
uint32_t VulkanSpy::SpyOverride_vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) {
    *pCount = 0;
    return VkResult::VK_SUCCESS;
}
uint32_t VulkanSpy::SpyOverride_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) {
    *pCount = 0;
    return VkResult::VK_SUCCESS;
}
void VulkanSpy::SpyOverride_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
    auto functions = mImports.mDeviceFunctions.find(device);
    if (functions == mImports.mDeviceFunctions.end() ||
    mImports.mDeviceFunctions[device].vkGetDeviceQueue == nullptr) {
        GAPID_WARNING("Application called unsupported function vkGetDeviceQueue");
        return;
    }
    functions->second.vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
    mImports.mQueuesToDevices[*pQueue] = device;
}
uint32_t VulkanSpy::SpyOverride_vkAllocateCommandBuffers(VkDevice device, VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
    auto functions = mImports.mDeviceFunctions.find(device);
    if (functions == mImports.mDeviceFunctions.end() ||
    mImports.mDeviceFunctions[device].vkAllocateCommandBuffers == nullptr) {
        GAPID_WARNING("Application called unsupported function vkAllocateCommandBuffers");
        return 0;
    }
    auto ret = functions->second.vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
    if (ret == VkResult::VK_SUCCESS) {
        for(size_t i = 0; i < pAllocateInfo->mcommandBufferCount; ++i) {
            mImports.mCommandBuffersToDevices[pCommandBuffers[i]] = device;
        }
    }
    return ret;
}
uint32_t VulkanSpy::SpyOverride_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) {
    auto it = mImports.mInstanceFunctions.find(instance);
    auto& dat = it->second;
    if (dat.mPhysicalDevices.empty()) {
        uint32_t count;
        uint32_t res = dat.vkEnumeratePhysicalDevices(instance, &count, nullptr);
        if (res != VkResult::VK_SUCCESS) {
            return res;
        }
        dat.mPhysicalDevices.resize(count);
        if (VkResult::VK_SUCCESS !=
        (res = dat.vkEnumeratePhysicalDevices(
        instance, &count, dat.mPhysicalDevices.data()))) {
            dat.mPhysicalDevices.clear();
            return res;
        }
    }
    for(auto device: dat.mPhysicalDevices) {
        mImports.mPhysicalDevicesToInstances[device] = instance;
    }
    uint32_t count = dat.mPhysicalDevices.size();
    if (pPhysicalDevices) {
        if (*pPhysicalDeviceCount > count)
        *pPhysicalDeviceCount = count;
        memcpy(pPhysicalDevices, dat.mPhysicalDevices.data(),
        *pPhysicalDeviceCount * sizeof(VkPhysicalDevice *));
    } else {
        *pPhysicalDeviceCount = count;
    }
    return VkResult::VK_SUCCESS;
}
uint32_t VulkanSpy::SpyOverride_vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
    VkLayerInstanceCreateInfo *layer_info = get_layer_link_info(pCreateInfo);
    // Grab the pointer to the next vkGetInstanceProcAddr in the chain.
    gapii::VulkanImports::PFNVKGETINSTANCEPROCADDR get_instance_proc_addr =
    layer_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
    // From that get the next vkCreateInstance function.
    gapii::VulkanImports::PFNVKCREATEINSTANCE create_instance = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEINSTANCE>(
    get_instance_proc_addr(0, "vkCreateInstance"));
    if (create_instance == NULL) {
        return VkResult::VK_ERROR_INITIALIZATION_FAILED;
    }
    // The next layer may read from layer_info,
    // so increment the pointer for it.
    layer_info->u.pLayerInfo = layer_info->u.pLayerInfo->pNext;
    // Actually call vkCreateInstance, and keep track of the result.
    uint32_t result = create_instance(pCreateInfo, pAllocator, pInstance);
    // If it failed, then we don't need to track this instance.
    if (result != VkResult::VK_SUCCESS) return result;
    // Add this instance, along with the vkGetInstanceProcAddr to our
    // map. This way when someone calls vkGetInstanceProcAddr, we can forward
    // it to the correct "next" vkGetInstanceProcAddr.
    {
        // The same instance was returned twice, this is a problem.
        auto insert_pt = mImports.mInstanceFunctions.insert({*pInstance, {}});
        if (!insert_pt.second) {
            // TODO(awoloszyn): Figure out if this is valid. Can an implementation return the same
            // instance for all calls to vkCreateInstance.
            return VkResult::VK_ERROR_INITIALIZATION_FAILED;
        }
        insert_pt.first->second.vkCreateAndroidSurfaceKHR = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEANDROIDSURFACEKHR>(get_instance_proc_addr(*pInstance, "vkCreateAndroidSurfaceKHR"));
        insert_pt.first->second.vkCreateInstance = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEINSTANCE>(get_instance_proc_addr(*pInstance, "vkCreateInstance"));
        insert_pt.first->second.vkDestroyInstance = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYINSTANCE>(get_instance_proc_addr(*pInstance, "vkDestroyInstance"));
        insert_pt.first->second.vkEnumeratePhysicalDevices = reinterpret_cast<gapii::VulkanImports::PFNVKENUMERATEPHYSICALDEVICES>(get_instance_proc_addr(*pInstance, "vkEnumeratePhysicalDevices"));
        insert_pt.first->second.vkGetInstanceProcAddr = reinterpret_cast<gapii::VulkanImports::PFNVKGETINSTANCEPROCADDR>(get_instance_proc_addr(*pInstance, "vkGetInstanceProcAddr"));
        insert_pt.first->second.vkDestroySurfaceKHR = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYSURFACEKHR>(get_instance_proc_addr(*pInstance, "vkDestroySurfaceKHR"));
        insert_pt.first->second.vkCreateDisplayPlaneSurfaceKHR = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEDISPLAYPLANESURFACEKHR>(get_instance_proc_addr(*pInstance, "vkCreateDisplayPlaneSurfaceKHR"));
        insert_pt.first->second.vkCreateDebugReportCallbackEXT = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEDEBUGREPORTCALLBACKEXT>(get_instance_proc_addr(*pInstance, "vkCreateDebugReportCallbackEXT"));
        insert_pt.first->second.vkDestroyDebugReportCallbackEXT = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYDEBUGREPORTCALLBACKEXT>(get_instance_proc_addr(*pInstance, "vkDestroyDebugReportCallbackEXT"));
        insert_pt.first->second.vkDebugReportMessageEXT = reinterpret_cast<gapii::VulkanImports::PFNVKDEBUGREPORTMESSAGEEXT>(get_instance_proc_addr(*pInstance, "vkDebugReportMessageEXT"));
        insert_pt.first->second.vkGetPhysicalDeviceFeatures = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICEFEATURES>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceFeatures"));
        insert_pt.first->second.vkGetPhysicalDeviceFormatProperties = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICEFORMATPROPERTIES>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceFormatProperties"));
        insert_pt.first->second.vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICEIMAGEFORMATPROPERTIES>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceImageFormatProperties"));
        insert_pt.first->second.vkGetPhysicalDeviceProperties = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICEPROPERTIES>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceProperties"));
        insert_pt.first->second.vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICEQUEUEFAMILYPROPERTIES>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceQueueFamilyProperties"));
        insert_pt.first->second.vkGetPhysicalDeviceMemoryProperties = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICEMEMORYPROPERTIES>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceMemoryProperties"));
        insert_pt.first->second.vkCreateDevice = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEDEVICE>(get_instance_proc_addr(*pInstance, "vkCreateDevice"));
        insert_pt.first->second.vkEnumerateDeviceExtensionProperties = reinterpret_cast<gapii::VulkanImports::PFNVKENUMERATEDEVICEEXTENSIONPROPERTIES>(get_instance_proc_addr(*pInstance, "vkEnumerateDeviceExtensionProperties"));
        insert_pt.first->second.vkEnumerateDeviceLayerProperties = reinterpret_cast<gapii::VulkanImports::PFNVKENUMERATEDEVICELAYERPROPERTIES>(get_instance_proc_addr(*pInstance, "vkEnumerateDeviceLayerProperties"));
        insert_pt.first->second.vkGetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICESPARSEIMAGEFORMATPROPERTIES>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceSparseImageFormatProperties"));
        insert_pt.first->second.vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICESURFACESUPPORTKHR>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceSurfaceSupportKHR"));
        insert_pt.first->second.vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICESURFACECAPABILITIESKHR>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
        insert_pt.first->second.vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICESURFACEFORMATSKHR>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
        insert_pt.first->second.vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICESURFACEPRESENTMODESKHR>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
        insert_pt.first->second.vkGetPhysicalDeviceDisplayPropertiesKHR = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICEDISPLAYPROPERTIESKHR>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceDisplayPropertiesKHR"));
        insert_pt.first->second.vkGetPhysicalDeviceDisplayPlanePropertiesKHR = reinterpret_cast<gapii::VulkanImports::PFNVKGETPHYSICALDEVICEDISPLAYPLANEPROPERTIESKHR>(get_instance_proc_addr(*pInstance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"));
        insert_pt.first->second.vkGetDisplayPlaneSupportedDisplaysKHR = reinterpret_cast<gapii::VulkanImports::PFNVKGETDISPLAYPLANESUPPORTEDDISPLAYSKHR>(get_instance_proc_addr(*pInstance, "vkGetDisplayPlaneSupportedDisplaysKHR"));
        insert_pt.first->second.vkGetDisplayModePropertiesKHR = reinterpret_cast<gapii::VulkanImports::PFNVKGETDISPLAYMODEPROPERTIESKHR>(get_instance_proc_addr(*pInstance, "vkGetDisplayModePropertiesKHR"));
        insert_pt.first->second.vkCreateDisplayModeKHR = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEDISPLAYMODEKHR>(get_instance_proc_addr(*pInstance, "vkCreateDisplayModeKHR"));
        insert_pt.first->second.vkGetDisplayPlaneCapabilitiesKHR = reinterpret_cast<gapii::VulkanImports::PFNVKGETDISPLAYPLANECAPABILITIESKHR>(get_instance_proc_addr(*pInstance, "vkGetDisplayPlaneCapabilitiesKHR"));
        insert_pt.first->second.vkEnumerateInstanceExtensionProperties =
        reinterpret_cast<VulkanImports::PFNVKENUMERATEINSTANCEEXTENSIONPROPERTIES>(get_instance_proc_addr(*pInstance, "VkEnumerateInstanceExtensionProperties"));
        insert_pt.first->second.vkEnumerateDeviceExtensionProperties =
        reinterpret_cast<VulkanImports::PFNVKENUMERATEDEVICEEXTENSIONPROPERTIES>(
        get_instance_proc_addr(*pInstance, "vkEnumerateDeviceExtensionProperties"));
    }
    return result;
}
void VulkanSpy::SpyOverride_vkDestroyInstance(VkInstance instance, VkAllocationCallbacks* pAllocator) {
    // First we have to find the function to chain to, then we have to
    // remove this instance from our list, then we forward the call.
    auto it = mImports.mInstanceFunctions.find(instance);
    gapii::VulkanImports::PFNVKDESTROYINSTANCE destroy_instance =
    it == mImports.mInstanceFunctions.end() ? nullptr :
    it->second.vkDestroyInstance;
    if (destroy_instance) {
        destroy_instance(instance, pAllocator);
    }
    mImports.mInstanceFunctions.erase(mImports.mInstanceFunctions.find(instance));
}
uint32_t VulkanSpy::SpyOverride_vkCreateDevice(VkPhysicalDevice physicalDevice, VkDeviceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
    VkLayerDeviceCreateInfo *layer_info = get_layer_link_info(pCreateInfo);
    // Grab the fpGetInstanceProcAddr from the layer_info. We will get
    // vkCreateDevice from this.
    // Note: we cannot use our instance_map because we do not have a
    // vkInstance here.
    gapii::VulkanImports::PFNVKGETINSTANCEPROCADDR get_instance_proc_addr =
    layer_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
    gapii::VulkanImports::PFNVKCREATEDEVICE create_device = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEDEVICE>(
    get_instance_proc_addr(0, "vkCreateDevice"));
    if (!create_device) {
        return VkResult::VK_ERROR_INITIALIZATION_FAILED;
    }
    // We want to store off the next vkGetDeviceProcAddr so keep track of it now,
    // keep track of it now, before we increment the pointer.
    gapii::VulkanImports::PFNVKGETDEVICEPROCADDR get_device_proc_addr =
    layer_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
    // The next layer may read from layer_info,
    // so increment the pointer for it.
    layer_info->u.pLayerInfo = layer_info->u.pLayerInfo->pNext;
    // Actually make the call to vkCreateDevice.
    uint32_t result = create_device(physicalDevice, pCreateInfo, pAllocator, pDevice);
    // If we failed, then we don't store the associated pointers.
    if (result != VkResult::VK_SUCCESS) {
        return result;
    }
    gapii::VulkanImports::PFNVKDESTROYDEVICE destroy_device = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYDEVICE>(
    get_device_proc_addr(*pDevice, "vkDestroyDevice"));
    // Add this device, along with the vkGetDeviceProcAddr to our map.
    // This way when someone calls vkGetDeviceProcAddr, we can forward
    // it to the correct "next" vkGetDeviceProcAddr.
    {
        auto insert_pt = mImports.mDeviceFunctions.insert({*pDevice, {}});
        if (!insert_pt.second) {
            return VkResult::VK_ERROR_INITIALIZATION_FAILED;
        }
        insert_pt.first->second.vkGetSwapchainGrallocUsageANDROID = reinterpret_cast<gapii::VulkanImports::PFNVKGETSWAPCHAINGRALLOCUSAGEANDROID>(get_device_proc_addr(*pDevice, "vkGetSwapchainGrallocUsageANDROID"));
        insert_pt.first->second.vkAcquireImageANDROID = reinterpret_cast<gapii::VulkanImports::PFNVKACQUIREIMAGEANDROID>(get_device_proc_addr(*pDevice, "vkAcquireImageANDROID"));
        insert_pt.first->second.vkQueueSignalReleaseImageANDROID = reinterpret_cast<gapii::VulkanImports::PFNVKQUEUESIGNALRELEASEIMAGEANDROID>(get_device_proc_addr(*pDevice, "vkQueueSignalReleaseImageANDROID"));
        insert_pt.first->second.vkGetDeviceProcAddr = reinterpret_cast<gapii::VulkanImports::PFNVKGETDEVICEPROCADDR>(get_device_proc_addr(*pDevice, "vkGetDeviceProcAddr"));
        insert_pt.first->second.vkDestroyDevice = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYDEVICE>(get_device_proc_addr(*pDevice, "vkDestroyDevice"));
        insert_pt.first->second.vkGetDeviceQueue = reinterpret_cast<gapii::VulkanImports::PFNVKGETDEVICEQUEUE>(get_device_proc_addr(*pDevice, "vkGetDeviceQueue"));
        insert_pt.first->second.vkQueueSubmit = reinterpret_cast<gapii::VulkanImports::PFNVKQUEUESUBMIT>(get_device_proc_addr(*pDevice, "vkQueueSubmit"));
        insert_pt.first->second.vkQueueWaitIdle = reinterpret_cast<gapii::VulkanImports::PFNVKQUEUEWAITIDLE>(get_device_proc_addr(*pDevice, "vkQueueWaitIdle"));
        insert_pt.first->second.vkDeviceWaitIdle = reinterpret_cast<gapii::VulkanImports::PFNVKDEVICEWAITIDLE>(get_device_proc_addr(*pDevice, "vkDeviceWaitIdle"));
        insert_pt.first->second.vkAllocateMemory = reinterpret_cast<gapii::VulkanImports::PFNVKALLOCATEMEMORY>(get_device_proc_addr(*pDevice, "vkAllocateMemory"));
        insert_pt.first->second.vkFreeMemory = reinterpret_cast<gapii::VulkanImports::PFNVKFREEMEMORY>(get_device_proc_addr(*pDevice, "vkFreeMemory"));
        insert_pt.first->second.vkMapMemory = reinterpret_cast<gapii::VulkanImports::PFNVKMAPMEMORY>(get_device_proc_addr(*pDevice, "vkMapMemory"));
        insert_pt.first->second.vkUnmapMemory = reinterpret_cast<gapii::VulkanImports::PFNVKUNMAPMEMORY>(get_device_proc_addr(*pDevice, "vkUnmapMemory"));
        insert_pt.first->second.vkFlushMappedMemoryRanges = reinterpret_cast<gapii::VulkanImports::PFNVKFLUSHMAPPEDMEMORYRANGES>(get_device_proc_addr(*pDevice, "vkFlushMappedMemoryRanges"));
        insert_pt.first->second.vkInvalidateMappedMemoryRanges = reinterpret_cast<gapii::VulkanImports::PFNVKINVALIDATEMAPPEDMEMORYRANGES>(get_device_proc_addr(*pDevice, "vkInvalidateMappedMemoryRanges"));
        insert_pt.first->second.vkGetDeviceMemoryCommitment = reinterpret_cast<gapii::VulkanImports::PFNVKGETDEVICEMEMORYCOMMITMENT>(get_device_proc_addr(*pDevice, "vkGetDeviceMemoryCommitment"));
        insert_pt.first->second.vkBindBufferMemory = reinterpret_cast<gapii::VulkanImports::PFNVKBINDBUFFERMEMORY>(get_device_proc_addr(*pDevice, "vkBindBufferMemory"));
        insert_pt.first->second.vkBindImageMemory = reinterpret_cast<gapii::VulkanImports::PFNVKBINDIMAGEMEMORY>(get_device_proc_addr(*pDevice, "vkBindImageMemory"));
        insert_pt.first->second.vkGetBufferMemoryRequirements = reinterpret_cast<gapii::VulkanImports::PFNVKGETBUFFERMEMORYREQUIREMENTS>(get_device_proc_addr(*pDevice, "vkGetBufferMemoryRequirements"));
        insert_pt.first->second.vkGetImageMemoryRequirements = reinterpret_cast<gapii::VulkanImports::PFNVKGETIMAGEMEMORYREQUIREMENTS>(get_device_proc_addr(*pDevice, "vkGetImageMemoryRequirements"));
        insert_pt.first->second.vkGetImageSparseMemoryRequirements = reinterpret_cast<gapii::VulkanImports::PFNVKGETIMAGESPARSEMEMORYREQUIREMENTS>(get_device_proc_addr(*pDevice, "vkGetImageSparseMemoryRequirements"));
        insert_pt.first->second.vkQueueBindSparse = reinterpret_cast<gapii::VulkanImports::PFNVKQUEUEBINDSPARSE>(get_device_proc_addr(*pDevice, "vkQueueBindSparse"));
        insert_pt.first->second.vkCreateFence = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEFENCE>(get_device_proc_addr(*pDevice, "vkCreateFence"));
        insert_pt.first->second.vkDestroyFence = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYFENCE>(get_device_proc_addr(*pDevice, "vkDestroyFence"));
        insert_pt.first->second.vkResetFences = reinterpret_cast<gapii::VulkanImports::PFNVKRESETFENCES>(get_device_proc_addr(*pDevice, "vkResetFences"));
        insert_pt.first->second.vkGetFenceStatus = reinterpret_cast<gapii::VulkanImports::PFNVKGETFENCESTATUS>(get_device_proc_addr(*pDevice, "vkGetFenceStatus"));
        insert_pt.first->second.vkWaitForFences = reinterpret_cast<gapii::VulkanImports::PFNVKWAITFORFENCES>(get_device_proc_addr(*pDevice, "vkWaitForFences"));
        insert_pt.first->second.vkCreateSemaphore = reinterpret_cast<gapii::VulkanImports::PFNVKCREATESEMAPHORE>(get_device_proc_addr(*pDevice, "vkCreateSemaphore"));
        insert_pt.first->second.vkDestroySemaphore = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYSEMAPHORE>(get_device_proc_addr(*pDevice, "vkDestroySemaphore"));
        insert_pt.first->second.vkCreateEvent = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEEVENT>(get_device_proc_addr(*pDevice, "vkCreateEvent"));
        insert_pt.first->second.vkDestroyEvent = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYEVENT>(get_device_proc_addr(*pDevice, "vkDestroyEvent"));
        insert_pt.first->second.vkGetEventStatus = reinterpret_cast<gapii::VulkanImports::PFNVKGETEVENTSTATUS>(get_device_proc_addr(*pDevice, "vkGetEventStatus"));
        insert_pt.first->second.vkSetEvent = reinterpret_cast<gapii::VulkanImports::PFNVKSETEVENT>(get_device_proc_addr(*pDevice, "vkSetEvent"));
        insert_pt.first->second.vkResetEvent = reinterpret_cast<gapii::VulkanImports::PFNVKRESETEVENT>(get_device_proc_addr(*pDevice, "vkResetEvent"));
        insert_pt.first->second.vkCreateQueryPool = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEQUERYPOOL>(get_device_proc_addr(*pDevice, "vkCreateQueryPool"));
        insert_pt.first->second.vkDestroyQueryPool = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYQUERYPOOL>(get_device_proc_addr(*pDevice, "vkDestroyQueryPool"));
        insert_pt.first->second.vkGetQueryPoolResults = reinterpret_cast<gapii::VulkanImports::PFNVKGETQUERYPOOLRESULTS>(get_device_proc_addr(*pDevice, "vkGetQueryPoolResults"));
        insert_pt.first->second.vkCreateBuffer = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEBUFFER>(get_device_proc_addr(*pDevice, "vkCreateBuffer"));
        insert_pt.first->second.vkDestroyBuffer = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYBUFFER>(get_device_proc_addr(*pDevice, "vkDestroyBuffer"));
        insert_pt.first->second.vkCreateBufferView = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEBUFFERVIEW>(get_device_proc_addr(*pDevice, "vkCreateBufferView"));
        insert_pt.first->second.vkDestroyBufferView = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYBUFFERVIEW>(get_device_proc_addr(*pDevice, "vkDestroyBufferView"));
        insert_pt.first->second.vkCreateImage = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEIMAGE>(get_device_proc_addr(*pDevice, "vkCreateImage"));
        insert_pt.first->second.vkDestroyImage = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYIMAGE>(get_device_proc_addr(*pDevice, "vkDestroyImage"));
        insert_pt.first->second.vkGetImageSubresourceLayout = reinterpret_cast<gapii::VulkanImports::PFNVKGETIMAGESUBRESOURCELAYOUT>(get_device_proc_addr(*pDevice, "vkGetImageSubresourceLayout"));
        insert_pt.first->second.vkCreateImageView = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEIMAGEVIEW>(get_device_proc_addr(*pDevice, "vkCreateImageView"));
        insert_pt.first->second.vkDestroyImageView = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYIMAGEVIEW>(get_device_proc_addr(*pDevice, "vkDestroyImageView"));
        insert_pt.first->second.vkCreateShaderModule = reinterpret_cast<gapii::VulkanImports::PFNVKCREATESHADERMODULE>(get_device_proc_addr(*pDevice, "vkCreateShaderModule"));
        insert_pt.first->second.vkDestroyShaderModule = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYSHADERMODULE>(get_device_proc_addr(*pDevice, "vkDestroyShaderModule"));
        insert_pt.first->second.vkCreatePipelineCache = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEPIPELINECACHE>(get_device_proc_addr(*pDevice, "vkCreatePipelineCache"));
        insert_pt.first->second.vkDestroyPipelineCache = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYPIPELINECACHE>(get_device_proc_addr(*pDevice, "vkDestroyPipelineCache"));
        insert_pt.first->second.vkGetPipelineCacheData = reinterpret_cast<gapii::VulkanImports::PFNVKGETPIPELINECACHEDATA>(get_device_proc_addr(*pDevice, "vkGetPipelineCacheData"));
        insert_pt.first->second.vkMergePipelineCaches = reinterpret_cast<gapii::VulkanImports::PFNVKMERGEPIPELINECACHES>(get_device_proc_addr(*pDevice, "vkMergePipelineCaches"));
        insert_pt.first->second.vkCreateGraphicsPipelines = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEGRAPHICSPIPELINES>(get_device_proc_addr(*pDevice, "vkCreateGraphicsPipelines"));
        insert_pt.first->second.vkCreateComputePipelines = reinterpret_cast<gapii::VulkanImports::PFNVKCREATECOMPUTEPIPELINES>(get_device_proc_addr(*pDevice, "vkCreateComputePipelines"));
        insert_pt.first->second.vkDestroyPipeline = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYPIPELINE>(get_device_proc_addr(*pDevice, "vkDestroyPipeline"));
        insert_pt.first->second.vkCreatePipelineLayout = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEPIPELINELAYOUT>(get_device_proc_addr(*pDevice, "vkCreatePipelineLayout"));
        insert_pt.first->second.vkDestroyPipelineLayout = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYPIPELINELAYOUT>(get_device_proc_addr(*pDevice, "vkDestroyPipelineLayout"));
        insert_pt.first->second.vkCreateSampler = reinterpret_cast<gapii::VulkanImports::PFNVKCREATESAMPLER>(get_device_proc_addr(*pDevice, "vkCreateSampler"));
        insert_pt.first->second.vkDestroySampler = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYSAMPLER>(get_device_proc_addr(*pDevice, "vkDestroySampler"));
        insert_pt.first->second.vkCreateDescriptorSetLayout = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEDESCRIPTORSETLAYOUT>(get_device_proc_addr(*pDevice, "vkCreateDescriptorSetLayout"));
        insert_pt.first->second.vkDestroyDescriptorSetLayout = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYDESCRIPTORSETLAYOUT>(get_device_proc_addr(*pDevice, "vkDestroyDescriptorSetLayout"));
        insert_pt.first->second.vkCreateDescriptorPool = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEDESCRIPTORPOOL>(get_device_proc_addr(*pDevice, "vkCreateDescriptorPool"));
        insert_pt.first->second.vkDestroyDescriptorPool = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYDESCRIPTORPOOL>(get_device_proc_addr(*pDevice, "vkDestroyDescriptorPool"));
        insert_pt.first->second.vkResetDescriptorPool = reinterpret_cast<gapii::VulkanImports::PFNVKRESETDESCRIPTORPOOL>(get_device_proc_addr(*pDevice, "vkResetDescriptorPool"));
        insert_pt.first->second.vkAllocateDescriptorSets = reinterpret_cast<gapii::VulkanImports::PFNVKALLOCATEDESCRIPTORSETS>(get_device_proc_addr(*pDevice, "vkAllocateDescriptorSets"));
        insert_pt.first->second.vkFreeDescriptorSets = reinterpret_cast<gapii::VulkanImports::PFNVKFREEDESCRIPTORSETS>(get_device_proc_addr(*pDevice, "vkFreeDescriptorSets"));
        insert_pt.first->second.vkUpdateDescriptorSets = reinterpret_cast<gapii::VulkanImports::PFNVKUPDATEDESCRIPTORSETS>(get_device_proc_addr(*pDevice, "vkUpdateDescriptorSets"));
        insert_pt.first->second.vkCreateFramebuffer = reinterpret_cast<gapii::VulkanImports::PFNVKCREATEFRAMEBUFFER>(get_device_proc_addr(*pDevice, "vkCreateFramebuffer"));
        insert_pt.first->second.vkDestroyFramebuffer = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYFRAMEBUFFER>(get_device_proc_addr(*pDevice, "vkDestroyFramebuffer"));
        insert_pt.first->second.vkCreateRenderPass = reinterpret_cast<gapii::VulkanImports::PFNVKCREATERENDERPASS>(get_device_proc_addr(*pDevice, "vkCreateRenderPass"));
        insert_pt.first->second.vkDestroyRenderPass = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYRENDERPASS>(get_device_proc_addr(*pDevice, "vkDestroyRenderPass"));
        insert_pt.first->second.vkGetRenderAreaGranularity = reinterpret_cast<gapii::VulkanImports::PFNVKGETRENDERAREAGRANULARITY>(get_device_proc_addr(*pDevice, "vkGetRenderAreaGranularity"));
        insert_pt.first->second.vkCreateCommandPool = reinterpret_cast<gapii::VulkanImports::PFNVKCREATECOMMANDPOOL>(get_device_proc_addr(*pDevice, "vkCreateCommandPool"));
        insert_pt.first->second.vkDestroyCommandPool = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYCOMMANDPOOL>(get_device_proc_addr(*pDevice, "vkDestroyCommandPool"));
        insert_pt.first->second.vkResetCommandPool = reinterpret_cast<gapii::VulkanImports::PFNVKRESETCOMMANDPOOL>(get_device_proc_addr(*pDevice, "vkResetCommandPool"));
        insert_pt.first->second.vkAllocateCommandBuffers = reinterpret_cast<gapii::VulkanImports::PFNVKALLOCATECOMMANDBUFFERS>(get_device_proc_addr(*pDevice, "vkAllocateCommandBuffers"));
        insert_pt.first->second.vkFreeCommandBuffers = reinterpret_cast<gapii::VulkanImports::PFNVKFREECOMMANDBUFFERS>(get_device_proc_addr(*pDevice, "vkFreeCommandBuffers"));
        insert_pt.first->second.vkBeginCommandBuffer = reinterpret_cast<gapii::VulkanImports::PFNVKBEGINCOMMANDBUFFER>(get_device_proc_addr(*pDevice, "vkBeginCommandBuffer"));
        insert_pt.first->second.vkEndCommandBuffer = reinterpret_cast<gapii::VulkanImports::PFNVKENDCOMMANDBUFFER>(get_device_proc_addr(*pDevice, "vkEndCommandBuffer"));
        insert_pt.first->second.vkResetCommandBuffer = reinterpret_cast<gapii::VulkanImports::PFNVKRESETCOMMANDBUFFER>(get_device_proc_addr(*pDevice, "vkResetCommandBuffer"));
        insert_pt.first->second.vkCmdBindPipeline = reinterpret_cast<gapii::VulkanImports::PFNVKCMDBINDPIPELINE>(get_device_proc_addr(*pDevice, "vkCmdBindPipeline"));
        insert_pt.first->second.vkCmdSetViewport = reinterpret_cast<gapii::VulkanImports::PFNVKCMDSETVIEWPORT>(get_device_proc_addr(*pDevice, "vkCmdSetViewport"));
        insert_pt.first->second.vkCmdSetScissor = reinterpret_cast<gapii::VulkanImports::PFNVKCMDSETSCISSOR>(get_device_proc_addr(*pDevice, "vkCmdSetScissor"));
        insert_pt.first->second.vkCmdSetLineWidth = reinterpret_cast<gapii::VulkanImports::PFNVKCMDSETLINEWIDTH>(get_device_proc_addr(*pDevice, "vkCmdSetLineWidth"));
        insert_pt.first->second.vkCmdSetDepthBias = reinterpret_cast<gapii::VulkanImports::PFNVKCMDSETDEPTHBIAS>(get_device_proc_addr(*pDevice, "vkCmdSetDepthBias"));
        insert_pt.first->second.vkCmdSetBlendConstants = reinterpret_cast<gapii::VulkanImports::PFNVKCMDSETBLENDCONSTANTS>(get_device_proc_addr(*pDevice, "vkCmdSetBlendConstants"));
        insert_pt.first->second.vkCmdSetDepthBounds = reinterpret_cast<gapii::VulkanImports::PFNVKCMDSETDEPTHBOUNDS>(get_device_proc_addr(*pDevice, "vkCmdSetDepthBounds"));
        insert_pt.first->second.vkCmdSetStencilCompareMask = reinterpret_cast<gapii::VulkanImports::PFNVKCMDSETSTENCILCOMPAREMASK>(get_device_proc_addr(*pDevice, "vkCmdSetStencilCompareMask"));
        insert_pt.first->second.vkCmdSetStencilWriteMask = reinterpret_cast<gapii::VulkanImports::PFNVKCMDSETSTENCILWRITEMASK>(get_device_proc_addr(*pDevice, "vkCmdSetStencilWriteMask"));
        insert_pt.first->second.vkCmdSetStencilReference = reinterpret_cast<gapii::VulkanImports::PFNVKCMDSETSTENCILREFERENCE>(get_device_proc_addr(*pDevice, "vkCmdSetStencilReference"));
        insert_pt.first->second.vkCmdBindDescriptorSets = reinterpret_cast<gapii::VulkanImports::PFNVKCMDBINDDESCRIPTORSETS>(get_device_proc_addr(*pDevice, "vkCmdBindDescriptorSets"));
        insert_pt.first->second.vkCmdBindIndexBuffer = reinterpret_cast<gapii::VulkanImports::PFNVKCMDBINDINDEXBUFFER>(get_device_proc_addr(*pDevice, "vkCmdBindIndexBuffer"));
        insert_pt.first->second.vkCmdBindVertexBuffers = reinterpret_cast<gapii::VulkanImports::PFNVKCMDBINDVERTEXBUFFERS>(get_device_proc_addr(*pDevice, "vkCmdBindVertexBuffers"));
        insert_pt.first->second.vkCmdDraw = reinterpret_cast<gapii::VulkanImports::PFNVKCMDDRAW>(get_device_proc_addr(*pDevice, "vkCmdDraw"));
        insert_pt.first->second.vkCmdDrawIndexed = reinterpret_cast<gapii::VulkanImports::PFNVKCMDDRAWINDEXED>(get_device_proc_addr(*pDevice, "vkCmdDrawIndexed"));
        insert_pt.first->second.vkCmdDrawIndirect = reinterpret_cast<gapii::VulkanImports::PFNVKCMDDRAWINDIRECT>(get_device_proc_addr(*pDevice, "vkCmdDrawIndirect"));
        insert_pt.first->second.vkCmdDrawIndexedIndirect = reinterpret_cast<gapii::VulkanImports::PFNVKCMDDRAWINDEXEDINDIRECT>(get_device_proc_addr(*pDevice, "vkCmdDrawIndexedIndirect"));
        insert_pt.first->second.vkCmdDispatch = reinterpret_cast<gapii::VulkanImports::PFNVKCMDDISPATCH>(get_device_proc_addr(*pDevice, "vkCmdDispatch"));
        insert_pt.first->second.vkCmdDispatchIndirect = reinterpret_cast<gapii::VulkanImports::PFNVKCMDDISPATCHINDIRECT>(get_device_proc_addr(*pDevice, "vkCmdDispatchIndirect"));
        insert_pt.first->second.vkCmdCopyBuffer = reinterpret_cast<gapii::VulkanImports::PFNVKCMDCOPYBUFFER>(get_device_proc_addr(*pDevice, "vkCmdCopyBuffer"));
        insert_pt.first->second.vkCmdCopyImage = reinterpret_cast<gapii::VulkanImports::PFNVKCMDCOPYIMAGE>(get_device_proc_addr(*pDevice, "vkCmdCopyImage"));
        insert_pt.first->second.vkCmdBlitImage = reinterpret_cast<gapii::VulkanImports::PFNVKCMDBLITIMAGE>(get_device_proc_addr(*pDevice, "vkCmdBlitImage"));
        insert_pt.first->second.vkCmdCopyBufferToImage = reinterpret_cast<gapii::VulkanImports::PFNVKCMDCOPYBUFFERTOIMAGE>(get_device_proc_addr(*pDevice, "vkCmdCopyBufferToImage"));
        insert_pt.first->second.vkCmdCopyImageToBuffer = reinterpret_cast<gapii::VulkanImports::PFNVKCMDCOPYIMAGETOBUFFER>(get_device_proc_addr(*pDevice, "vkCmdCopyImageToBuffer"));
        insert_pt.first->second.vkCmdUpdateBuffer = reinterpret_cast<gapii::VulkanImports::PFNVKCMDUPDATEBUFFER>(get_device_proc_addr(*pDevice, "vkCmdUpdateBuffer"));
        insert_pt.first->second.vkCmdFillBuffer = reinterpret_cast<gapii::VulkanImports::PFNVKCMDFILLBUFFER>(get_device_proc_addr(*pDevice, "vkCmdFillBuffer"));
        insert_pt.first->second.vkCmdClearColorImage = reinterpret_cast<gapii::VulkanImports::PFNVKCMDCLEARCOLORIMAGE>(get_device_proc_addr(*pDevice, "vkCmdClearColorImage"));
        insert_pt.first->second.vkCmdClearDepthStencilImage = reinterpret_cast<gapii::VulkanImports::PFNVKCMDCLEARDEPTHSTENCILIMAGE>(get_device_proc_addr(*pDevice, "vkCmdClearDepthStencilImage"));
        insert_pt.first->second.vkCmdClearAttachments = reinterpret_cast<gapii::VulkanImports::PFNVKCMDCLEARATTACHMENTS>(get_device_proc_addr(*pDevice, "vkCmdClearAttachments"));
        insert_pt.first->second.vkCmdResolveImage = reinterpret_cast<gapii::VulkanImports::PFNVKCMDRESOLVEIMAGE>(get_device_proc_addr(*pDevice, "vkCmdResolveImage"));
        insert_pt.first->second.vkCmdSetEvent = reinterpret_cast<gapii::VulkanImports::PFNVKCMDSETEVENT>(get_device_proc_addr(*pDevice, "vkCmdSetEvent"));
        insert_pt.first->second.vkCmdResetEvent = reinterpret_cast<gapii::VulkanImports::PFNVKCMDRESETEVENT>(get_device_proc_addr(*pDevice, "vkCmdResetEvent"));
        insert_pt.first->second.vkCmdWaitEvents = reinterpret_cast<gapii::VulkanImports::PFNVKCMDWAITEVENTS>(get_device_proc_addr(*pDevice, "vkCmdWaitEvents"));
        insert_pt.first->second.vkCmdPipelineBarrier = reinterpret_cast<gapii::VulkanImports::PFNVKCMDPIPELINEBARRIER>(get_device_proc_addr(*pDevice, "vkCmdPipelineBarrier"));
        insert_pt.first->second.vkCmdBeginQuery = reinterpret_cast<gapii::VulkanImports::PFNVKCMDBEGINQUERY>(get_device_proc_addr(*pDevice, "vkCmdBeginQuery"));
        insert_pt.first->second.vkCmdEndQuery = reinterpret_cast<gapii::VulkanImports::PFNVKCMDENDQUERY>(get_device_proc_addr(*pDevice, "vkCmdEndQuery"));
        insert_pt.first->second.vkCmdResetQueryPool = reinterpret_cast<gapii::VulkanImports::PFNVKCMDRESETQUERYPOOL>(get_device_proc_addr(*pDevice, "vkCmdResetQueryPool"));
        insert_pt.first->second.vkCmdWriteTimestamp = reinterpret_cast<gapii::VulkanImports::PFNVKCMDWRITETIMESTAMP>(get_device_proc_addr(*pDevice, "vkCmdWriteTimestamp"));
        insert_pt.first->second.vkCmdCopyQueryPoolResults = reinterpret_cast<gapii::VulkanImports::PFNVKCMDCOPYQUERYPOOLRESULTS>(get_device_proc_addr(*pDevice, "vkCmdCopyQueryPoolResults"));
        insert_pt.first->second.vkCmdPushConstants = reinterpret_cast<gapii::VulkanImports::PFNVKCMDPUSHCONSTANTS>(get_device_proc_addr(*pDevice, "vkCmdPushConstants"));
        insert_pt.first->second.vkCmdBeginRenderPass = reinterpret_cast<gapii::VulkanImports::PFNVKCMDBEGINRENDERPASS>(get_device_proc_addr(*pDevice, "vkCmdBeginRenderPass"));
        insert_pt.first->second.vkCmdNextSubpass = reinterpret_cast<gapii::VulkanImports::PFNVKCMDNEXTSUBPASS>(get_device_proc_addr(*pDevice, "vkCmdNextSubpass"));
        insert_pt.first->second.vkCmdEndRenderPass = reinterpret_cast<gapii::VulkanImports::PFNVKCMDENDRENDERPASS>(get_device_proc_addr(*pDevice, "vkCmdEndRenderPass"));
        insert_pt.first->second.vkCmdExecuteCommands = reinterpret_cast<gapii::VulkanImports::PFNVKCMDEXECUTECOMMANDS>(get_device_proc_addr(*pDevice, "vkCmdExecuteCommands"));
        insert_pt.first->second.vkCreateSwapchainKHR = reinterpret_cast<gapii::VulkanImports::PFNVKCREATESWAPCHAINKHR>(get_device_proc_addr(*pDevice, "vkCreateSwapchainKHR"));
        insert_pt.first->second.vkDestroySwapchainKHR = reinterpret_cast<gapii::VulkanImports::PFNVKDESTROYSWAPCHAINKHR>(get_device_proc_addr(*pDevice, "vkDestroySwapchainKHR"));
        insert_pt.first->second.vkGetSwapchainImagesKHR = reinterpret_cast<gapii::VulkanImports::PFNVKGETSWAPCHAINIMAGESKHR>(get_device_proc_addr(*pDevice, "vkGetSwapchainImagesKHR"));
        insert_pt.first->second.vkAcquireNextImageKHR = reinterpret_cast<gapii::VulkanImports::PFNVKACQUIRENEXTIMAGEKHR>(get_device_proc_addr(*pDevice, "vkAcquireNextImageKHR"));
        insert_pt.first->second.vkQueuePresentKHR = reinterpret_cast<gapii::VulkanImports::PFNVKQUEUEPRESENTKHR>(get_device_proc_addr(*pDevice, "vkQueuePresentKHR"));
        insert_pt.first->second.vkCreateSharedSwapchainsKHR = reinterpret_cast<gapii::VulkanImports::PFNVKCREATESHAREDSWAPCHAINSKHR>(get_device_proc_addr(*pDevice, "vkCreateSharedSwapchainsKHR"));
    }
    return result;
}
void VulkanSpy::SpyOverride_vkDestroyDevice(VkDevice device, VkAllocationCallbacks* pAllocator) {
    // First we have to find the function to chain to, then we have to
    // remove this instance from our list, then we forward the call.
    auto it = mImports.mDeviceFunctions.find(device);
    gapii::VulkanImports::PFNVKDESTROYDEVICE destroy_device =
    it == mImports.mDeviceFunctions.end()
    ? nullptr
    : it->second.vkDestroyDevice;
    if (destroy_device) {
        destroy_device(device, pAllocator);
    }
    mImports.mDeviceFunctions.erase(mImports.mDeviceFunctions.find(device));
}
}