| // Copyright 2013 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "impeller/renderer/backend/vulkan/test/mock_vulkan.h" |
| |
| #include <cstdint> |
| #include <cstring> |
| #include <utility> |
| #include <vector> |
| |
| #include "impeller/base/thread_safety.h" |
| #include "impeller/renderer/backend/vulkan/vk.h" // IWYU pragma: keep. |
| #include "third_party/swiftshader/include/vulkan/vulkan_core.h" |
| #include "vulkan/vulkan.hpp" |
| #include "vulkan/vulkan_core.h" |
| |
| namespace impeller { |
| namespace testing { |
| |
| namespace { |
| |
| struct MockCommandBuffer { |
| explicit MockCommandBuffer( |
| std::shared_ptr<std::vector<std::string>> called_functions) |
| : called_functions_(std::move(called_functions)) {} |
| std::shared_ptr<std::vector<std::string>> called_functions_; |
| }; |
| |
| struct MockQueryPool {}; |
| |
| struct MockCommandPool {}; |
| |
| struct MockDescriptorPool {}; |
| |
| struct MockSurfaceKHR {}; |
| |
| struct MockImage {}; |
| |
| struct MockSwapchainKHR { |
| std::array<MockImage, 3> images; |
| size_t current_image = 0; |
| }; |
| |
| struct MockSemaphore {}; |
| |
| struct MockFramebuffer {}; |
| |
| static ISize currentImageSize = ISize{1, 1}; |
| |
| class MockDevice final { |
| public: |
| explicit MockDevice() : called_functions_(new std::vector<std::string>()) {} |
| |
| MockCommandBuffer* NewCommandBuffer() { |
| auto buffer = std::make_unique<MockCommandBuffer>(called_functions_); |
| MockCommandBuffer* result = buffer.get(); |
| Lock lock(command_buffers_mutex_); |
| command_buffers_.emplace_back(std::move(buffer)); |
| return result; |
| } |
| |
| MockCommandPool* NewCommandPool() { |
| auto pool = std::make_unique<MockCommandPool>(); |
| MockCommandPool* result = pool.get(); |
| Lock lock(commmand_pools_mutex_); |
| command_pools_.emplace_back(std::move(pool)); |
| return result; |
| } |
| |
| void DeleteCommandPool(MockCommandPool* pool) { |
| Lock lock(commmand_pools_mutex_); |
| auto it = std::find_if(command_pools_.begin(), command_pools_.end(), |
| [pool](const std::unique_ptr<MockCommandPool>& p) { |
| return p.get() == pool; |
| }); |
| if (it != command_pools_.end()) { |
| command_pools_.erase(it); |
| } |
| } |
| |
| const std::shared_ptr<std::vector<std::string>>& GetCalledFunctions() { |
| return called_functions_; |
| } |
| |
| void AddCalledFunction(const std::string& function) { |
| Lock lock(called_functions_mutex_); |
| called_functions_->push_back(function); |
| } |
| |
| private: |
| MockDevice(const MockDevice&) = delete; |
| |
| MockDevice& operator=(const MockDevice&) = delete; |
| |
| Mutex called_functions_mutex_; |
| std::shared_ptr<std::vector<std::string>> called_functions_ IPLR_GUARDED_BY( |
| called_functions_mutex_); |
| |
| Mutex command_buffers_mutex_; |
| std::vector<std::unique_ptr<MockCommandBuffer>> command_buffers_ |
| IPLR_GUARDED_BY(command_buffers_mutex_); |
| |
| Mutex commmand_pools_mutex_; |
| std::vector<std::unique_ptr<MockCommandPool>> command_pools_ IPLR_GUARDED_BY( |
| commmand_pools_mutex_); |
| }; |
| |
| void noop() {} |
| |
| static thread_local std::vector<std::string> g_instance_extensions; |
| |
| VkResult vkEnumerateInstanceExtensionProperties( |
| const char* pLayerName, |
| uint32_t* pPropertyCount, |
| VkExtensionProperties* pProperties) { |
| if (!pProperties) { |
| *pPropertyCount = g_instance_extensions.size(); |
| } else { |
| uint32_t count = 0; |
| for (const std::string& ext : g_instance_extensions) { |
| strncpy(pProperties[count].extensionName, ext.c_str(), |
| sizeof(VkExtensionProperties::extensionName)); |
| pProperties[count].specVersion = 0; |
| count++; |
| } |
| } |
| return VK_SUCCESS; |
| } |
| |
| static thread_local std::vector<std::string> g_instance_layers; |
| |
| VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, |
| VkLayerProperties* pProperties) { |
| if (!pProperties) { |
| *pPropertyCount = g_instance_layers.size(); |
| } else { |
| uint32_t count = 0; |
| for (const std::string& layer : g_instance_layers) { |
| strncpy(pProperties[count].layerName, layer.c_str(), |
| sizeof(VkLayerProperties::layerName)); |
| pProperties[count].specVersion = 0; |
| count++; |
| } |
| } |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkEnumeratePhysicalDevices(VkInstance instance, |
| uint32_t* pPhysicalDeviceCount, |
| VkPhysicalDevice* pPhysicalDevices) { |
| if (!pPhysicalDevices) { |
| *pPhysicalDeviceCount = 1; |
| } else { |
| pPhysicalDevices[0] = reinterpret_cast<VkPhysicalDevice>(0xfeedface); |
| } |
| return VK_SUCCESS; |
| } |
| |
| static thread_local std::function<void(VkPhysicalDevice physicalDevice, |
| VkFormat format, |
| VkFormatProperties* pFormatProperties)> |
| g_format_properties_callback; |
| |
| void vkGetPhysicalDeviceFormatProperties( |
| VkPhysicalDevice physicalDevice, |
| VkFormat format, |
| VkFormatProperties* pFormatProperties) { |
| g_format_properties_callback(physicalDevice, format, pFormatProperties); |
| } |
| |
| void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties* pProperties) { |
| pProperties->limits.framebufferColorSampleCounts = |
| static_cast<VkSampleCountFlags>(VK_SAMPLE_COUNT_1_BIT | |
| VK_SAMPLE_COUNT_4_BIT); |
| pProperties->limits.maxImageDimension2D = 4096; |
| pProperties->limits.timestampPeriod = 1; |
| } |
| |
| void vkGetPhysicalDeviceQueueFamilyProperties( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pQueueFamilyPropertyCount, |
| VkQueueFamilyProperties* pQueueFamilyProperties) { |
| if (!pQueueFamilyProperties) { |
| *pQueueFamilyPropertyCount = 1; |
| } else { |
| pQueueFamilyProperties[0].queueCount = 3; |
| pQueueFamilyProperties[0].queueFlags = static_cast<VkQueueFlags>( |
| VK_QUEUE_TRANSFER_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_GRAPHICS_BIT); |
| } |
| } |
| |
| VkResult vkEnumerateDeviceExtensionProperties( |
| VkPhysicalDevice physicalDevice, |
| const char* pLayerName, |
| uint32_t* pPropertyCount, |
| VkExtensionProperties* pProperties) { |
| if (!pProperties) { |
| *pPropertyCount = 1; |
| } else { |
| strcpy(pProperties[0].extensionName, "VK_KHR_swapchain"); |
| pProperties[0].specVersion = 0; |
| } |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, |
| const VkDeviceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDevice* pDevice) { |
| *pDevice = reinterpret_cast<VkDevice>(new MockDevice()); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkInstance* pInstance) { |
| *pInstance = reinterpret_cast<VkInstance>(0xbaadf00d); |
| return VK_SUCCESS; |
| } |
| |
| void vkGetPhysicalDeviceMemoryProperties( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceMemoryProperties* pMemoryProperties) { |
| pMemoryProperties->memoryTypeCount = 2; |
| pMemoryProperties->memoryHeapCount = 2; |
| pMemoryProperties->memoryTypes[0].heapIndex = 0; |
| pMemoryProperties->memoryTypes[0].propertyFlags = |
| VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | |
| VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | |
| VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; |
| pMemoryProperties->memoryTypes[1].heapIndex = 1; |
| pMemoryProperties->memoryTypes[1].propertyFlags = |
| VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; |
| pMemoryProperties->memoryHeaps[0].size = 1024 * 1024 * 1024; |
| pMemoryProperties->memoryHeaps[0].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT; |
| pMemoryProperties->memoryHeaps[1].size = 1024 * 1024 * 1024; |
| pMemoryProperties->memoryHeaps[1].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT; |
| } |
| |
| VkResult vkCreatePipelineCache(VkDevice device, |
| const VkPipelineCacheCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineCache* pPipelineCache) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkCreatePipelineCache"); |
| *pPipelineCache = reinterpret_cast<VkPipelineCache>(0xb000dead); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateCommandPool(VkDevice device, |
| const VkCommandPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkCommandPool* pCommandPool) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkCreateCommandPool"); |
| *pCommandPool = |
| reinterpret_cast<VkCommandPool>(mock_device->NewCommandPool()); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkResetCommandPool(VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolResetFlags flags) { |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkAllocateCommandBuffers( |
| VkDevice device, |
| const VkCommandBufferAllocateInfo* pAllocateInfo, |
| VkCommandBuffer* pCommandBuffers) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkAllocateCommandBuffers"); |
| *pCommandBuffers = |
| reinterpret_cast<VkCommandBuffer>(mock_device->NewCommandBuffer()); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, |
| const VkCommandBufferBeginInfo* pBeginInfo) { |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateImage(VkDevice device, |
| const VkImageCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImage* pImage) { |
| *pImage = reinterpret_cast<VkImage>(0xD0D0CACA); |
| return VK_SUCCESS; |
| } |
| |
| void vkGetImageMemoryRequirements2KHR( |
| VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) { |
| pMemoryRequirements->memoryRequirements.size = 1024; |
| pMemoryRequirements->memoryRequirements.memoryTypeBits = 1; |
| } |
| |
| VkResult vkAllocateMemory(VkDevice device, |
| const VkMemoryAllocateInfo* pAllocateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDeviceMemory* pMemory) { |
| *pMemory = reinterpret_cast<VkDeviceMemory>(0xCAFEB0BA); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkBindImageMemory(VkDevice device, |
| VkImage image, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset) { |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateImageView(VkDevice device, |
| const VkImageViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImageView* pView) { |
| *pView = reinterpret_cast<VkImageView>(0xFEE1DEAD); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateBuffer(VkDevice device, |
| const VkBufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBuffer* pBuffer) { |
| *pBuffer = reinterpret_cast<VkBuffer>(0xDEADDEAD); |
| return VK_SUCCESS; |
| } |
| |
| void vkGetBufferMemoryRequirements2KHR( |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) { |
| pMemoryRequirements->memoryRequirements.size = 1024; |
| pMemoryRequirements->memoryRequirements.memoryTypeBits = 1; |
| } |
| |
| VkResult vkBindBufferMemory(VkDevice device, |
| VkBuffer buffer, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset) { |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateRenderPass(VkDevice device, |
| const VkRenderPassCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass) { |
| *pRenderPass = reinterpret_cast<VkRenderPass>(0x12341234); |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkCreateRenderPass"); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateDescriptorSetLayout( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorSetLayout* pSetLayout) { |
| *pSetLayout = reinterpret_cast<VkDescriptorSetLayout>(0x77777777); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreatePipelineLayout(VkDevice device, |
| const VkPipelineLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineLayout* pPipelineLayout) { |
| *pPipelineLayout = reinterpret_cast<VkPipelineLayout>(0x88888888); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateGraphicsPipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkCreateGraphicsPipelines"); |
| *pPipelines = reinterpret_cast<VkPipeline>(0x99999999); |
| return VK_SUCCESS; |
| } |
| |
| void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkDestroyDevice"); |
| delete reinterpret_cast<MockDevice*>(device); |
| } |
| |
| void vkDestroyPipeline(VkDevice device, |
| VkPipeline pipeline, |
| const VkAllocationCallbacks* pAllocator) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkDestroyPipeline"); |
| } |
| |
| VkResult vkCreateShaderModule(VkDevice device, |
| const VkShaderModuleCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkShaderModule* pShaderModule) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkCreateShaderModule"); |
| *pShaderModule = reinterpret_cast<VkShaderModule>(0x11111111); |
| return VK_SUCCESS; |
| } |
| |
| void vkDestroyShaderModule(VkDevice device, |
| VkShaderModule shaderModule, |
| const VkAllocationCallbacks* pAllocator) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkDestroyShaderModule"); |
| } |
| |
| void vkDestroyPipelineCache(VkDevice device, |
| VkPipelineCache pipelineCache, |
| const VkAllocationCallbacks* pAllocator) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkDestroyPipelineCache"); |
| } |
| |
| void vkDestroySurfaceKHR(VkInstance instance, |
| VkSurfaceKHR surface, |
| const VkAllocationCallbacks* pAllocator) { |
| return; |
| } |
| |
| void vkCmdBindPipeline(VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipeline pipeline) { |
| MockCommandBuffer* mock_command_buffer = |
| reinterpret_cast<MockCommandBuffer*>(commandBuffer); |
| mock_command_buffer->called_functions_->push_back("vkCmdBindPipeline"); |
| } |
| |
| void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t reference) { |
| MockCommandBuffer* mock_command_buffer = |
| reinterpret_cast<MockCommandBuffer*>(commandBuffer); |
| mock_command_buffer->called_functions_->push_back("vkCmdSetStencilReference"); |
| } |
| |
| void vkCmdSetScissor(VkCommandBuffer commandBuffer, |
| uint32_t firstScissor, |
| uint32_t scissorCount, |
| const VkRect2D* pScissors) { |
| MockCommandBuffer* mock_command_buffer = |
| reinterpret_cast<MockCommandBuffer*>(commandBuffer); |
| mock_command_buffer->called_functions_->push_back("vkCmdSetScissor"); |
| } |
| |
| void vkCmdSetViewport(VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkViewport* pViewports) { |
| MockCommandBuffer* mock_command_buffer = |
| reinterpret_cast<MockCommandBuffer*>(commandBuffer); |
| mock_command_buffer->called_functions_->push_back("vkCmdSetViewport"); |
| } |
| |
| void vkFreeCommandBuffers(VkDevice device, |
| VkCommandPool commandPool, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkFreeCommandBuffers"); |
| } |
| |
| void vkDestroyCommandPool(VkDevice device, |
| VkCommandPool commandPool, |
| const VkAllocationCallbacks* pAllocator) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->DeleteCommandPool( |
| reinterpret_cast<MockCommandPool*>(commandPool)); |
| mock_device->AddCalledFunction("vkDestroyCommandPool"); |
| } |
| |
| VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) { |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateFence(VkDevice device, |
| const VkFenceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| *pFence = reinterpret_cast<VkFence>(new MockFence()); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkDestroyFence(VkDevice device, |
| VkFence fence, |
| const VkAllocationCallbacks* pAllocator) { |
| delete reinterpret_cast<MockFence*>(fence); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkQueueSubmit(VkQueue queue, |
| uint32_t submitCount, |
| const VkSubmitInfo* pSubmits, |
| VkFence fence) { |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkWaitForFences(VkDevice device, |
| uint32_t fenceCount, |
| const VkFence* pFences, |
| VkBool32 waitAll, |
| uint64_t timeout) { |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkGetFenceStatus(VkDevice device, VkFence fence) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| MockFence* mock_fence = reinterpret_cast<MockFence*>(fence); |
| return mock_fence->GetStatus(); |
| } |
| |
| VkResult vkResetFences(VkDevice device, |
| uint32_t fenceCount, |
| const VkFence* fences) { |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateDebugUtilsMessengerEXT( |
| VkInstance instance, |
| const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugUtilsMessengerEXT* pMessenger) { |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkSetDebugUtilsObjectNameEXT( |
| VkDevice device, |
| const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateQueryPool(VkDevice device, |
| const VkQueryPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkQueryPool* pQueryPool) { |
| *pQueryPool = reinterpret_cast<VkQueryPool>(new MockQueryPool()); |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkCreateQueryPool"); |
| return VK_SUCCESS; |
| } |
| |
| void vkDestroyQueryPool(VkDevice device, |
| VkQueryPool queryPool, |
| const VkAllocationCallbacks* pAllocator) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkDestroyQueryPool"); |
| delete reinterpret_cast<MockQueryPool*>(queryPool); |
| } |
| |
| VkResult vkGetQueryPoolResults(VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| size_t dataSize, |
| void* pData, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| if (dataSize == sizeof(uint32_t)) { |
| uint32_t* data = static_cast<uint32_t*>(pData); |
| for (auto i = firstQuery; i < queryCount; i++) { |
| data[0] = i; |
| } |
| } else if (dataSize == sizeof(int64_t)) { |
| uint64_t* data = static_cast<uint64_t*>(pData); |
| for (auto i = firstQuery; i < queryCount; i++) { |
| data[0] = i; |
| } |
| } |
| mock_device->AddCalledFunction("vkGetQueryPoolResults"); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateDescriptorPool(VkDevice device, |
| const VkDescriptorPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorPool* pDescriptorPool) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| *pDescriptorPool = |
| reinterpret_cast<VkDescriptorPool>(new MockDescriptorPool()); |
| mock_device->AddCalledFunction("vkCreateDescriptorPool"); |
| return VK_SUCCESS; |
| } |
| |
| void vkDestroyDescriptorPool(VkDevice device, |
| VkDescriptorPool descriptorPool, |
| const VkAllocationCallbacks* pAllocator) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkDestroyDescriptorPool"); |
| delete reinterpret_cast<MockDescriptorPool*>(descriptorPool); |
| } |
| |
| VkResult vkResetDescriptorPool(VkDevice device, |
| VkDescriptorPool descriptorPool, |
| VkDescriptorPoolResetFlags flags) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkResetDescriptorPool"); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkAllocateDescriptorSets( |
| VkDevice device, |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, |
| VkDescriptorSet* pDescriptorSets) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| mock_device->AddCalledFunction("vkAllocateDescriptorSets"); |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pSurfaceFormatCount, |
| VkSurfaceFormatKHR* pSurfaceFormats) { |
| *pSurfaceFormatCount = 1u; |
| if (pSurfaceFormats != nullptr) { |
| pSurfaceFormats[0] = |
| VkSurfaceFormatKHR{.format = VK_FORMAT_R8G8B8A8_UNORM, |
| .colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}; |
| } |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { |
| *pSurfaceCapabilities = VkSurfaceCapabilitiesKHR{ |
| .minImageCount = 3, |
| .maxImageCount = 6, |
| .currentExtent = |
| VkExtent2D{ |
| .width = static_cast<uint32_t>(currentImageSize.width), |
| .height = static_cast<uint32_t>(currentImageSize.height), |
| }, |
| .minImageExtent = |
| VkExtent2D{ |
| .width = 0, |
| .height = 0, |
| }, |
| .maxImageExtent = |
| VkExtent2D{ |
| .width = static_cast<uint32_t>(currentImageSize.width), |
| .height = static_cast<uint32_t>(currentImageSize.height), |
| }, |
| .maxImageArrayLayers = 1, |
| .supportedTransforms = |
| VkSurfaceTransformFlagBitsKHR::VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, |
| .currentTransform = |
| VkSurfaceTransformFlagBitsKHR::VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, |
| .supportedCompositeAlpha = VkCompositeAlphaFlagBitsKHR:: |
| VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR, |
| .supportedUsageFlags = |
| VkImageUsageFlagBits::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT}; |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, |
| uint32_t queueFamilyIndex, |
| VkSurfaceKHR surface, |
| VkBool32* pSupported) { |
| *pSupported = VK_TRUE; |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateSwapchainKHR(VkDevice device, |
| const VkSwapchainCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSwapchainKHR* pSwapchain) { |
| *pSwapchain = reinterpret_cast<VkSwapchainKHR>(new MockSwapchainKHR()); |
| return VK_SUCCESS; |
| } |
| |
| void vkDestroySwapchainKHR(VkDevice device, |
| VkSwapchainKHR swapchain, |
| const VkAllocationCallbacks* pAllocator) { |
| delete reinterpret_cast<MockSwapchainKHR*>(swapchain); |
| } |
| |
| VkResult vkGetSwapchainImagesKHR(VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint32_t* pSwapchainImageCount, |
| VkImage* pSwapchainImages) { |
| MockSwapchainKHR* mock_swapchain = |
| reinterpret_cast<MockSwapchainKHR*>(swapchain); |
| auto& images = mock_swapchain->images; |
| *pSwapchainImageCount = images.size(); |
| if (pSwapchainImages != nullptr) { |
| for (size_t i = 0; i < images.size(); i++) { |
| pSwapchainImages[i] = reinterpret_cast<VkImage>(&images[i]); |
| } |
| } |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateSemaphore(VkDevice device, |
| const VkSemaphoreCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSemaphore* pSemaphore) { |
| *pSemaphore = reinterpret_cast<VkSemaphore>(new MockSemaphore()); |
| return VK_SUCCESS; |
| } |
| |
| void vkDestroySemaphore(VkDevice device, |
| VkSemaphore semaphore, |
| const VkAllocationCallbacks* pAllocator) { |
| delete reinterpret_cast<MockSemaphore*>(semaphore); |
| } |
| |
| VkResult vkAcquireNextImageKHR(VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint64_t timeout, |
| VkSemaphore semaphore, |
| VkFence fence, |
| uint32_t* pImageIndex) { |
| auto current_index = |
| reinterpret_cast<MockSwapchainKHR*>(swapchain)->current_image++; |
| *pImageIndex = (current_index + 1) % 3u; |
| return VK_SUCCESS; |
| } |
| |
| VkResult vkCreateFramebuffer(VkDevice device, |
| const VkFramebufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFramebuffer* pFramebuffer) { |
| *pFramebuffer = reinterpret_cast<VkFramebuffer>(new MockFramebuffer()); |
| return VK_SUCCESS; |
| } |
| |
| void vkDestroyFramebuffer(VkDevice device, |
| VkFramebuffer framebuffer, |
| const VkAllocationCallbacks* pAllocator) { |
| delete reinterpret_cast<MockFramebuffer*>(framebuffer); |
| } |
| |
| PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance, |
| const char* pName) { |
| if (strcmp("vkEnumerateInstanceExtensionProperties", pName) == 0) { |
| return (PFN_vkVoidFunction)vkEnumerateInstanceExtensionProperties; |
| } else if (strcmp("vkEnumerateInstanceLayerProperties", pName) == 0) { |
| return (PFN_vkVoidFunction)vkEnumerateInstanceLayerProperties; |
| } else if (strcmp("vkEnumeratePhysicalDevices", pName) == 0) { |
| return (PFN_vkVoidFunction)vkEnumeratePhysicalDevices; |
| } else if (strcmp("vkGetPhysicalDeviceFormatProperties", pName) == 0) { |
| return (PFN_vkVoidFunction)vkGetPhysicalDeviceFormatProperties; |
| } else if (strcmp("vkGetPhysicalDeviceProperties", pName) == 0) { |
| return (PFN_vkVoidFunction)vkGetPhysicalDeviceProperties; |
| } else if (strcmp("vkGetPhysicalDeviceQueueFamilyProperties", pName) == 0) { |
| return (PFN_vkVoidFunction)vkGetPhysicalDeviceQueueFamilyProperties; |
| } else if (strcmp("vkEnumerateDeviceExtensionProperties", pName) == 0) { |
| return (PFN_vkVoidFunction)vkEnumerateDeviceExtensionProperties; |
| } else if (strcmp("vkCreateDevice", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateDevice; |
| } else if (strcmp("vkCreateInstance", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateInstance; |
| } else if (strcmp("vkGetPhysicalDeviceMemoryProperties", pName) == 0) { |
| return (PFN_vkVoidFunction)vkGetPhysicalDeviceMemoryProperties; |
| } else if (strcmp("vkCreatePipelineCache", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreatePipelineCache; |
| } else if (strcmp("vkCreateCommandPool", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateCommandPool; |
| } else if (strcmp("vkResetCommandPool", pName) == 0) { |
| return (PFN_vkVoidFunction)vkResetCommandPool; |
| } else if (strcmp("vkAllocateCommandBuffers", pName) == 0) { |
| return (PFN_vkVoidFunction)vkAllocateCommandBuffers; |
| } else if (strcmp("vkBeginCommandBuffer", pName) == 0) { |
| return (PFN_vkVoidFunction)vkBeginCommandBuffer; |
| } else if (strcmp("vkCreateImage", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateImage; |
| } else if (strcmp("vkGetInstanceProcAddr", pName) == 0) { |
| return (PFN_vkVoidFunction)GetMockVulkanProcAddress; |
| } else if (strcmp("vkGetDeviceProcAddr", pName) == 0) { |
| return (PFN_vkVoidFunction)GetMockVulkanProcAddress; |
| } else if (strcmp("vkGetImageMemoryRequirements2KHR", pName) == 0 || |
| strcmp("vkGetImageMemoryRequirements2", pName) == 0) { |
| return (PFN_vkVoidFunction)vkGetImageMemoryRequirements2KHR; |
| } else if (strcmp("vkAllocateMemory", pName) == 0) { |
| return (PFN_vkVoidFunction)vkAllocateMemory; |
| } else if (strcmp("vkBindImageMemory", pName) == 0) { |
| return (PFN_vkVoidFunction)vkBindImageMemory; |
| } else if (strcmp("vkCreateImageView", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateImageView; |
| } else if (strcmp("vkCreateBuffer", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateBuffer; |
| } else if (strcmp("vkGetBufferMemoryRequirements2KHR", pName) == 0 || |
| strcmp("vkGetBufferMemoryRequirements2", pName) == 0) { |
| return (PFN_vkVoidFunction)vkGetBufferMemoryRequirements2KHR; |
| } else if (strcmp("vkBindBufferMemory", pName) == 0) { |
| return (PFN_vkVoidFunction)vkBindBufferMemory; |
| } else if (strcmp("vkCreateRenderPass", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateRenderPass; |
| } else if (strcmp("vkCreateDescriptorSetLayout", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateDescriptorSetLayout; |
| } else if (strcmp("vkCreatePipelineLayout", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreatePipelineLayout; |
| } else if (strcmp("vkCreateGraphicsPipelines", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateGraphicsPipelines; |
| } else if (strcmp("vkDestroyDevice", pName) == 0) { |
| return (PFN_vkVoidFunction)vkDestroyDevice; |
| } else if (strcmp("vkDestroyPipeline", pName) == 0) { |
| return (PFN_vkVoidFunction)vkDestroyPipeline; |
| } else if (strcmp("vkCreateShaderModule", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateShaderModule; |
| } else if (strcmp("vkDestroyShaderModule", pName) == 0) { |
| return (PFN_vkVoidFunction)vkDestroyShaderModule; |
| } else if (strcmp("vkDestroyPipelineCache", pName) == 0) { |
| return (PFN_vkVoidFunction)vkDestroyPipelineCache; |
| } else if (strcmp("vkCmdBindPipeline", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCmdBindPipeline; |
| } else if (strcmp("vkCmdSetStencilReference", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCmdSetStencilReference; |
| } else if (strcmp("vkCmdSetScissor", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCmdSetScissor; |
| } else if (strcmp("vkCmdSetViewport", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCmdSetViewport; |
| } else if (strcmp("vkDestroyCommandPool", pName) == 0) { |
| return (PFN_vkVoidFunction)vkDestroyCommandPool; |
| } else if (strcmp("vkFreeCommandBuffers", pName) == 0) { |
| return (PFN_vkVoidFunction)vkFreeCommandBuffers; |
| } else if (strcmp("vkEndCommandBuffer", pName) == 0) { |
| return (PFN_vkVoidFunction)vkEndCommandBuffer; |
| } else if (strcmp("vkCreateFence", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateFence; |
| } else if (strcmp("vkDestroyFence", pName) == 0) { |
| return (PFN_vkVoidFunction)vkDestroyFence; |
| } else if (strcmp("vkQueueSubmit", pName) == 0) { |
| return (PFN_vkVoidFunction)vkQueueSubmit; |
| } else if (strcmp("vkWaitForFences", pName) == 0) { |
| return (PFN_vkVoidFunction)vkWaitForFences; |
| } else if (strcmp("vkGetFenceStatus", pName) == 0) { |
| return (PFN_vkVoidFunction)vkGetFenceStatus; |
| } else if (strcmp("vkResetFences", pName) == 0) { |
| return (PFN_vkVoidFunction)vkResetFences; |
| } else if (strcmp("vkCreateDebugUtilsMessengerEXT", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateDebugUtilsMessengerEXT; |
| } else if (strcmp("vkSetDebugUtilsObjectNameEXT", pName) == 0) { |
| return (PFN_vkVoidFunction)vkSetDebugUtilsObjectNameEXT; |
| } else if (strcmp("vkCreateQueryPool", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateQueryPool; |
| } else if (strcmp("vkDestroyQueryPool", pName) == 0) { |
| return (PFN_vkVoidFunction)vkDestroyQueryPool; |
| } else if (strcmp("vkGetQueryPoolResults", pName) == 0) { |
| return (PFN_vkVoidFunction)vkGetQueryPoolResults; |
| } else if (strcmp("vkCreateDescriptorPool", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateDescriptorPool; |
| } else if (strcmp("vkDestroyDescriptorPool", pName) == 0) { |
| return (PFN_vkVoidFunction)vkDestroyDescriptorPool; |
| } else if (strcmp("vkResetDescriptorPool", pName) == 0) { |
| return (PFN_vkVoidFunction)vkResetDescriptorPool; |
| } else if (strcmp("vkAllocateDescriptorSets", pName) == 0) { |
| return (PFN_vkVoidFunction)vkAllocateDescriptorSets; |
| } else if (strcmp("vkGetPhysicalDeviceSurfaceFormatsKHR", pName) == 0) { |
| return (PFN_vkVoidFunction)vkGetPhysicalDeviceSurfaceFormatsKHR; |
| } else if (strcmp("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", pName) == 0) { |
| return (PFN_vkVoidFunction)vkGetPhysicalDeviceSurfaceCapabilitiesKHR; |
| } else if (strcmp("vkGetPhysicalDeviceSurfaceSupportKHR", pName) == 0) { |
| return (PFN_vkVoidFunction)vkGetPhysicalDeviceSurfaceSupportKHR; |
| } else if (strcmp("vkCreateSwapchainKHR", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateSwapchainKHR; |
| } else if (strcmp("vkDestroySwapchainKHR", pName) == 0) { |
| return (PFN_vkVoidFunction)vkDestroySwapchainKHR; |
| } else if (strcmp("vkGetSwapchainImagesKHR", pName) == 0) { |
| return (PFN_vkVoidFunction)vkGetSwapchainImagesKHR; |
| } else if (strcmp("vkCreateSemaphore", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateSemaphore; |
| } else if (strcmp("vkDestroySemaphore", pName) == 0) { |
| return (PFN_vkVoidFunction)vkDestroySemaphore; |
| } else if (strcmp("vkDestroySurfaceKHR", pName) == 0) { |
| return (PFN_vkVoidFunction)vkDestroySurfaceKHR; |
| } else if (strcmp("vkAcquireNextImageKHR", pName) == 0) { |
| return (PFN_vkVoidFunction)vkAcquireNextImageKHR; |
| } else if (strcmp("vkCreateFramebuffer", pName) == 0) { |
| return (PFN_vkVoidFunction)vkCreateFramebuffer; |
| } else if (strcmp("vkDestroyFramebuffer", pName) == 0) { |
| return (PFN_vkVoidFunction)vkDestroyFramebuffer; |
| } |
| return noop; |
| } |
| |
| } // namespace |
| |
| MockVulkanContextBuilder::MockVulkanContextBuilder() |
| : instance_extensions_({"VK_KHR_surface", "VK_MVK_macos_surface"}), |
| format_properties_callback_([](VkPhysicalDevice physicalDevice, |
| VkFormat format, |
| VkFormatProperties* pFormatProperties) { |
| if (format == VK_FORMAT_R8G8B8A8_UNORM) { |
| pFormatProperties->optimalTilingFeatures = |
| static_cast<VkFormatFeatureFlags>( |
| vk::FormatFeatureFlagBits::eColorAttachment); |
| } else if (format == VK_FORMAT_D32_SFLOAT_S8_UINT) { |
| pFormatProperties->optimalTilingFeatures = |
| static_cast<VkFormatFeatureFlags>( |
| vk::FormatFeatureFlagBits::eDepthStencilAttachment); |
| } else if (format == VK_FORMAT_S8_UINT) { |
| pFormatProperties->optimalTilingFeatures = |
| static_cast<VkFormatFeatureFlags>( |
| vk::FormatFeatureFlagBits::eDepthStencilAttachment); |
| } |
| }) {} |
| |
| std::shared_ptr<ContextVK> MockVulkanContextBuilder::Build() { |
| auto message_loop = fml::ConcurrentMessageLoop::Create(); |
| ContextVK::Settings settings; |
| settings.proc_address_callback = GetMockVulkanProcAddress; |
| if (settings_callback_) { |
| settings_callback_(settings); |
| } |
| g_instance_extensions = instance_extensions_; |
| g_instance_layers = instance_layers_; |
| g_format_properties_callback = format_properties_callback_; |
| std::shared_ptr<ContextVK> result = ContextVK::Create(std::move(settings)); |
| return result; |
| } |
| |
| std::shared_ptr<std::vector<std::string>> GetMockVulkanFunctions( |
| VkDevice device) { |
| MockDevice* mock_device = reinterpret_cast<MockDevice*>(device); |
| return mock_device->GetCalledFunctions(); |
| } |
| |
| void SetSwapchainImageSize(ISize size) { |
| currentImageSize = size; |
| } |
| |
| } // namespace testing |
| } // namespace impeller |
