From 46fff48c04b97689f15876d98f16622a9c72d82c Mon Sep 17 00:00:00 2001 From: Aaron Clarke Date: Fri, 21 Apr 2023 10:01:58 -0700 Subject: [PATCH 01/12] [Impeller] created mock for vulkan and added tracking resource fix for blit to buffer --- impeller/BUILD.gn | 6 + impeller/renderer/backend/vulkan/BUILD.gn | 6 + .../vulkan/blit_command_vk_unittests.cc | 146 ++++++++++++++++++ .../backend/vulkan/command_encoder_vk.h | 5 + 4 files changed, 163 insertions(+) create mode 100644 impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc diff --git a/impeller/BUILD.gn b/impeller/BUILD.gn index 6ca7bde884982..1ad0cba156fc9 100644 --- a/impeller/BUILD.gn +++ b/impeller/BUILD.gn @@ -97,6 +97,12 @@ impeller_component("impeller_unittests") { ] } + if (impeller_enable_vulkan) { + deps += [ + "//flutter/impeller/renderer/backend/vulkan:vulkan_unittests", + ] + } + if (impeller_enable_compute) { deps += [ "renderer:compute_tessellation_unittests" ] } diff --git a/impeller/renderer/backend/vulkan/BUILD.gn b/impeller/renderer/backend/vulkan/BUILD.gn index 303d5f6f1c8c8..313f5d7a1703b 100644 --- a/impeller/renderer/backend/vulkan/BUILD.gn +++ b/impeller/renderer/backend/vulkan/BUILD.gn @@ -4,6 +4,12 @@ import("../../../tools/impeller.gni") +impeller_component("vulkan_unittests") { + testonly = true + sources = [ "blit_command_vk_unittests.cc" ] + deps = [ ":vulkan", "//flutter/testing:testing_lib" ] +} + impeller_component("vulkan") { sources = [ "allocator_vk.cc", diff --git a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc new file mode 100644 index 0000000000000..46835d42a657f --- /dev/null +++ b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc @@ -0,0 +1,146 @@ +// 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 "flutter/testing/testing.h" +#include "impeller/renderer/backend/vulkan/blit_command_vk.h" +#include "impeller/renderer/backend/vulkan/command_encoder_vk.h" + +namespace impeller { +namespace testing { + +namespace { +void noop() {} + +VkResult vkEnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) { + if (!pProperties) { + *pPropertyCount = 2; + + } else { + strcpy(pProperties[0].extensionName, "VK_KHR_surface"); + pProperties[0].specVersion = 0; + strcpy(pProperties[1].extensionName, "VK_MVK_macos_surface"); + pProperties[1].specVersion = 0; + } + return VK_SUCCESS; +} + +VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, + VkLayerProperties* pProperties) { + *pPropertyCount = 0; + return VK_SUCCESS; +} + +VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance) { + return VK_SUCCESS; +} + +VkResult vkEnumeratePhysicalDevices(VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices) { + if (!pPhysicalDevices) { + *pPhysicalDeviceCount = 1; + } else { + pPhysicalDevices[0] = reinterpret_cast(0xfeedface); + } + return VK_SUCCESS; +} + +void vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties) { + if (format == VK_FORMAT_B8G8R8A8_UNORM) { + pFormatProperties->optimalTilingFeatures = + static_cast( + vk::FormatFeatureFlagBits::eColorAttachment); + } else if (format == VK_FORMAT_S8_UINT) { + pFormatProperties->optimalTilingFeatures = + static_cast( + vk::FormatFeatureFlagBits::eDepthStencilAttachment); + } +} + +void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties) { + pProperties->limits.framebufferColorSampleCounts = + static_cast(VK_SAMPLE_COUNT_1_BIT | + VK_SAMPLE_COUNT_4_BIT); +} + +void vkGetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties) { + if (!pQueueFamilyProperties) { + *pQueueFamilyPropertyCount = 1; + } else { + pQueueFamilyProperties[0].queueCount = 3; + pQueueFamilyProperties[0].queueFlags = static_cast( + 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(0xcafebabe); + return VK_SUCCESS; +} +} // namespace + +TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { + ContextVK::Settings settings; + settings.proc_address_callback = [](VkInstance instance, + const char* pName) -> PFN_vkVoidFunction { + if (strcmp("vkEnumerateInstanceExtensionProperties", pName) == 0) { + return (PFN_vkVoidFunction)vkEnumerateInstanceExtensionProperties; + } else if (strcmp("vkEnumerateInstanceLayerProperties", pName) == 0) { + return (PFN_vkVoidFunction)vkEnumerateInstanceLayerProperties; + } else if (strcmp("vkCreateInstance", pName) == 0) { + return (PFN_vkVoidFunction)vkCreateInstance; + } 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; + } + return noop; + }; + auto context = ContextVK::Create(std::move(settings)); + CommandEncoderVK encoder(context->GetDevice(), {}, {}, + context->GetFenceWaiter()); + BlitCopyTextureToTextureCommandVK cmd; + bool result = cmd.Encode(encoder); + ASSERT_TRUE(result); +} + +} // namespace testing +} // namespace impeller diff --git a/impeller/renderer/backend/vulkan/command_encoder_vk.h b/impeller/renderer/backend/vulkan/command_encoder_vk.h index 9e79fb36ee420..e52f72cb88106 100644 --- a/impeller/renderer/backend/vulkan/command_encoder_vk.h +++ b/impeller/renderer/backend/vulkan/command_encoder_vk.h @@ -16,6 +16,10 @@ namespace impeller { +namespace testing { + class BlitCommandVkTest_BlitCopyTextureToTextureCommandVK_Test; +} + class ContextVK; class DeviceBuffer; class Texture; @@ -52,6 +56,7 @@ class CommandEncoderVK { private: friend class ContextVK; + friend class ::impeller::testing::BlitCommandVkTest_BlitCopyTextureToTextureCommandVK_Test; vk::Device device_ = {}; std::shared_ptr queue_; From d8dd4a3a5944f9b450beb70f73332efc7b85c3ab Mon Sep 17 00:00:00 2001 From: Aaron Clarke Date: Fri, 21 Apr 2023 11:43:11 -0700 Subject: [PATCH 02/12] got a "valid" context --- .../vulkan/blit_command_vk_unittests.cc | 44 +++++++++++++++---- 1 file changed, 36 insertions(+), 8 deletions(-) diff --git a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc index 46835d42a657f..9798c3be77bba 100644 --- a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc +++ b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc @@ -34,12 +34,6 @@ VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, return VK_SUCCESS; } -VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkInstance* pInstance) { - return VK_SUCCESS; -} - VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { @@ -107,18 +101,46 @@ VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, *pDevice = reinterpret_cast(0xcafebabe); return VK_SUCCESS; } + +VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance) { + *pInstance = reinterpret_cast(0xbaadf00d); + return VK_SUCCESS; +} + +void vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties) { + pMemoryProperties->memoryTypeCount = 1; + pMemoryProperties->memoryTypes[0].heapIndex = 0; + pMemoryProperties->memoryTypes[0].propertyFlags = 0; + pMemoryProperties->memoryHeapCount = 1; + pMemoryProperties->memoryHeaps[0].size = 1024 * 1024 * 1024; + pMemoryProperties->memoryHeaps[0].flags = 0; +} + +VkResult vkCreatePipelineCache(VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache) { + *pPipelineCache = reinterpret_cast(0xb000dead); + return VK_SUCCESS; +} + } // namespace TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { ContextVK::Settings settings; + auto message_loop = fml::ConcurrentMessageLoop::Create(); + settings.worker_task_runner = + std::make_shared(message_loop); settings.proc_address_callback = [](VkInstance instance, const char* pName) -> PFN_vkVoidFunction { if (strcmp("vkEnumerateInstanceExtensionProperties", pName) == 0) { return (PFN_vkVoidFunction)vkEnumerateInstanceExtensionProperties; } else if (strcmp("vkEnumerateInstanceLayerProperties", pName) == 0) { return (PFN_vkVoidFunction)vkEnumerateInstanceLayerProperties; - } else if (strcmp("vkCreateInstance", pName) == 0) { - return (PFN_vkVoidFunction)vkCreateInstance; } else if (strcmp("vkEnumeratePhysicalDevices", pName) == 0) { return (PFN_vkVoidFunction)vkEnumeratePhysicalDevices; } else if (strcmp("vkGetPhysicalDeviceFormatProperties", pName) == 0) { @@ -131,6 +153,12 @@ TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { 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; } return noop; }; From dbe43c3ec7ae20f3e51045ffa322db1537bd9118 Mon Sep 17 00:00:00 2001 From: Aaron Clarke Date: Fri, 21 Apr 2023 11:50:06 -0700 Subject: [PATCH 03/12] started using the graphcis queue --- .../renderer/backend/vulkan/blit_command_vk_unittests.cc | 4 ++-- impeller/renderer/backend/vulkan/command_encoder_vk.h | 5 +++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc index 9798c3be77bba..e926f101b2ba9 100644 --- a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc +++ b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc @@ -163,8 +163,8 @@ TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { return noop; }; auto context = ContextVK::Create(std::move(settings)); - CommandEncoderVK encoder(context->GetDevice(), {}, {}, - context->GetFenceWaiter()); + CommandEncoderVK encoder(context->GetDevice(), context->GetGraphicsQueue(), + {}, context->GetFenceWaiter()); BlitCopyTextureToTextureCommandVK cmd; bool result = cmd.Encode(encoder); ASSERT_TRUE(result); diff --git a/impeller/renderer/backend/vulkan/command_encoder_vk.h b/impeller/renderer/backend/vulkan/command_encoder_vk.h index e52f72cb88106..16ac2c9e11f39 100644 --- a/impeller/renderer/backend/vulkan/command_encoder_vk.h +++ b/impeller/renderer/backend/vulkan/command_encoder_vk.h @@ -17,7 +17,7 @@ namespace impeller { namespace testing { - class BlitCommandVkTest_BlitCopyTextureToTextureCommandVK_Test; +class BlitCommandVkTest_BlitCopyTextureToTextureCommandVK_Test; } class ContextVK; @@ -56,7 +56,8 @@ class CommandEncoderVK { private: friend class ContextVK; - friend class ::impeller::testing::BlitCommandVkTest_BlitCopyTextureToTextureCommandVK_Test; + friend class ::impeller::testing:: + BlitCommandVkTest_BlitCopyTextureToTextureCommandVK_Test; vk::Device device_ = {}; std::shared_ptr queue_; From cd34aea41bd980a80688902dc5115ca3a0d70abf Mon Sep 17 00:00:00 2001 From: Aaron Clarke Date: Fri, 21 Apr 2023 15:05:04 -0700 Subject: [PATCH 04/12] started allocating the textures --- .../vulkan/blit_command_vk_unittests.cc | 137 ++++++++++++++---- 1 file changed, 109 insertions(+), 28 deletions(-) diff --git a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc index e926f101b2ba9..5f1859a081b6b 100644 --- a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc +++ b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc @@ -65,6 +65,7 @@ void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, pProperties->limits.framebufferColorSampleCounts = static_cast(VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + pProperties->limits.maxImageDimension2D = 4096; } void vkGetPhysicalDeviceQueueFamilyProperties( @@ -114,7 +115,9 @@ void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties* pMemoryProperties) { pMemoryProperties->memoryTypeCount = 1; pMemoryProperties->memoryTypes[0].heapIndex = 0; - pMemoryProperties->memoryTypes[0].propertyFlags = 0; + // pMemoryProperties->memoryTypes[0].propertyFlags = + // VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | + // VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD; pMemoryProperties->memoryHeapCount = 1; pMemoryProperties->memoryHeaps[0].size = 1024 * 1024 * 1024; pMemoryProperties->memoryHeaps[0].flags = 0; @@ -128,6 +131,103 @@ VkResult vkCreatePipelineCache(VkDevice device, return VK_SUCCESS; } +VkResult vkCreateCommandPool(VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool) { + *pCommandPool = reinterpret_cast(0xc0de0001); + return VK_SUCCESS; +} + +VkResult vkAllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers) { + *pCommandBuffers = reinterpret_cast(0x0b0ffe12); + 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(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(0xCAFEB0BA); + return VK_SUCCESS; +} + +VkResult vkBindImageMemory(VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset) { + return VK_SUCCESS; +} + +PFN_vkVoidFunction GetProcAddress(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("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)GetProcAddress; + } else if (strcmp("vkGetDeviceProcAddr", pName) == 0) { + return (PFN_vkVoidFunction)GetProcAddress; + } 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; + } + return noop; +} } // namespace TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { @@ -135,37 +235,18 @@ TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { auto message_loop = fml::ConcurrentMessageLoop::Create(); settings.worker_task_runner = std::make_shared(message_loop); - settings.proc_address_callback = [](VkInstance instance, - const char* pName) -> PFN_vkVoidFunction { - 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; - } - return noop; - }; + settings.proc_address_callback = GetProcAddress; auto context = ContextVK::Create(std::move(settings)); + auto pool = CommandPoolVK::GetThreadLocal(context.get()); CommandEncoderVK encoder(context->GetDevice(), context->GetGraphicsQueue(), {}, context->GetFenceWaiter()); BlitCopyTextureToTextureCommandVK cmd; + cmd.source = context->GetResourceAllocator()->CreateTexture({ + .size = ISize(100, 100), + }); + cmd.destination = context->GetResourceAllocator()->CreateTexture({ + .size = ISize(100, 100), + }); bool result = cmd.Encode(encoder); ASSERT_TRUE(result); } From c34e37cf1f155724531ea48d4a7547f7b8635557 Mon Sep 17 00:00:00 2001 From: Aaron Clarke Date: Fri, 21 Apr 2023 15:14:00 -0700 Subject: [PATCH 05/12] test passes now --- .../backend/vulkan/blit_command_vk_unittests.cc | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc index 5f1859a081b6b..297105a816013 100644 --- a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc +++ b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc @@ -183,6 +183,14 @@ VkResult vkBindImageMemory(VkDevice device, return VK_SUCCESS; } +VkResult vkCreateImageView(VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView) { + *pView = reinterpret_cast(0xFEE1DEAD); + return VK_SUCCESS; +} + PFN_vkVoidFunction GetProcAddress(VkInstance instance, const char* pName) { if (strcmp("vkEnumerateInstanceExtensionProperties", pName) == 0) { return (PFN_vkVoidFunction)vkEnumerateInstanceExtensionProperties; @@ -225,6 +233,8 @@ PFN_vkVoidFunction GetProcAddress(VkInstance instance, const char* pName) { return (PFN_vkVoidFunction)vkAllocateMemory; } else if (strcmp("vkBindImageMemory", pName) == 0) { return (PFN_vkVoidFunction)vkBindImageMemory; + } else if (strcmp("vkCreateImageView", pName) == 0) { + return (PFN_vkVoidFunction)vkCreateImageView; } return noop; } @@ -239,7 +249,7 @@ TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { auto context = ContextVK::Create(std::move(settings)); auto pool = CommandPoolVK::GetThreadLocal(context.get()); CommandEncoderVK encoder(context->GetDevice(), context->GetGraphicsQueue(), - {}, context->GetFenceWaiter()); + pool, context->GetFenceWaiter()); BlitCopyTextureToTextureCommandVK cmd; cmd.source = context->GetResourceAllocator()->CreateTexture({ .size = ISize(100, 100), From 52bb77c0802009078f4a54df079070b0ea87c74b Mon Sep 17 00:00:00 2001 From: Aaron Clarke Date: Fri, 21 Apr 2023 15:23:35 -0700 Subject: [PATCH 06/12] split out mock vulkan into its own file --- impeller/renderer/backend/vulkan/BUILD.gn | 11 +- .../backend/vulkan/test/mock_vulkan.cc | 247 ++++++++++++++++++ .../backend/vulkan/test/mock_vulkan.h | 16 ++ 3 files changed, 272 insertions(+), 2 deletions(-) create mode 100644 impeller/renderer/backend/vulkan/test/mock_vulkan.cc create mode 100644 impeller/renderer/backend/vulkan/test/mock_vulkan.h diff --git a/impeller/renderer/backend/vulkan/BUILD.gn b/impeller/renderer/backend/vulkan/BUILD.gn index 313f5d7a1703b..a2386ddbc3d22 100644 --- a/impeller/renderer/backend/vulkan/BUILD.gn +++ b/impeller/renderer/backend/vulkan/BUILD.gn @@ -6,8 +6,15 @@ import("../../../tools/impeller.gni") impeller_component("vulkan_unittests") { testonly = true - sources = [ "blit_command_vk_unittests.cc" ] - deps = [ ":vulkan", "//flutter/testing:testing_lib" ] + sources = [ + "blit_command_vk_unittests.cc", + "test/mock_vulkan.cc", + "test/mock_vulkan.h", + ] + deps = [ + ":vulkan", + "//flutter/testing:testing_lib", + ] } impeller_component("vulkan") { diff --git a/impeller/renderer/backend/vulkan/test/mock_vulkan.cc b/impeller/renderer/backend/vulkan/test/mock_vulkan.cc new file mode 100644 index 0000000000000..b2d37388e6841 --- /dev/null +++ b/impeller/renderer/backend/vulkan/test/mock_vulkan.cc @@ -0,0 +1,247 @@ +// 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" + +namespace impeller { +namespace testing { + +PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance, + const char* pName); + +namespace { +void noop() {} + +VkResult vkEnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) { + if (!pProperties) { + *pPropertyCount = 2; + + } else { + strcpy(pProperties[0].extensionName, "VK_KHR_surface"); + pProperties[0].specVersion = 0; + strcpy(pProperties[1].extensionName, "VK_MVK_macos_surface"); + pProperties[1].specVersion = 0; + } + return VK_SUCCESS; +} + +VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, + VkLayerProperties* pProperties) { + *pPropertyCount = 0; + return VK_SUCCESS; +} + +VkResult vkEnumeratePhysicalDevices(VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices) { + if (!pPhysicalDevices) { + *pPhysicalDeviceCount = 1; + } else { + pPhysicalDevices[0] = reinterpret_cast(0xfeedface); + } + return VK_SUCCESS; +} + +void vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties) { + if (format == VK_FORMAT_B8G8R8A8_UNORM) { + pFormatProperties->optimalTilingFeatures = + static_cast( + vk::FormatFeatureFlagBits::eColorAttachment); + } else if (format == VK_FORMAT_S8_UINT) { + pFormatProperties->optimalTilingFeatures = + static_cast( + vk::FormatFeatureFlagBits::eDepthStencilAttachment); + } +} + +void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties) { + pProperties->limits.framebufferColorSampleCounts = + static_cast(VK_SAMPLE_COUNT_1_BIT | + VK_SAMPLE_COUNT_4_BIT); + pProperties->limits.maxImageDimension2D = 4096; +} + +void vkGetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties) { + if (!pQueueFamilyProperties) { + *pQueueFamilyPropertyCount = 1; + } else { + pQueueFamilyProperties[0].queueCount = 3; + pQueueFamilyProperties[0].queueFlags = static_cast( + 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(0xcafebabe); + return VK_SUCCESS; +} + +VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance) { + *pInstance = reinterpret_cast(0xbaadf00d); + return VK_SUCCESS; +} + +void vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties) { + pMemoryProperties->memoryTypeCount = 1; + pMemoryProperties->memoryTypes[0].heapIndex = 0; + // pMemoryProperties->memoryTypes[0].propertyFlags = + // VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | + // VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD; + pMemoryProperties->memoryHeapCount = 1; + pMemoryProperties->memoryHeaps[0].size = 1024 * 1024 * 1024; + pMemoryProperties->memoryHeaps[0].flags = 0; +} + +VkResult vkCreatePipelineCache(VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache) { + *pPipelineCache = reinterpret_cast(0xb000dead); + return VK_SUCCESS; +} + +VkResult vkCreateCommandPool(VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool) { + *pCommandPool = reinterpret_cast(0xc0de0001); + return VK_SUCCESS; +} + +VkResult vkAllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers) { + *pCommandBuffers = reinterpret_cast(0x0b0ffe12); + 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(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(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(0xFEE1DEAD); + return VK_SUCCESS; +} + +} // namespace + +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("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; + } + return noop; +} + +} // namespace testing +} // namespace impeller diff --git a/impeller/renderer/backend/vulkan/test/mock_vulkan.h b/impeller/renderer/backend/vulkan/test/mock_vulkan.h new file mode 100644 index 0000000000000..2e5b90190ddbb --- /dev/null +++ b/impeller/renderer/backend/vulkan/test/mock_vulkan.h @@ -0,0 +1,16 @@ +// 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. + +#pragma once + +#include "impeller/renderer/backend/vulkan/vk.h" + +namespace impeller { +namespace testing { + +PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance, + const char* pName); + +} +} // namespace impeller From 34652a6f7d5c391f1a0f5fd11e1f7955be738db1 Mon Sep 17 00:00:00 2001 From: Aaron Clarke Date: Fri, 21 Apr 2023 15:34:20 -0700 Subject: [PATCH 07/12] finished test for one blit command --- .../vulkan/blit_command_vk_unittests.cc | 238 +----------------- .../backend/vulkan/command_encoder_vk.cc | 16 ++ .../backend/vulkan/command_encoder_vk.h | 2 + 3 files changed, 23 insertions(+), 233 deletions(-) diff --git a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc index 297105a816013..a9196abc9febf 100644 --- a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc +++ b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc @@ -5,247 +5,17 @@ #include "flutter/testing/testing.h" #include "impeller/renderer/backend/vulkan/blit_command_vk.h" #include "impeller/renderer/backend/vulkan/command_encoder_vk.h" +#include "impeller/renderer/backend/vulkan/test/mock_vulkan.h" namespace impeller { namespace testing { -namespace { -void noop() {} - -VkResult vkEnumerateInstanceExtensionProperties( - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties) { - if (!pProperties) { - *pPropertyCount = 2; - - } else { - strcpy(pProperties[0].extensionName, "VK_KHR_surface"); - pProperties[0].specVersion = 0; - strcpy(pProperties[1].extensionName, "VK_MVK_macos_surface"); - pProperties[1].specVersion = 0; - } - return VK_SUCCESS; -} - -VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, - VkLayerProperties* pProperties) { - *pPropertyCount = 0; - return VK_SUCCESS; -} - -VkResult vkEnumeratePhysicalDevices(VkInstance instance, - uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices) { - if (!pPhysicalDevices) { - *pPhysicalDeviceCount = 1; - } else { - pPhysicalDevices[0] = reinterpret_cast(0xfeedface); - } - return VK_SUCCESS; -} - -void vkGetPhysicalDeviceFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties* pFormatProperties) { - if (format == VK_FORMAT_B8G8R8A8_UNORM) { - pFormatProperties->optimalTilingFeatures = - static_cast( - vk::FormatFeatureFlagBits::eColorAttachment); - } else if (format == VK_FORMAT_S8_UINT) { - pFormatProperties->optimalTilingFeatures = - static_cast( - vk::FormatFeatureFlagBits::eDepthStencilAttachment); - } -} - -void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties) { - pProperties->limits.framebufferColorSampleCounts = - static_cast(VK_SAMPLE_COUNT_1_BIT | - VK_SAMPLE_COUNT_4_BIT); - pProperties->limits.maxImageDimension2D = 4096; -} - -void vkGetPhysicalDeviceQueueFamilyProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties* pQueueFamilyProperties) { - if (!pQueueFamilyProperties) { - *pQueueFamilyPropertyCount = 1; - } else { - pQueueFamilyProperties[0].queueCount = 3; - pQueueFamilyProperties[0].queueFlags = static_cast( - 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(0xcafebabe); - return VK_SUCCESS; -} - -VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkInstance* pInstance) { - *pInstance = reinterpret_cast(0xbaadf00d); - return VK_SUCCESS; -} - -void vkGetPhysicalDeviceMemoryProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties* pMemoryProperties) { - pMemoryProperties->memoryTypeCount = 1; - pMemoryProperties->memoryTypes[0].heapIndex = 0; - // pMemoryProperties->memoryTypes[0].propertyFlags = - // VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | - // VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD; - pMemoryProperties->memoryHeapCount = 1; - pMemoryProperties->memoryHeaps[0].size = 1024 * 1024 * 1024; - pMemoryProperties->memoryHeaps[0].flags = 0; -} - -VkResult vkCreatePipelineCache(VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineCache* pPipelineCache) { - *pPipelineCache = reinterpret_cast(0xb000dead); - return VK_SUCCESS; -} - -VkResult vkCreateCommandPool(VkDevice device, - const VkCommandPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCommandPool* pCommandPool) { - *pCommandPool = reinterpret_cast(0xc0de0001); - return VK_SUCCESS; -} - -VkResult vkAllocateCommandBuffers( - VkDevice device, - const VkCommandBufferAllocateInfo* pAllocateInfo, - VkCommandBuffer* pCommandBuffers) { - *pCommandBuffers = reinterpret_cast(0x0b0ffe12); - 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(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(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(0xFEE1DEAD); - return VK_SUCCESS; -} - -PFN_vkVoidFunction GetProcAddress(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("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)GetProcAddress; - } else if (strcmp("vkGetDeviceProcAddr", pName) == 0) { - return (PFN_vkVoidFunction)GetProcAddress; - } 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; - } - return noop; -} -} // namespace - TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { ContextVK::Settings settings; auto message_loop = fml::ConcurrentMessageLoop::Create(); settings.worker_task_runner = std::make_shared(message_loop); - settings.proc_address_callback = GetProcAddress; + settings.proc_address_callback = GetMockVulkanProcAddress; auto context = ContextVK::Create(std::move(settings)); auto pool = CommandPoolVK::GetThreadLocal(context.get()); CommandEncoderVK encoder(context->GetDevice(), context->GetGraphicsQueue(), @@ -258,7 +28,9 @@ TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { .size = ISize(100, 100), }); bool result = cmd.Encode(encoder); - ASSERT_TRUE(result); + EXPECT_TRUE(result); + EXPECT_TRUE(encoder.IsTracking(cmd.source)); + EXPECT_TRUE(encoder.IsTracking(cmd.destination)); } } // namespace testing diff --git a/impeller/renderer/backend/vulkan/command_encoder_vk.cc b/impeller/renderer/backend/vulkan/command_encoder_vk.cc index 35e0da71a903f..4b4b1c8703c2b 100644 --- a/impeller/renderer/backend/vulkan/command_encoder_vk.cc +++ b/impeller/renderer/backend/vulkan/command_encoder_vk.cc @@ -65,6 +65,13 @@ class TrackedObjectsVK { tracked_textures_.insert(std::move(texture)); } + bool IsTracking(const std::shared_ptr& texture) const { + if (!texture) { + return false; + } + return tracked_textures_.find(texture) != tracked_textures_.end(); + } + vk::CommandBuffer GetCommandBuffer() const { return *buffer_; } DescriptorPoolVK& GetDescriptorPool() { return desc_pool_; } @@ -190,6 +197,15 @@ bool CommandEncoderVK::Track(const std::shared_ptr& texture) { return Track(TextureVK::Cast(*texture).GetTextureSource()); } +bool CommandEncoderVK::IsTracking( + const std::shared_ptr& texture) const { + if (!IsValid()) { + return false; + } + std::shared_ptr source = TextureVK::Cast(*texture).GetTextureSource(); + return tracked_objects_->IsTracking(source); +} + std::optional CommandEncoderVK::AllocateDescriptorSet( const vk::DescriptorSetLayout& layout) { if (!IsValid()) { diff --git a/impeller/renderer/backend/vulkan/command_encoder_vk.h b/impeller/renderer/backend/vulkan/command_encoder_vk.h index 16ac2c9e11f39..95e09565f53fc 100644 --- a/impeller/renderer/backend/vulkan/command_encoder_vk.h +++ b/impeller/renderer/backend/vulkan/command_encoder_vk.h @@ -54,6 +54,8 @@ class CommandEncoderVK { std::optional AllocateDescriptorSet( const vk::DescriptorSetLayout& layout); + bool IsTracking(const std::shared_ptr& texture) const; + private: friend class ContextVK; friend class ::impeller::testing:: From 6169338aa6f2cd47ca00a1b02f98db6009caa78e Mon Sep 17 00:00:00 2001 From: Aaron Clarke Date: Fri, 21 Apr 2023 15:41:53 -0700 Subject: [PATCH 08/12] added mip map test --- .../vulkan/blit_command_vk_unittests.cc | 43 +++++++++++++++++++ .../backend/vulkan/command_encoder_vk.cc | 3 +- .../backend/vulkan/command_encoder_vk.h | 8 +++- 3 files changed, 52 insertions(+), 2 deletions(-) diff --git a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc index a9196abc9febf..66ddf4136dc89 100644 --- a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc +++ b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc @@ -33,5 +33,48 @@ TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { EXPECT_TRUE(encoder.IsTracking(cmd.destination)); } +// TEST(BlitCommandVkTest, BlitCopyTextureToBufferCommandVK) { +// ContextVK::Settings settings; +// auto message_loop = fml::ConcurrentMessageLoop::Create(); +// settings.worker_task_runner = +// std::make_shared(message_loop); +// settings.proc_address_callback = GetMockVulkanProcAddress; +// auto context = ContextVK::Create(std::move(settings)); +// auto pool = CommandPoolVK::GetThreadLocal(context.get()); +// CommandEncoderVK encoder(context->GetDevice(), context->GetGraphicsQueue(), +// pool, context->GetFenceWaiter()); +// BlitCopyTextureToBufferCommandVK cmd; +// cmd.source = context->GetResourceAllocator()->CreateTexture({ +// .size = ISize(100, 100), +// }); +// cmd.destination = context->GetResourceAllocator()->CreateTexture({ +// .size = ISize(100, 100), +// }); +// bool result = cmd.Encode(encoder); +// EXPECT_TRUE(result); +// EXPECT_TRUE(encoder.IsTracking(cmd.source)); +// EXPECT_TRUE(encoder.IsTracking(cmd.destination)); +// } + +TEST(BlitCommandVkTest, BlitGenerateMipmapCommandVK) { + ContextVK::Settings settings; + auto message_loop = fml::ConcurrentMessageLoop::Create(); + settings.worker_task_runner = + std::make_shared(message_loop); + settings.proc_address_callback = GetMockVulkanProcAddress; + auto context = ContextVK::Create(std::move(settings)); + auto pool = CommandPoolVK::GetThreadLocal(context.get()); + CommandEncoderVK encoder(context->GetDevice(), context->GetGraphicsQueue(), + pool, context->GetFenceWaiter()); + BlitGenerateMipmapCommandVK cmd; + cmd.texture = context->GetResourceAllocator()->CreateTexture({ + .size = ISize(100, 100), + .mip_count = 2, + }); + bool result = cmd.Encode(encoder); + EXPECT_TRUE(result); + EXPECT_TRUE(encoder.IsTracking(cmd.texture)); +} + } // namespace testing } // namespace impeller diff --git a/impeller/renderer/backend/vulkan/command_encoder_vk.cc b/impeller/renderer/backend/vulkan/command_encoder_vk.cc index 4b4b1c8703c2b..7ed71448a4d68 100644 --- a/impeller/renderer/backend/vulkan/command_encoder_vk.cc +++ b/impeller/renderer/backend/vulkan/command_encoder_vk.cc @@ -202,7 +202,8 @@ bool CommandEncoderVK::IsTracking( if (!IsValid()) { return false; } - std::shared_ptr source = TextureVK::Cast(*texture).GetTextureSource(); + std::shared_ptr source = + TextureVK::Cast(*texture).GetTextureSource(); return tracked_objects_->IsTracking(source); } diff --git a/impeller/renderer/backend/vulkan/command_encoder_vk.h b/impeller/renderer/backend/vulkan/command_encoder_vk.h index 95e09565f53fc..eca4d7415159f 100644 --- a/impeller/renderer/backend/vulkan/command_encoder_vk.h +++ b/impeller/renderer/backend/vulkan/command_encoder_vk.h @@ -18,7 +18,9 @@ namespace impeller { namespace testing { class BlitCommandVkTest_BlitCopyTextureToTextureCommandVK_Test; -} +class BlitCommandVkTest_BlitCopyTextureToBufferCommandVK_Test; +class BlitCommandVkTest_BlitGenerateMipmapCommandVK_Test; +} // namespace testing class ContextVK; class DeviceBuffer; @@ -60,6 +62,10 @@ class CommandEncoderVK { friend class ContextVK; friend class ::impeller::testing:: BlitCommandVkTest_BlitCopyTextureToTextureCommandVK_Test; + friend class ::impeller::testing:: + BlitCommandVkTest_BlitCopyTextureToBufferCommandVK_Test; + friend class ::impeller::testing:: + BlitCommandVkTest_BlitGenerateMipmapCommandVK_Test; vk::Device device_ = {}; std::shared_ptr queue_; From 07b5818123b74d1275810c85aebd449ae82650f9 Mon Sep 17 00:00:00 2001 From: Aaron Clarke Date: Fri, 21 Apr 2023 15:58:56 -0700 Subject: [PATCH 09/12] got the blit to buffer working --- .../backend/vulkan/blit_command_vk.cc | 2 +- .../vulkan/blit_command_vk_unittests.cc | 44 +++++++++---------- .../backend/vulkan/command_encoder_vk.cc | 15 +++++++ .../backend/vulkan/command_encoder_vk.h | 6 ++- .../backend/vulkan/test/mock_vulkan.cc | 30 +++++++++++++ 5 files changed, 72 insertions(+), 25 deletions(-) diff --git a/impeller/renderer/backend/vulkan/blit_command_vk.cc b/impeller/renderer/backend/vulkan/blit_command_vk.cc index 1c45c3411deb9..edf2cd73dc555 100644 --- a/impeller/renderer/backend/vulkan/blit_command_vk.cc +++ b/impeller/renderer/backend/vulkan/blit_command_vk.cc @@ -100,7 +100,7 @@ bool BlitCopyTextureToBufferCommandVK::Encode(CommandEncoderVK& encoder) const { // cast source and destination to TextureVK const auto& src = TextureVK::Cast(*source); - if (!encoder.Track(source)) { + if (!encoder.Track(source) || !encoder.Track(destination)) { return false; } diff --git a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc index 66ddf4136dc89..7ad4e8e9d73a0 100644 --- a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc +++ b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc @@ -33,28 +33,28 @@ TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { EXPECT_TRUE(encoder.IsTracking(cmd.destination)); } -// TEST(BlitCommandVkTest, BlitCopyTextureToBufferCommandVK) { -// ContextVK::Settings settings; -// auto message_loop = fml::ConcurrentMessageLoop::Create(); -// settings.worker_task_runner = -// std::make_shared(message_loop); -// settings.proc_address_callback = GetMockVulkanProcAddress; -// auto context = ContextVK::Create(std::move(settings)); -// auto pool = CommandPoolVK::GetThreadLocal(context.get()); -// CommandEncoderVK encoder(context->GetDevice(), context->GetGraphicsQueue(), -// pool, context->GetFenceWaiter()); -// BlitCopyTextureToBufferCommandVK cmd; -// cmd.source = context->GetResourceAllocator()->CreateTexture({ -// .size = ISize(100, 100), -// }); -// cmd.destination = context->GetResourceAllocator()->CreateTexture({ -// .size = ISize(100, 100), -// }); -// bool result = cmd.Encode(encoder); -// EXPECT_TRUE(result); -// EXPECT_TRUE(encoder.IsTracking(cmd.source)); -// EXPECT_TRUE(encoder.IsTracking(cmd.destination)); -// } +TEST(BlitCommandVkTest, BlitCopyTextureToBufferCommandVK) { + ContextVK::Settings settings; + auto message_loop = fml::ConcurrentMessageLoop::Create(); + settings.worker_task_runner = + std::make_shared(message_loop); + settings.proc_address_callback = GetMockVulkanProcAddress; + auto context = ContextVK::Create(std::move(settings)); + auto pool = CommandPoolVK::GetThreadLocal(context.get()); + CommandEncoderVK encoder(context->GetDevice(), context->GetGraphicsQueue(), + pool, context->GetFenceWaiter()); + BlitCopyTextureToBufferCommandVK cmd; + cmd.source = context->GetResourceAllocator()->CreateTexture({ + .size = ISize(100, 100), + }); + cmd.destination = context->GetResourceAllocator()->CreateBuffer({ + .size = 1, + }); + bool result = cmd.Encode(encoder); + EXPECT_TRUE(result); + EXPECT_TRUE(encoder.IsTracking(cmd.source)); + EXPECT_TRUE(encoder.IsTracking(cmd.destination)); +} TEST(BlitCommandVkTest, BlitGenerateMipmapCommandVK) { ContextVK::Settings settings; diff --git a/impeller/renderer/backend/vulkan/command_encoder_vk.cc b/impeller/renderer/backend/vulkan/command_encoder_vk.cc index 7ed71448a4d68..fd6cbec90be2a 100644 --- a/impeller/renderer/backend/vulkan/command_encoder_vk.cc +++ b/impeller/renderer/backend/vulkan/command_encoder_vk.cc @@ -58,6 +58,13 @@ class TrackedObjectsVK { tracked_buffers_.insert(std::move(buffer)); } + bool IsTracking(const std::shared_ptr& buffer) const { + if (!buffer) { + return false; + } + return tracked_buffers_.find(buffer) != tracked_buffers_.end(); + } + void Track(std::shared_ptr texture) { if (!texture) { return; @@ -179,6 +186,14 @@ bool CommandEncoderVK::Track(std::shared_ptr buffer) { return true; } +bool CommandEncoderVK::IsTracking( + const std::shared_ptr& buffer) const { + if (!IsValid()) { + return false; + } + return tracked_objects_->IsTracking(buffer); +} + bool CommandEncoderVK::Track(std::shared_ptr texture) { if (!IsValid()) { return false; diff --git a/impeller/renderer/backend/vulkan/command_encoder_vk.h b/impeller/renderer/backend/vulkan/command_encoder_vk.h index eca4d7415159f..9a4581cdf9c9b 100644 --- a/impeller/renderer/backend/vulkan/command_encoder_vk.h +++ b/impeller/renderer/backend/vulkan/command_encoder_vk.h @@ -41,8 +41,12 @@ class CommandEncoderVK { bool Track(std::shared_ptr buffer); + bool IsTracking(const std::shared_ptr& texture) const; + bool Track(const std::shared_ptr& texture); + bool IsTracking(const std::shared_ptr& texture) const; + bool Track(std::shared_ptr texture); vk::CommandBuffer GetCommandBuffer() const; @@ -56,8 +60,6 @@ class CommandEncoderVK { std::optional AllocateDescriptorSet( const vk::DescriptorSetLayout& layout); - bool IsTracking(const std::shared_ptr& texture) const; - private: friend class ContextVK; friend class ::impeller::testing:: diff --git a/impeller/renderer/backend/vulkan/test/mock_vulkan.cc b/impeller/renderer/backend/vulkan/test/mock_vulkan.cc index b2d37388e6841..447cf59b4aae1 100644 --- a/impeller/renderer/backend/vulkan/test/mock_vulkan.cc +++ b/impeller/renderer/backend/vulkan/test/mock_vulkan.cc @@ -192,6 +192,29 @@ VkResult vkCreateImageView(VkDevice device, return VK_SUCCESS; } +VkResult vkCreateBuffer(VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer) { + *pBuffer = reinterpret_cast(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; +} + } // namespace PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance, @@ -239,6 +262,13 @@ PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance, 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; } return noop; } From aa114bca3b6f4776e67ec3a8b4d6658ccd1c750e Mon Sep 17 00:00:00 2001 From: Aaron Clarke Date: Fri, 21 Apr 2023 15:59:31 -0700 Subject: [PATCH 10/12] format gn --- impeller/BUILD.gn | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/impeller/BUILD.gn b/impeller/BUILD.gn index 1ad0cba156fc9..fb111b0e4c31e 100644 --- a/impeller/BUILD.gn +++ b/impeller/BUILD.gn @@ -98,9 +98,7 @@ impeller_component("impeller_unittests") { } if (impeller_enable_vulkan) { - deps += [ - "//flutter/impeller/renderer/backend/vulkan:vulkan_unittests", - ] + deps += [ "//flutter/impeller/renderer/backend/vulkan:vulkan_unittests" ] } if (impeller_enable_compute) { From 824a32a80ec72fffed2b8d36c3d5c0d2c5069925 Mon Sep 17 00:00:00 2001 From: Aaron Clarke Date: Fri, 21 Apr 2023 16:18:06 -0700 Subject: [PATCH 11/12] pulled out function to make mock vulkan context --- .../vulkan/blit_command_vk_unittests.cc | 21 +++---------------- .../backend/vulkan/test/mock_vulkan.cc | 16 +++++++++----- .../backend/vulkan/test/mock_vulkan.h | 5 ++--- 3 files changed, 16 insertions(+), 26 deletions(-) diff --git a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc index 7ad4e8e9d73a0..a6f871d64c694 100644 --- a/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc +++ b/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc @@ -11,12 +11,7 @@ namespace impeller { namespace testing { TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { - ContextVK::Settings settings; - auto message_loop = fml::ConcurrentMessageLoop::Create(); - settings.worker_task_runner = - std::make_shared(message_loop); - settings.proc_address_callback = GetMockVulkanProcAddress; - auto context = ContextVK::Create(std::move(settings)); + auto context = CreateMockVulkanContext(); auto pool = CommandPoolVK::GetThreadLocal(context.get()); CommandEncoderVK encoder(context->GetDevice(), context->GetGraphicsQueue(), pool, context->GetFenceWaiter()); @@ -34,12 +29,7 @@ TEST(BlitCommandVkTest, BlitCopyTextureToTextureCommandVK) { } TEST(BlitCommandVkTest, BlitCopyTextureToBufferCommandVK) { - ContextVK::Settings settings; - auto message_loop = fml::ConcurrentMessageLoop::Create(); - settings.worker_task_runner = - std::make_shared(message_loop); - settings.proc_address_callback = GetMockVulkanProcAddress; - auto context = ContextVK::Create(std::move(settings)); + auto context = CreateMockVulkanContext(); auto pool = CommandPoolVK::GetThreadLocal(context.get()); CommandEncoderVK encoder(context->GetDevice(), context->GetGraphicsQueue(), pool, context->GetFenceWaiter()); @@ -57,12 +47,7 @@ TEST(BlitCommandVkTest, BlitCopyTextureToBufferCommandVK) { } TEST(BlitCommandVkTest, BlitGenerateMipmapCommandVK) { - ContextVK::Settings settings; - auto message_loop = fml::ConcurrentMessageLoop::Create(); - settings.worker_task_runner = - std::make_shared(message_loop); - settings.proc_address_callback = GetMockVulkanProcAddress; - auto context = ContextVK::Create(std::move(settings)); + auto context = CreateMockVulkanContext(); auto pool = CommandPoolVK::GetThreadLocal(context.get()); CommandEncoderVK encoder(context->GetDevice(), context->GetGraphicsQueue(), pool, context->GetFenceWaiter()); diff --git a/impeller/renderer/backend/vulkan/test/mock_vulkan.cc b/impeller/renderer/backend/vulkan/test/mock_vulkan.cc index 447cf59b4aae1..100b36b1cb175 100644 --- a/impeller/renderer/backend/vulkan/test/mock_vulkan.cc +++ b/impeller/renderer/backend/vulkan/test/mock_vulkan.cc @@ -7,9 +7,6 @@ namespace impeller { namespace testing { -PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance, - const char* pName); - namespace { void noop() {} @@ -215,8 +212,6 @@ VkResult vkBindBufferMemory(VkDevice device, return VK_SUCCESS; } -} // namespace - PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance, const char* pName) { if (strcmp("vkEnumerateInstanceExtensionProperties", pName) == 0) { @@ -273,5 +268,16 @@ PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance, return noop; } +} // namespace + +std::shared_ptr CreateMockVulkanContext(void) { + ContextVK::Settings settings; + auto message_loop = fml::ConcurrentMessageLoop::Create(); + settings.worker_task_runner = + std::make_shared(message_loop); + settings.proc_address_callback = GetMockVulkanProcAddress; + return ContextVK::Create(std::move(settings)); +} + } // namespace testing } // namespace impeller diff --git a/impeller/renderer/backend/vulkan/test/mock_vulkan.h b/impeller/renderer/backend/vulkan/test/mock_vulkan.h index 2e5b90190ddbb..cc075850ff37a 100644 --- a/impeller/renderer/backend/vulkan/test/mock_vulkan.h +++ b/impeller/renderer/backend/vulkan/test/mock_vulkan.h @@ -4,13 +4,12 @@ #pragma once -#include "impeller/renderer/backend/vulkan/vk.h" +#include "impeller/renderer/backend/vulkan/context_vk.h" namespace impeller { namespace testing { -PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance, - const char* pName); +std::shared_ptr CreateMockVulkanContext(void); } } // namespace impeller From 2e907b40291272b022658cf818a1949493af82a8 Mon Sep 17 00:00:00 2001 From: Aaron Clarke Date: Fri, 21 Apr 2023 16:49:46 -0700 Subject: [PATCH 12/12] licenses --- ci/licenses_golden/excluded_files | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ci/licenses_golden/excluded_files b/ci/licenses_golden/excluded_files index 1cf139cf375e2..2d3b7636892fb 100644 --- a/ci/licenses_golden/excluded_files +++ b/ci/licenses_golden/excluded_files @@ -144,6 +144,8 @@ ../../../flutter/impeller/golden_tests_harvester/test ../../../flutter/impeller/image/README.md ../../../flutter/impeller/playground +../../../flutter/impeller/renderer/backend/vulkan/blit_command_vk_unittests.cc +../../../flutter/impeller/renderer/backend/vulkan/test ../../../flutter/impeller/renderer/capabilities_unittests.cc ../../../flutter/impeller/renderer/compute_subgroup_unittests.cc ../../../flutter/impeller/renderer/compute_unittests.cc