| /* |
| * 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)); |
| } |
| } |
