From 52e943a4693af75b40b62200191981da7458db62 Mon Sep 17 00:00:00 2001 From: Brian Salomon Date: Tue, 13 Mar 2018 09:32:39 -0400 Subject: [PATCH] Add testing-only backend render target support to GrVkGpu. Update unit tests to use backend render targets on non-GL contexts Add named DM configs for rendering to Vulkan backend render targets and textures. Make src data ptr param to createTestingOnlyBackendTexture be const. Change-Id: I17f5375ed9bb08422006698956469d3151c4954c Reviewed-on: https://skia-review.googlesource.com/113276 Commit-Queue: Brian Salomon Reviewed-by: Greg Daniel --- src/gpu/GrGpu.h | 11 +-- src/gpu/gl/GrGLGpu.cpp | 4 +- src/gpu/gl/GrGLGpu.h | 5 +- src/gpu/mock/GrMockGpu.cpp | 2 +- src/gpu/mock/GrMockGpu.h | 5 +- src/gpu/mtl/GrMtlGpu.h | 2 +- src/gpu/vk/GrVkGpu.cpp | 142 +++++++++++++++++----------- src/gpu/vk/GrVkGpu.h | 11 ++- tests/ProxyConversionTest.cpp | 58 +++++++----- tests/ProxyTest.cpp | 34 +++++-- tools/flags/SkCommonFlagsConfig.cpp | 2 + tools/gpu/GrTest.cpp | 2 +- 12 files changed, 173 insertions(+), 105 deletions(-) diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h index 40d766431a..2aacc49151 100644 --- a/src/gpu/GrGpu.h +++ b/src/gpu/GrGpu.h @@ -452,14 +452,13 @@ public: /** Creates a texture directly in the backend API without wrapping it in a GrTexture. This is only to be used for testing (particularly for testing the methods that import an externally created texture into Skia. Must be matched with a call to deleteTestingOnlyTexture(). */ - GrBackendTexture createTestingOnlyBackendTexture(void* pixels, int w, int h, SkColorType, + GrBackendTexture createTestingOnlyBackendTexture(const void* pixels, int w, int h, SkColorType, bool isRenderTarget, GrMipMapped); /** Older version based on GrPixelConfig. Currently the preferred one above devolves to this. */ - virtual GrBackendTexture createTestingOnlyBackendTexture( - void* pixels, int w, int h, - GrPixelConfig config, - bool isRenderTarget, - GrMipMapped mipMapped) = 0; + virtual GrBackendTexture createTestingOnlyBackendTexture(const void* pixels, int w, int h, + GrPixelConfig config, + bool isRenderTarget, + GrMipMapped mipMapped) = 0; /** Check a handle represents an actual texture in the backend API that has not been freed. */ virtual bool isTestingOnlyBackendTexture(const GrBackendTexture&) const = 0; /** diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp index 7e69fbe341..9023554b6b 100644 --- a/src/gpu/gl/GrGLGpu.cpp +++ b/src/gpu/gl/GrGLGpu.cpp @@ -4345,7 +4345,7 @@ void GrGLGpu::xferBarrier(GrRenderTarget* rt, GrXferBarrierType type) { } #if GR_TEST_UTILS -GrBackendTexture GrGLGpu::createTestingOnlyBackendTexture(void* pixels, int w, int h, +GrBackendTexture GrGLGpu::createTestingOnlyBackendTexture(const void* pixels, int w, int h, GrPixelConfig config, bool /*isRT*/, GrMipMapped mipMapped) { if (!this->caps()->isConfigTexturable(config)) { @@ -4395,7 +4395,7 @@ GrBackendTexture GrGLGpu::createTestingOnlyBackendTexture(void* pixels, int w, i if (!pixels) { // Fill in the texture with all zeros so we don't have random garbage pixels = defaultStorage.get(); - memset(pixels, 0, baseLayerSize); + memset(defaultStorage.get(), 0, baseLayerSize); } int width = w; diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h index 79d74d2c09..7ddd4e752d 100644 --- a/src/gpu/gl/GrGLGpu.h +++ b/src/gpu/gl/GrGLGpu.h @@ -145,9 +145,8 @@ public: int width, int height) override; #if GR_TEST_UTILS - GrBackendTexture createTestingOnlyBackendTexture(void* pixels, int w, int h, - GrPixelConfig config, - bool isRenderTarget, + GrBackendTexture createTestingOnlyBackendTexture(const void* pixels, int w, int h, + GrPixelConfig config, bool isRenderTarget, GrMipMapped mipMapped) override; bool isTestingOnlyBackendTexture(const GrBackendTexture&) const override; void deleteTestingOnlyBackendTexture(const GrBackendTexture&) override; diff --git a/src/gpu/mock/GrMockGpu.cpp b/src/gpu/mock/GrMockGpu.cpp index b1c3e7dd7d..4b786ab9b2 100644 --- a/src/gpu/mock/GrMockGpu.cpp +++ b/src/gpu/mock/GrMockGpu.cpp @@ -181,7 +181,7 @@ GrStencilAttachment* GrMockGpu::createStencilAttachmentForRenderTarget(const GrR } #if GR_TEST_UTILS -GrBackendTexture GrMockGpu::createTestingOnlyBackendTexture(void* pixels, int w, int h, +GrBackendTexture GrMockGpu::createTestingOnlyBackendTexture(const void* pixels, int w, int h, GrPixelConfig config, bool isRT, GrMipMapped mipMapped) { GrMockTextureInfo info; diff --git a/src/gpu/mock/GrMockGpu.h b/src/gpu/mock/GrMockGpu.h index f0d7c07deb..8a3dc3045b 100644 --- a/src/gpu/mock/GrMockGpu.h +++ b/src/gpu/mock/GrMockGpu.h @@ -114,8 +114,9 @@ private: void clearStencil(GrRenderTarget*, int clearValue) override {} #if GR_TEST_UTILS - GrBackendTexture createTestingOnlyBackendTexture(void* pixels, int w, int h, GrPixelConfig, - bool isRT, GrMipMapped) override; + GrBackendTexture createTestingOnlyBackendTexture(const void* pixels, int w, int h, + GrPixelConfig, bool isRT, + GrMipMapped) override; bool isTestingOnlyBackendTexture(const GrBackendTexture&) const override; void deleteTestingOnlyBackendTexture(const GrBackendTexture&) override; diff --git a/src/gpu/mtl/GrMtlGpu.h b/src/gpu/mtl/GrMtlGpu.h index 1babc8218e..4729e6e6be 100644 --- a/src/gpu/mtl/GrMtlGpu.h +++ b/src/gpu/mtl/GrMtlGpu.h @@ -138,7 +138,7 @@ private: void clearStencil(GrRenderTarget* target, int clearValue) override {} #if GR_TEST_UTILS - GrBackendTexture createTestingOnlyBackendTexture(void* pixels, int w, int h, + GrBackendTexture createTestingOnlyBackendTexture(const void* pixels, int w, int h, GrPixelConfig config, bool isRT, GrMipMapped) override { return GrBackendTexture(); diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp index 73787bf29b..5e6473e3a4 100644 --- a/src/gpu/vk/GrVkGpu.cpp +++ b/src/gpu/vk/GrVkGpu.cpp @@ -1131,8 +1131,8 @@ GrStencilAttachment* GrVkGpu::createStencilAttachmentForRenderTarget(const GrRen //////////////////////////////////////////////////////////////////////////////// -bool copy_testing_data(GrVkGpu* gpu, void* srcData, const GrVkAlloc& alloc, size_t bufferOffset, - size_t srcRowBytes, size_t dstRowBytes, int h) { +bool copy_testing_data(GrVkGpu* gpu, const void* srcData, const GrVkAlloc& alloc, + size_t bufferOffset, size_t srcRowBytes, size_t dstRowBytes, int h) { // For Noncoherent buffers we want to make sure the range that we map, both offset and size, // are aligned to the nonCoherentAtomSize limit. We may have to move the initial offset back to // meet the alignment requirements. So we track how far we move back and then adjust the mapped @@ -1184,33 +1184,39 @@ bool copy_testing_data(GrVkGpu* gpu, void* srcData, const GrVkAlloc& alloc, size } #if GR_TEST_UTILS -GrBackendTexture GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, int h, - GrPixelConfig config, - bool isRenderTarget, - GrMipMapped mipMapped) { - +bool GrVkGpu::createTestingOnlyVkImage(GrPixelConfig config, int w, int h, bool texturable, + bool renderable, GrMipMapped mipMapped, const void* srcData, + GrVkImageInfo* info) { + SkASSERT(texturable || renderable); + if (!texturable) { + SkASSERT(GrMipMapped::kNo == mipMapped); + SkASSERT(!srcData); + } VkFormat pixelFormat; if (!GrPixelConfigToVkFormat(config, &pixelFormat)) { - return GrBackendTexture(); // invalid + return false; } - if (!fVkCaps->isConfigTexturable(config)) { - return GrBackendTexture(); // invalid + if (texturable && !fVkCaps->isConfigTexturable(config)) { + return false; } - if (isRenderTarget && !fVkCaps->isConfigRenderable(config)) { - return GrBackendTexture(); // invalid + if (renderable && !fVkCaps->isConfigRenderable(config)) { + return false; } // Currently we don't support uploading pixel data when mipped. if (srcData && GrMipMapped::kYes == mipMapped) { - return GrBackendTexture(); // invalid + return false; } - VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_SAMPLED_BIT; + VkImageUsageFlags usageFlags = 0; usageFlags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; usageFlags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT; - if (isRenderTarget) { + if (texturable) { + usageFlags |= VK_IMAGE_USAGE_SAMPLED_BIT; + } + if (renderable) { usageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; } @@ -1221,7 +1227,7 @@ GrBackendTexture GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, // Create Image VkSampleCountFlagBits vkSamples; if (!GrSampleCountToVkSampleCount(1, &vkSamples)) { - return GrBackendTexture(); // invalid + return false; } // Figure out the number of mip levels. @@ -1248,11 +1254,12 @@ GrBackendTexture GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, initialLayout // initialLayout }; - GR_VK_CALL_ERRCHECK(this->vkInterface(), CreateImage(this->device(), &imageCreateInfo, nullptr, &image)); + GR_VK_CALL_ERRCHECK(this->vkInterface(), + CreateImage(this->device(), &imageCreateInfo, nullptr, &image)); if (!GrVkMemory::AllocAndBindImageMemory(this, image, false, &alloc)) { VK_CALL(DestroyImage(this->device(), image, nullptr)); - return GrBackendTexture(); // invalid + return false; } // We need to declare these early so that we can delete them at the end outside of the if block. @@ -1273,7 +1280,7 @@ GrBackendTexture GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, if (err) { GrVkMemory::FreeImageMemory(this, false, alloc); VK_CALL(DestroyImage(fDevice, image, nullptr)); - return GrBackendTexture(); // invalid + return false; } VkCommandBufferBeginInfo cmdBufferBeginInfo; @@ -1328,7 +1335,7 @@ GrBackendTexture GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, VK_CALL(DestroyImage(fDevice, image, nullptr)); VK_CALL(EndCommandBuffer(cmdBuffer)); VK_CALL(FreeCommandBuffers(fDevice, fCmdPool, 1, &cmdBuffer)); - return GrBackendTexture(); // invalid + return false; } if (!GrVkMemory::AllocAndBindBufferMemory(this, buffer, GrVkBuffer::kCopyRead_Type, true, @@ -1338,7 +1345,7 @@ GrBackendTexture GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, VK_CALL(DestroyBuffer(fDevice, buffer, nullptr)); VK_CALL(EndCommandBuffer(cmdBuffer)); VK_CALL(FreeCommandBuffers(fDevice, fCmdPool, 1, &cmdBuffer)); - return GrBackendTexture(); // invalid + return false; } currentWidth = w; @@ -1355,7 +1362,7 @@ GrBackendTexture GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, VK_CALL(DestroyBuffer(fDevice, buffer, nullptr)); VK_CALL(EndCommandBuffer(cmdBuffer)); VK_CALL(FreeCommandBuffers(fDevice, fCmdPool, 1, &cmdBuffer)); - return GrBackendTexture(); // invalid + return false; } currentWidth = SkTMax(1, currentWidth / 2); currentHeight = SkTMax(1, currentHeight / 2); @@ -1401,27 +1408,29 @@ GrBackendTexture GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, VK_CALL(CmdCopyBufferToImage(cmdBuffer, buffer, image, initialLayout, regions.count(), regions.begin())); - // Change Image layout to shader read since if we use this texture as a borrowed textures within - // Ganesh we require that its layout be set to that - memset(&barrier, 0, sizeof(VkImageMemoryBarrier)); - barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; - barrier.pNext = nullptr; - barrier.srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(initialLayout); - barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - barrier.oldLayout = initialLayout; - barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barrier.image = image; - barrier.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, mipLevels, 0 , 1}; - - VK_CALL(CmdPipelineBarrier(cmdBuffer, - GrVkMemory::LayoutToPipelineStageFlags(initialLayout), - VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, - 0, - 0, nullptr, - 0, nullptr, - 1, &barrier)); + if (texturable) { + // Change Image layout to shader read since if we use this texture as a borrowed textures + // within Ganesh we require that its layout be set to that + memset(&barrier, 0, sizeof(VkImageMemoryBarrier)); + barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + barrier.pNext = nullptr; + barrier.srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(initialLayout); + barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; + barrier.oldLayout = initialLayout; + barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.image = image; + barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, mipLevels, 0, 1}; + initialLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + VK_CALL(CmdPipelineBarrier(cmdBuffer, + GrVkMemory::LayoutToPipelineStageFlags(initialLayout), + VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, + 0, + 0, nullptr, + 0, nullptr, + 1, &barrier)); + } // End CommandBuffer err = VK_CALL(EndCommandBuffer(cmdBuffer)); @@ -1471,15 +1480,24 @@ GrBackendTexture GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, VK_CALL(FreeCommandBuffers(fDevice, fCmdPool, 1, &cmdBuffer)); VK_CALL(DestroyFence(fDevice, fence, nullptr)); + info->fImage = image; + info->fAlloc = alloc; + info->fImageTiling = VK_IMAGE_TILING_OPTIMAL; + info->fImageLayout = initialLayout; + info->fFormat = pixelFormat; + info->fLevelCount = mipLevels; + return true; +} + +GrBackendTexture GrVkGpu::createTestingOnlyBackendTexture(const void* srcData, int w, int h, + GrPixelConfig config, bool isRenderTarget, + GrMipMapped mipMapped) { GrVkImageInfo info; - info.fImage = image; - info.fAlloc = alloc; - info.fImageTiling = VK_IMAGE_TILING_OPTIMAL; - info.fImageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - info.fFormat = pixelFormat; - info.fLevelCount = mipLevels; - + if (!this->createTestingOnlyVkImage(config, w, h, true, isRenderTarget, mipMapped, srcData, + &info)) { + return {}; + } return GrBackendTexture(w, h, info); } @@ -1512,13 +1530,29 @@ void GrVkGpu::deleteTestingOnlyBackendTexture(const GrBackendTexture& tex) { } } -GrBackendRenderTarget GrVkGpu::createTestingOnlyBackendRenderTarget(int w, int h, GrColorType, - GrSRGBEncoded) { - return GrBackendRenderTarget(); +GrBackendRenderTarget GrVkGpu::createTestingOnlyBackendRenderTarget(int w, int h, GrColorType ct, + GrSRGBEncoded srgbEncoded) { + GrVkImageInfo info; + auto config = GrColorTypeToPixelConfig(ct, srgbEncoded); + if (kUnknown_GrPixelConfig == config) { + return {}; + } + if (!this->createTestingOnlyVkImage(config, w, h, false, true, GrMipMapped::kNo, nullptr, + &info)) { + return {}; + } + return {w, h, 1, 0, info}; } -void GrVkGpu::deleteTestingOnlyBackendRenderTarget(const GrBackendRenderTarget&) {} +void GrVkGpu::deleteTestingOnlyBackendRenderTarget(const GrBackendRenderTarget& rt) { + SkASSERT(kVulkan_GrBackend == rt.fBackend); + if (const auto* info = rt.getVkImageInfo()) { + // something in the command buffer may still be using this, so force submit + this->submitCommandBuffer(kForce_SyncQueue); + GrVkImage::DestroyImageInfo(this, const_cast(info)); + } +} void GrVkGpu::testingOnly_flushGpuAndSync() { this->submitCommandBuffer(kForce_SyncQueue); diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h index b5ddcb894a..6eac5c8086 100644 --- a/src/gpu/vk/GrVkGpu.h +++ b/src/gpu/vk/GrVkGpu.h @@ -70,9 +70,8 @@ public: void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {} #if GR_TEST_UTILS - GrBackendTexture createTestingOnlyBackendTexture(void* pixels, int w, int h, - GrPixelConfig config, - bool isRenderTarget, + GrBackendTexture createTestingOnlyBackendTexture(const void* pixels, int w, int h, + GrPixelConfig config, bool isRenderTarget, GrMipMapped) override; bool isTestingOnlyBackendTexture(const GrBackendTexture&) const override; void deleteTestingOnlyBackendTexture(const GrBackendTexture&) override; @@ -247,6 +246,12 @@ private: void resolveImage(GrSurface* dst, GrVkRenderTarget* src, const SkIRect& srcRect, const SkIPoint& dstPoint); +#if GR_TEST_UTILS + bool createTestingOnlyVkImage(GrPixelConfig config, int w, int h, bool texturable, + bool renderable, GrMipMapped mipMapped, const void* srcData, + GrVkImageInfo* info); +#endif + sk_sp fBackendContext; sk_sp fVkCaps; diff --git a/tests/ProxyConversionTest.cpp b/tests/ProxyConversionTest.cpp index 3ebfbf4778..7103403d43 100644 --- a/tests/ProxyConversionTest.cpp +++ b/tests/ProxyConversionTest.cpp @@ -12,6 +12,7 @@ #if SK_SUPPORT_GPU #include "GrBackendSurface.h" #include "GrContextPriv.h" +#include "GrGpu.h" #include "GrProxyProvider.h" #include "GrRenderTarget.h" #include "GrRenderTargetProxy.h" @@ -19,36 +20,46 @@ #include "GrTexture.h" #include "GrTextureProxy.h" -static sk_sp make_wrapped_FBO0(GrProxyProvider* provider, - skiatest::Reporter* reporter, - const GrSurfaceDesc& desc, - GrSurfaceOrigin origin) { - GrGLFramebufferInfo fboInfo; - fboInfo.fFBOID = 0; - GrBackendRenderTarget backendRT(desc.fWidth, desc.fHeight, desc.fSampleCnt, 8, - desc.fConfig, fboInfo); - +static sk_sp make_wrapped_rt(GrProxyProvider* provider, + GrGpu* gpu, + skiatest::Reporter* reporter, + const GrSurfaceDesc& desc, + GrSurfaceOrigin origin) { + // We don't currently have a way of making MSAA backend render targets. + SkASSERT(1 == desc.fSampleCnt); + GrSRGBEncoded srgbEncoded; + auto ct = GrPixelConfigToColorTypeAndEncoding(desc.fConfig, &srgbEncoded); + auto backendRT = gpu->createTestingOnlyBackendRenderTarget(desc.fWidth, desc.fHeight, ct, + GrSRGBEncoded::kNo); return provider->wrapBackendRenderTarget(backendRT, origin); } -static sk_sp make_wrapped_offscreen_rt(GrProxyProvider* provider, - const GrSurfaceDesc& desc, - GrSurfaceOrigin origin) { +void clean_up_wrapped_rt(GrGpu* gpu, sk_sp proxy) { + SkASSERT(proxy->isUnique_debugOnly()); + SkASSERT(proxy->priv().peekRenderTarget()); + GrBackendRenderTarget rt = proxy->priv().peekRenderTarget()->getBackendRenderTarget(); + proxy.reset(); + gpu->deleteTestingOnlyBackendRenderTarget(rt); +} + +static sk_sp make_offscreen_rt(GrProxyProvider* provider, + const GrSurfaceDesc& desc, + GrSurfaceOrigin origin) { SkASSERT(kRenderTarget_GrSurfaceFlag == desc.fFlags); return provider->createInstantiatedProxy(desc, origin, SkBackingFit::kExact, SkBudgeted::kYes); } -static sk_sp make_wrapped_texture(GrProxyProvider* provider, - const GrSurfaceDesc& desc, - GrSurfaceOrigin origin) { +static sk_sp make_texture(GrProxyProvider* provider, + const GrSurfaceDesc& desc, + GrSurfaceOrigin origin) { return provider->createInstantiatedProxy(desc, origin, SkBackingFit::kExact, SkBudgeted::kYes); } -// Test converting between RenderTargetProxies and TextureProxies for wrapped -// Proxies -DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo) { +// Test converting between RenderTargetProxies and TextureProxies for preinstantiated Proxies +DEF_GPUTEST_FOR_RENDERING_CONTEXTS(PreinstantiatedProxyConversionTest, reporter, ctxInfo) { GrProxyProvider* proxyProvider = ctxInfo.grContext()->contextPriv().proxyProvider(); + GrGpu* gpu = ctxInfo.grContext()->contextPriv().getGpu(); GrSurfaceDesc desc; desc.fFlags = kRenderTarget_GrSurfaceFlag; @@ -56,23 +67,24 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo desc.fHeight = 64; desc.fConfig = kRGBA_8888_GrPixelConfig; - if (kOpenGL_GrBackend == ctxInfo.backend()) { + { // External on-screen render target. sk_sp sProxy( - make_wrapped_FBO0(proxyProvider, reporter, desc, kBottomLeft_GrSurfaceOrigin)); + make_wrapped_rt(proxyProvider, gpu, reporter, desc, kBottomLeft_GrSurfaceOrigin)); if (sProxy) { // RenderTarget-only GrRenderTargetProxy* rtProxy = sProxy->asRenderTargetProxy(); REPORTER_ASSERT(reporter, rtProxy); REPORTER_ASSERT(reporter, !rtProxy->asTextureProxy()); REPORTER_ASSERT(reporter, rtProxy->asRenderTargetProxy() == rtProxy); + clean_up_wrapped_rt(gpu, std::move(sProxy)); } } { // Internal offscreen render target. sk_sp sProxy( - make_wrapped_offscreen_rt(proxyProvider, desc, kBottomLeft_GrSurfaceOrigin)); + make_offscreen_rt(proxyProvider, desc, kBottomLeft_GrSurfaceOrigin)); if (sProxy) { // Both RenderTarget and Texture GrRenderTargetProxy* rtProxy = sProxy->asRenderTargetProxy(); @@ -87,7 +99,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo { // Internal offscreen render target - but through GrTextureProxy sk_sp sProxy( - make_wrapped_texture(proxyProvider, desc, kBottomLeft_GrSurfaceOrigin)); + make_texture(proxyProvider, desc, kBottomLeft_GrSurfaceOrigin)); if (sProxy) { // Both RenderTarget and Texture GrTextureProxy* tProxy = sProxy->asTextureProxy(); @@ -103,7 +115,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo desc.fFlags = kNone_GrSurfaceFlags; // force no-RT sk_sp sProxy( - make_wrapped_texture(proxyProvider, desc, kBottomLeft_GrSurfaceOrigin)); + make_texture(proxyProvider, desc, kBottomLeft_GrSurfaceOrigin)); if (sProxy) { // Texture-only GrTextureProxy* tProxy = sProxy->asTextureProxy(); diff --git a/tests/ProxyTest.cpp b/tests/ProxyTest.cpp index 911c430dc1..4970e43a20 100644 --- a/tests/ProxyTest.cpp +++ b/tests/ProxyTest.cpp @@ -201,12 +201,28 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) { static const int kWidthHeight = 100; - if (kOpenGL_GrBackend != ctxInfo.backend()) { - return; - } for (auto origin : { kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin }) { for (auto colorType : { kAlpha_8_SkColorType, kRGBA_8888_SkColorType, kRGBA_1010102_SkColorType }) { + // External on-screen render target. + // Tests wrapBackendRenderTarget with a GrBackendRenderTarget + // Our test-only function that creates a backend render target doesn't currently support + // sample counts :(. + if (ctxInfo.grContext()->colorTypeSupportedAsSurface(colorType)) { + GrBackendRenderTarget backendRT = gpu->createTestingOnlyBackendRenderTarget( + kWidthHeight, kWidthHeight, SkColorTypeToGrColorType(colorType), + GrSRGBEncoded::kNo); + sk_sp sProxy( + proxyProvider->wrapBackendRenderTarget(backendRT, origin)); + check_surface(reporter, sProxy.get(), origin, kWidthHeight, kWidthHeight, + backendRT.testingOnly_getPixelConfig(), SkBudgeted::kNo); + static constexpr int kExpectedNumSamples = 1; + check_rendertarget(reporter, caps, resourceProvider, sProxy->asRenderTargetProxy(), + kExpectedNumSamples, SkBackingFit::kExact, + caps.maxWindowRectangles()); + gpu->deleteTestingOnlyBackendRenderTarget(backendRT); + } + for (auto numSamples : {1, 4}) { GrPixelConfig config = SkImageInfo2GrPixelConfig(colorType, nullptr, caps); SkASSERT(kUnknown_GrPixelConfig != config); @@ -216,14 +232,14 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) { continue; } - // External on-screen render target. - // Tests wrapBackendRenderTarget with a GrBackendRenderTarget - { + // Test wrapping FBO 0 (with made up properties). This tests sample count and the + // special case where FBO 0 doesn't support window rectangles. + if (kOpenGL_GrBackend == ctxInfo.backend()) { GrGLFramebufferInfo fboInfo; fboInfo.fFBOID = 0; - GrBackendRenderTarget backendRT(kWidthHeight, kWidthHeight, numSamples, 8, - config, fboInfo); - + static constexpr int kStencilBits = 8; + GrBackendRenderTarget backendRT(kWidthHeight, kWidthHeight, numSamples, + kStencilBits, config, fboInfo); sk_sp sProxy( proxyProvider->wrapBackendRenderTarget(backendRT, origin)); check_surface(reporter, sProxy.get(), origin, diff --git a/tools/flags/SkCommonFlagsConfig.cpp b/tools/flags/SkCommonFlagsConfig.cpp index bb53c2d64e..b8fd4190a6 100644 --- a/tools/flags/SkCommonFlagsConfig.cpp +++ b/tools/flags/SkCommonFlagsConfig.cpp @@ -89,6 +89,8 @@ static const struct { ,{ "vkwide", "gpu", "api=vulkan,color=f16_wide" } ,{ "vkmsaa4", "gpu", "api=vulkan,samples=4" } ,{ "vkmsaa8", "gpu", "api=vulkan,samples=8" } + ,{ "vkbetex", "gpu", "api=vulkan,surf=betex" } + ,{ "vkbert", "gpu", "api=vulkan,surf=bert" } #endif #ifdef SK_METAL ,{ "mtl", "gpu", "api=metal" } diff --git a/tools/gpu/GrTest.cpp b/tools/gpu/GrTest.cpp index e33e2dd5c7..e1a7924062 100644 --- a/tools/gpu/GrTest.cpp +++ b/tools/gpu/GrTest.cpp @@ -212,7 +212,7 @@ void GrGpu::Stats::dumpKeyValuePairs(SkTArray* keys, SkTArray* #endif -GrBackendTexture GrGpu::createTestingOnlyBackendTexture(void* pixels, int w, int h, +GrBackendTexture GrGpu::createTestingOnlyBackendTexture(const void* pixels, int w, int h, SkColorType colorType, bool isRenderTarget, GrMipMapped mipMapped) { GrPixelConfig config = SkImageInfo2GrPixelConfig(colorType, nullptr, *this->caps());