From e3bd422fafc74dd3410c3de24a576635be92c3b4 Mon Sep 17 00:00:00 2001 From: Greg Daniel Date: Thu, 27 Apr 2017 18:48:15 +0000 Subject: Revert "Plumb the use of GrBackendRenderTarget throughout Skia" This reverts commit fdd77daedbba3b7c53be74a82fb9fae891b51696. Reason for revert: Apparently I have a few more build files to update before this can land. Original change's description: > Plumb the use of GrBackendRenderTarget throughout Skia > > Bug: skia: > Change-Id: Ib99a58d9552f5c7b8d77c09dcc72fa88326c26aa > Reviewed-on: https://skia-review.googlesource.com/14148 > Reviewed-by: Brian Salomon > Reviewed-by: Robert Phillips > Commit-Queue: Greg Daniel > TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true Change-Id: I984e1909870182474c4c3cce257f01b6a9d8581f Reviewed-on: https://skia-review.googlesource.com/14531 Reviewed-by: Greg Daniel Commit-Queue: Greg Daniel --- example/SkiaSDLExample.cpp | 18 ++++++++--------- include/gpu/GrBackendSurface.h | 24 ++++++++++++++--------- include/gpu/gl/GrGLTypes.h | 6 ------ include/gpu/vk/GrVkDefines.h | 4 ++-- src/gpu/GrBackendSurface.cpp | 31 ++++++++++++------------------ src/gpu/GrContext.cpp | 6 ++---- src/gpu/GrContextPriv.h | 4 +--- src/gpu/GrGpu.cpp | 7 +++---- src/gpu/GrGpu.h | 6 ++---- src/gpu/GrResourceProvider.cpp | 4 ++-- src/gpu/GrResourceProvider.h | 3 +-- src/gpu/gl/GrGLGpu.cpp | 34 ++++++++++++++++++--------------- src/gpu/gl/GrGLGpu.h | 3 +-- src/gpu/vk/GrVkGpu.cpp | 25 +++++++++--------------- src/gpu/vk/GrVkGpu.h | 3 +-- src/image/SkSurface_Gpu.cpp | 33 +++++++++++++------------------- src/views/SkWindow.cpp | 34 ++++++++++++++------------------- tests/ProxyConversionTest.cpp | 18 +++++++++-------- tests/ProxyTest.cpp | 17 ++++++++++------- tests/VkWrapTests.cpp | 20 ++++++++++++------- tools/gpu/GrTest.cpp | 3 +-- tools/viewer/sk_app/GLWindowContext.cpp | 34 ++++++++++++++++----------------- 22 files changed, 156 insertions(+), 181 deletions(-) diff --git a/example/SkiaSDLExample.cpp b/example/SkiaSDLExample.cpp index f3be85045e..abd198afe9 100644 --- a/example/SkiaSDLExample.cpp +++ b/example/SkiaSDLExample.cpp @@ -6,7 +6,6 @@ * */ -#include "GrBackendSurface.h" #include "GrContext.h" #include "SDL.h" #include "SkCanvas.h" @@ -193,12 +192,16 @@ int main(int argc, char** argv) { // Wrap the frame buffer object attached to the screen in a Skia render target so Skia can // render to it - GrGLFrameBufferInfo fbInfo; + GrBackendRenderTargetDesc desc; + desc.fWidth = dm.w; + desc.fHeight = dm.h; + desc.fConfig = kSkia8888_GrPixelConfig; + desc.fOrigin = kBottomLeft_GrSurfaceOrigin; + desc.fSampleCnt = kMsaaSampleCount; + desc.fStencilBits = kStencilBits; GrGLint buffer; GR_GL_GetIntegerv(interface, GR_GL_FRAMEBUFFER_BINDING, &buffer); - fbInfo.fFBOID = buffer; - GrBackendRenderTarget backendRT(dm.w, dm.h, kMsaaSampleCount, kStencilBits, - kSkia8888_GrPixelConfig, fbInfo); + desc.fRenderTargetHandle = buffer; // setup SkSurface // To use distance field text, use commented out SkSurfaceProps instead @@ -206,10 +209,7 @@ int main(int argc, char** argv) { // SkSurfaceProps::kLegacyFontHost_InitType); SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType); - sk_sp surface(SkSurface::MakeFromBackendRenderTarget(grContext, - backendRT, - kBottomLeft_GrSurfaceOrigin, - &props)); + sk_sp surface(SkSurface::MakeFromBackendRenderTarget(grContext, desc, &props)); SkCanvas* canvas = surface->getCanvas(); diff --git a/include/gpu/GrBackendSurface.h b/include/gpu/GrBackendSurface.h index d9302dafc2..fd99a4312a 100644 --- a/include/gpu/GrBackendSurface.h +++ b/include/gpu/GrBackendSurface.h @@ -9,8 +9,9 @@ #define GrBackendSurface_DEFINED #include "GrTypes.h" -#include "gl/GrGLTypes.h" -#include "vk/GrVkTypes.h" + +struct GrVkImageInfo; +struct GrGLTextureInfo; class GrBackendTexture { public: @@ -62,18 +63,22 @@ private: class GrBackendRenderTarget { public: + // The passed in GrVkImageInfo must live until the GrBackendTexture is no longer used in + // creation of SkImages or SkSurfaces. GrBackendRenderTarget(int width, int height, int sampleCnt, int stencilBits, - const GrVkImageInfo& vkInfo); + const GrVkImageInfo* vkInfo); + // The passed in GrGLTextureInfo must live until the GrBackendTexture is no longer used in + // creation of SkImages or SkSurfaces. GrBackendRenderTarget(int width, int height, int sampleCnt, int stencilBits, GrPixelConfig config, - const GrGLFramebufferInfo& glInfo); + const GrGLTextureInfo* glInfo); int width() const { return fWidth; } int height() const { return fHeight; } @@ -83,12 +88,12 @@ public: GrBackend backend() const {return fBackend; } // If the backend API is Vulkan, this returns a pointer to the GrVkImageInfo struct. Otherwise - // it returns nullptr + // it returns nullptr. const GrVkImageInfo* getVkImageInfo() const; - // If the backend API is GL, this returns a pointer to the GrGLFramebufferInfo struct. Otherwise + // If the backend API is GL, this returns a pointer to the GrGLTextureInfo struct. Otherwise // it returns nullptr. - const GrGLFramebufferInfo* getGLFramebufferInfo() const; + const GrGLTextureInfo* getGLTextureInfo() const; private: // Temporary constructor which can be used to convert from a GrBackendRenderTargetDesc. @@ -107,8 +112,9 @@ private: GrBackend fBackend; union { - GrVkImageInfo fVkInfo; - GrGLFramebufferInfo fGLInfo; + const GrVkImageInfo* fVkInfo; + const GrGLTextureInfo* fGLInfo; + GrBackendObject fHandle; }; }; diff --git a/include/gpu/gl/GrGLTypes.h b/include/gpu/gl/GrGLTypes.h index 345364b050..f2b339eccc 100644 --- a/include/gpu/gl/GrGLTypes.h +++ b/include/gpu/gl/GrGLTypes.h @@ -135,10 +135,4 @@ protected: GR_STATIC_ASSERT(sizeof(GrBackendObject) >= sizeof(const GrGLTextureInfo*)); -struct GrGLFramebufferInfo { - GrGLuint fFBOID; -}; - -GR_STATIC_ASSERT(sizeof(GrBackendObject) >= sizeof(const GrGLFramebufferInfo*)); - #endif diff --git a/include/gpu/vk/GrVkDefines.h b/include/gpu/vk/GrVkDefines.h index 7defed2ad5..7b9ee8dadf 100644 --- a/include/gpu/vk/GrVkDefines.h +++ b/include/gpu/vk/GrVkDefines.h @@ -9,8 +9,6 @@ #ifndef GrVkDefines_DEFINED #define GrVkDefines_DEFINED -#ifdef SK_VULKAN - #if defined(SK_BUILD_FOR_WIN) || defined(SK_BUILD_FOR_WIN32) # if !defined(VK_USE_PLATFORM_WIN32_KHR) # define VK_USE_PLATFORM_WIN32_KHR @@ -31,6 +29,8 @@ # endif #endif +#if defined(Bool) || defined(Status) || defined(True) || defined(False) +# pragma error "Macros unexpectedly defined." #endif #include diff --git a/src/gpu/GrBackendSurface.cpp b/src/gpu/GrBackendSurface.cpp index 6a1448e17c..97b3b6ee03 100644 --- a/src/gpu/GrBackendSurface.cpp +++ b/src/gpu/GrBackendSurface.cpp @@ -70,14 +70,14 @@ GrBackendRenderTarget::GrBackendRenderTarget(int width, int height, int sampleCnt, int stencilBits, - const GrVkImageInfo& vkInfo) + const GrVkImageInfo* vkInfo) : fWidth(width) , fHeight(height) , fSampleCnt(sampleCnt) , fStencilBits(stencilBits) , fConfig( #ifdef SK_VULKAN - GrVkFormatToPixelConfig(vkInfo.fFormat) + GrVkFormatToPixelConfig(vkInfo->fFormat) #else kUnknown_GrPixelConfig #endif @@ -90,7 +90,7 @@ GrBackendRenderTarget::GrBackendRenderTarget(int width, int sampleCnt, int stencilBits, GrPixelConfig config, - const GrGLFramebufferInfo& glInfo) + const GrGLTextureInfo* glInfo) : fWidth(width) , fHeight(height) , fSampleCnt(sampleCnt) @@ -105,33 +105,26 @@ GrBackendRenderTarget::GrBackendRenderTarget(const GrBackendRenderTargetDesc& de , fHeight(desc.fHeight) , fSampleCnt(desc.fSampleCnt) , fStencilBits(desc.fStencilBits) - , fConfig(desc.fConfig) - , fBackend(backend) { - if (kOpenGL_GrBackend == backend) { - fGLInfo = *reinterpret_cast(desc.fRenderTargetHandle); - } else { - SkASSERT(kVulkan_GrBackend == backend); + , fConfig(kVulkan_GrBackend == backend #ifdef SK_VULKAN - const GrVkImageInfo* vkInfo = - reinterpret_cast(desc.fRenderTargetHandle); - fConfig = GrVkFormatToPixelConfig(vkInfo->fFormat); - fVkInfo = *vkInfo; + ? GrVkFormatToPixelConfig(((GrVkImageInfo*)desc.fRenderTargetHandle)->fFormat) #else - fConfig = kUnknown_GrPixelConfig; + ? kUnknown_GrPixelConfig #endif - } -} + : desc.fConfig) + , fBackend(backend) + , fHandle(desc.fRenderTargetHandle) {} const GrVkImageInfo* GrBackendRenderTarget::getVkImageInfo() const { if (kVulkan_GrBackend == fBackend) { - return &fVkInfo; + return fVkInfo; } return nullptr; } -const GrGLFramebufferInfo* GrBackendRenderTarget::getGLFramebufferInfo() const { +const GrGLTextureInfo* GrBackendRenderTarget::getGLTextureInfo() const { if (kOpenGL_GrBackend == fBackend) { - return &fGLInfo; + return fGLInfo; } return nullptr; } diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp index aa245b5672..a2f227226d 100644 --- a/src/gpu/GrContext.cpp +++ b/src/gpu/GrContext.cpp @@ -702,14 +702,12 @@ sk_sp GrContextPriv::makeBackendTextureRenderTargetContex } sk_sp GrContextPriv::makeBackendRenderTargetRenderTargetContext( - const GrBackendRenderTarget& backendRT, - GrSurfaceOrigin origin, + const GrBackendRenderTargetDesc& desc, sk_sp colorSpace, const SkSurfaceProps* surfaceProps) { ASSERT_SINGLE_OWNER_PRIV - sk_sp rt(fContext->resourceProvider()->wrapBackendRenderTarget(backendRT, - origin)); + sk_sp rt(fContext->resourceProvider()->wrapBackendRenderTarget(desc)); if (!rt) { return nullptr; } diff --git a/src/gpu/GrContextPriv.h b/src/gpu/GrContextPriv.h index 08b26e56d5..c85ac2c9b6 100644 --- a/src/gpu/GrContextPriv.h +++ b/src/gpu/GrContextPriv.h @@ -11,7 +11,6 @@ #include "GrContext.h" #include "GrSurfaceContext.h" -class GrBackendRenderTarget; class GrSemaphore; class GrSurfaceProxy; class GrPreFlushCallbackObject; @@ -53,8 +52,7 @@ public: const SkSurfaceProps* = nullptr); sk_sp makeBackendRenderTargetRenderTargetContext( - const GrBackendRenderTarget&, - GrSurfaceOrigin origin, + const GrBackendRenderTargetDesc& desc, sk_sp colorSpace, const SkSurfaceProps* = nullptr); diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp index 5ce8274215..4bf0c87bf1 100644 --- a/src/gpu/GrGpu.cpp +++ b/src/gpu/GrGpu.cpp @@ -223,13 +223,12 @@ sk_sp GrGpu::wrapBackendTexture(const GrBackendTexture& backendTex, return tex; } -sk_sp GrGpu::wrapBackendRenderTarget(const GrBackendRenderTarget& backendRT, - GrSurfaceOrigin origin) { - if (!this->caps()->isConfigRenderable(backendRT.config(), backendRT.sampleCnt() > 0)) { +sk_sp GrGpu::wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc) { + if (!this->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) { return nullptr; } this->handleDirtyContext(); - return this->onWrapBackendRenderTarget(backendRT, origin); + return this->onWrapBackendRenderTarget(desc); } sk_sp GrGpu::wrapBackendTextureAsRenderTarget(const GrBackendTexture& tex, diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h index 000b32421b..523add5cb7 100644 --- a/src/gpu/GrGpu.h +++ b/src/gpu/GrGpu.h @@ -20,7 +20,6 @@ #include "SkTArray.h" #include -class GrBackendRenderTarget; class GrBuffer; class GrContext; struct GrContextOptions; @@ -136,7 +135,7 @@ public: /** * Implements GrResourceProvider::wrapBackendRenderTarget */ - sk_sp wrapBackendRenderTarget(const GrBackendRenderTarget&, GrSurfaceOrigin); + sk_sp wrapBackendRenderTarget(const GrBackendRenderTargetDesc&); /** * Implements GrResourceProvider::wrapBackendTextureAsRenderTarget @@ -557,8 +556,7 @@ private: GrBackendTextureFlags, int sampleCnt, GrWrapOwnership) = 0; - virtual sk_sp onWrapBackendRenderTarget(const GrBackendRenderTarget&, - GrSurfaceOrigin) = 0; + virtual sk_sp onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) = 0; virtual sk_sp onWrapBackendTextureAsRenderTarget(const GrBackendTexture&, GrSurfaceOrigin, int sampleCnt)=0; diff --git a/src/gpu/GrResourceProvider.cpp b/src/gpu/GrResourceProvider.cpp index d7b90873ed..a250f6826f 100644 --- a/src/gpu/GrResourceProvider.cpp +++ b/src/gpu/GrResourceProvider.cpp @@ -254,10 +254,10 @@ sk_sp GrResourceProvider::wrapBackendTexture(const GrBackendTexture& } sk_sp GrResourceProvider::wrapBackendRenderTarget( - const GrBackendRenderTarget& backendRT, GrSurfaceOrigin origin) + const GrBackendRenderTargetDesc& desc) { ASSERT_SINGLE_OWNER - return this->isAbandoned() ? nullptr : fGpu->wrapBackendRenderTarget(backendRT, origin); + return this->isAbandoned() ? nullptr : fGpu->wrapBackendRenderTarget(desc); } void GrResourceProvider::assignUniqueKeyToResource(const GrUniqueKey& key, diff --git a/src/gpu/GrResourceProvider.h b/src/gpu/GrResourceProvider.h index e22a0d8428..c3d96ff803 100644 --- a/src/gpu/GrResourceProvider.h +++ b/src/gpu/GrResourceProvider.h @@ -12,7 +12,6 @@ #include "GrGpu.h" #include "GrPathRange.h" -class GrBackendRenderTarget; class GrPath; class GrRenderTarget; class GrSingleOwner; @@ -101,7 +100,7 @@ public: * * @return GrRenderTarget object or NULL on failure. */ - sk_sp wrapBackendRenderTarget(const GrBackendRenderTarget&, GrSurfaceOrigin); + sk_sp wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc); static const int kMinScratchTextureSize; diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp index 646524a8e7..da3ec49a29 100644 --- a/src/gpu/gl/GrGLGpu.cpp +++ b/src/gpu/gl/GrGLGpu.cpp @@ -504,6 +504,17 @@ void GrGLGpu::onResetContext(uint32_t resetBits) { } } +static GrSurfaceOrigin resolve_origin(GrSurfaceOrigin origin, bool renderTarget) { + // By default, GrRenderTargets are GL's normal orientation so that they + // can be drawn to by the outside world without the client having + // to render upside down. + if (kDefault_GrSurfaceOrigin == origin) { + return renderTarget ? kBottomLeft_GrSurfaceOrigin : kTopLeft_GrSurfaceOrigin; + } else { + return origin; + } +} + sk_sp GrGLGpu::onWrapBackendTexture(const GrBackendTexture& backendTex, GrSurfaceOrigin origin, GrBackendTextureFlags flags, @@ -580,30 +591,23 @@ sk_sp GrGLGpu::onWrapBackendTexture(const GrBackendTexture& backendTe } } -sk_sp GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT, - GrSurfaceOrigin origin) { - const GrGLFramebufferInfo* info = backendRT.getGLFramebufferInfo(); - if (!info) { - return nullptr; - } - +sk_sp GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& wrapDesc){ GrGLRenderTarget::IDDesc idDesc; - idDesc.fRTFBOID = info->fFBOID; + idDesc.fRTFBOID = static_cast(wrapDesc.fRenderTargetHandle); idDesc.fMSColorRenderbufferID = 0; idDesc.fTexFBOID = GrGLRenderTarget::kUnresolvableFBOID; idDesc.fRTFBOOwnership = GrBackendObjectOwnership::kBorrowed; idDesc.fIsMixedSampled = false; GrSurfaceDesc desc; - desc.fConfig = backendRT.config(); + desc.fConfig = wrapDesc.fConfig; desc.fFlags = kCheckAllocation_GrSurfaceFlag | kRenderTarget_GrSurfaceFlag; - desc.fWidth = backendRT.width(); - desc.fHeight = backendRT.height(); - desc.fSampleCnt = SkTMin(backendRT.sampleCnt(), this->caps()->maxSampleCount()); - SkASSERT(kDefault_GrSurfaceOrigin != origin); - desc.fOrigin = origin; + desc.fWidth = wrapDesc.fWidth; + desc.fHeight = wrapDesc.fHeight; + desc.fSampleCnt = SkTMin(wrapDesc.fSampleCnt, this->caps()->maxSampleCount()); + desc.fOrigin = resolve_origin(wrapDesc.fOrigin, true); - return GrGLRenderTarget::MakeWrapped(this, desc, idDesc, backendRT.stencilBits()); + return GrGLRenderTarget::MakeWrapped(this, desc, idDesc, wrapDesc.fStencilBits); } sk_sp GrGLGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex, diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h index f74673faf0..f7e75cc2e7 100644 --- a/src/gpu/gl/GrGLGpu.h +++ b/src/gpu/gl/GrGLGpu.h @@ -176,8 +176,7 @@ private: GrBackendTextureFlags, int sampleCnt, GrWrapOwnership) override; - sk_sp onWrapBackendRenderTarget(const GrBackendRenderTarget&, - GrSurfaceOrigin origin) override; + sk_sp onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) override; sk_sp onWrapBackendTextureAsRenderTarget(const GrBackendTexture&, GrSurfaceOrigin, int sampleCnt) override; diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp index 1eec506a42..be5b0c7f49 100644 --- a/src/gpu/vk/GrVkGpu.cpp +++ b/src/gpu/vk/GrVkGpu.cpp @@ -815,36 +815,32 @@ sk_sp GrVkGpu::onWrapBackendTexture(const GrBackendTexture& backendTe return GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(this, surfDesc, ownership, info); } -sk_sp GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT, - GrSurfaceOrigin origin){ +sk_sp GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& wrapDesc){ // Currently the Vulkan backend does not support wrapping of msaa render targets directly. In // general this is not an issue since swapchain images in vulkan are never multisampled. Thus if // you want a multisampled RT it is best to wrap the swapchain images and then let Skia handle // creating and owning the MSAA images. - if (backendRT.sampleCnt()) { + if (wrapDesc.fSampleCnt) { return nullptr; } - const GrVkImageInfo* info = backendRT.getVkImageInfo(); - if (!info) { - return nullptr; - } + const GrVkImageInfo* info = + reinterpret_cast(wrapDesc.fRenderTargetHandle); if (VK_NULL_HANDLE == info->fImage) { return nullptr; } GrSurfaceDesc desc; - desc.fConfig = backendRT.config(); + desc.fConfig = wrapDesc.fConfig; desc.fFlags = kCheckAllocation_GrSurfaceFlag | kRenderTarget_GrSurfaceFlag; - desc.fWidth = backendRT.width(); - desc.fHeight = backendRT.height(); + desc.fWidth = wrapDesc.fWidth; + desc.fHeight = wrapDesc.fHeight; desc.fSampleCnt = 0; - SkASSERT(kDefault_GrSurfaceOrigin != origin); - desc.fOrigin = origin; + desc.fOrigin = resolve_origin(wrapDesc.fOrigin); sk_sp tgt = GrVkRenderTarget::MakeWrappedRenderTarget(this, desc, info); - if (tgt && backendRT.stencilBits()) { + if (tgt && wrapDesc.fStencilBits) { if (!createStencilAttachmentForRenderTarget(tgt.get(), desc.fWidth, desc.fHeight)) { return nullptr; } @@ -857,9 +853,6 @@ sk_sp GrVkGpu::onWrapBackendTextureAsRenderTarget(const GrBacken int sampleCnt) { const GrVkImageInfo* info = tex.getVkImageInfo(); - if (!info) { - return nullptr; - } if (VK_NULL_HANDLE == info->fImage) { return nullptr; } diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h index 6ae34bd105..d3e155581e 100644 --- a/src/gpu/vk/GrVkGpu.h +++ b/src/gpu/vk/GrVkGpu.h @@ -180,8 +180,7 @@ private: GrBackendTextureFlags, int sampleCnt, GrWrapOwnership) override; - sk_sp onWrapBackendRenderTarget(const GrBackendRenderTarget&, - GrSurfaceOrigin) override; + sk_sp onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) override; sk_sp onWrapBackendTextureAsRenderTarget(const GrBackendTexture&, GrSurfaceOrigin, diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp index 5001811cea..96ac31e16c 100644 --- a/src/image/SkSurface_Gpu.cpp +++ b/src/image/SkSurface_Gpu.cpp @@ -261,36 +261,19 @@ sk_sp SkSurface::MakeFromBackendRenderTarget(GrContext* context, if (!context) { return nullptr; } - - GrBackendRenderTarget backendRT(desc, context->contextPriv().getBackend()); - return MakeFromBackendRenderTarget(context, backendRT, desc.fOrigin, - std::move(colorSpace), props); - -} - -sk_sp SkSurface::MakeFromBackendRenderTarget(GrContext* context, - const GrBackendRenderTarget& backendRT, - GrSurfaceOrigin origin, - sk_sp colorSpace, - const SkSurfaceProps* props) { - if (!context) { - return nullptr; - } - if (!SkSurface_Gpu::Valid(context, backendRT.config(), colorSpace.get())) { + if (!SkSurface_Gpu::Valid(context, desc.fConfig, colorSpace.get())) { return nullptr; } sk_sp rtc( - context->contextPriv().makeBackendRenderTargetRenderTargetContext(backendRT, - origin, + context->contextPriv().makeBackendRenderTargetRenderTargetContext(desc, std::move(colorSpace), props)); if (!rtc) { return nullptr; } - sk_sp device(SkGpuDevice::Make(context, std::move(rtc), - backendRT.width(), backendRT.height(), + sk_sp device(SkGpuDevice::Make(context, std::move(rtc), desc.fWidth, desc.fHeight, SkGpuDevice::kUninit_InitContents)); if (!device) { return nullptr; @@ -299,6 +282,16 @@ sk_sp SkSurface::MakeFromBackendRenderTarget(GrContext* context, return sk_make_sp(std::move(device)); } +sk_sp SkSurface::MakeFromBackendRenderTarget(GrContext*, + const GrBackendRenderTarget&, + GrSurfaceOrigin origin, + sk_sp, + const SkSurfaceProps*) { + // This function is not implemented yet + sk_throw(); + return nullptr; +} + sk_sp SkSurface::MakeFromBackendTextureAsRenderTarget(GrContext* context, const GrBackendTextureDesc& desc, sk_sp colorSpace, diff --git a/src/views/SkWindow.cpp b/src/views/SkWindow.cpp index ba06a1f3c2..f86bb9f9ef 100644 --- a/src/views/SkWindow.cpp +++ b/src/views/SkWindow.cpp @@ -316,7 +316,6 @@ bool SkWindow::onDispatchClick(int x, int y, Click::State state, #if SK_SUPPORT_GPU -#include "GrBackendSurface.h" #include "GrContext.h" #include "gl/GrGLInterface.h" #include "gl/GrGLUtil.h" @@ -325,9 +324,10 @@ bool SkWindow::onDispatchClick(int x, int y, Click::State state, sk_sp SkWindow::makeGpuBackedSurface(const AttachmentInfo& attachmentInfo, const GrGLInterface* interface, GrContext* grContext) { - int width = SkScalarRoundToInt(this->width()); - int height = SkScalarRoundToInt(this->height()); - if (0 == width || 0 == height) { + GrBackendRenderTargetDesc desc; + desc.fWidth = SkScalarRoundToInt(this->width()); + desc.fHeight = SkScalarRoundToInt(this->height()); + if (0 == desc.fWidth || 0 == desc.fHeight) { return nullptr; } @@ -340,28 +340,22 @@ sk_sp SkWindow::makeGpuBackedSurface(const AttachmentInfo& attachment // // ... and, if we're using a 10-bit/channel FB0, it doesn't do sRGB conversion on write, // so pretend that it's non-sRGB 8888: - GrPixelConfig config = grContext->caps()->srgbSupport() && - info().colorSpace() && - (attachmentInfo.fColorBits != 30) - ? kSRGBA_8888_GrPixelConfig : kRGBA_8888_GrPixelConfig; - GrGLFramebufferInfo fbInfo; + desc.fConfig = + grContext->caps()->srgbSupport() && + info().colorSpace() && + (attachmentInfo.fColorBits != 30) + ? kSRGBA_8888_GrPixelConfig : kRGBA_8888_GrPixelConfig; + desc.fOrigin = kBottomLeft_GrSurfaceOrigin; + desc.fSampleCnt = attachmentInfo.fSampleCount; + desc.fStencilBits = attachmentInfo.fStencilBits; GrGLint buffer; GR_GL_GetIntegerv(interface, GR_GL_FRAMEBUFFER_BINDING, &buffer); - fbInfo.fFBOID = buffer; - - GrBackendRenderTarget backendRT(width, - height, - attachmentInfo.fSampleCount, - attachmentInfo.fStencilBits, - config, - fbInfo); - + desc.fRenderTargetHandle = buffer; sk_sp colorSpace = grContext->caps()->srgbSupport() && info().colorSpace() ? SkColorSpace::MakeSRGB() : nullptr; - return SkSurface::MakeFromBackendRenderTarget(grContext, backendRT, kBottomLeft_GrSurfaceOrigin, - colorSpace, &fSurfaceProps); + return SkSurface::MakeFromBackendRenderTarget(grContext, desc, colorSpace, &fSurfaceProps); } #endif diff --git a/tests/ProxyConversionTest.cpp b/tests/ProxyConversionTest.cpp index 167cc4b10d..a041d68c2b 100644 --- a/tests/ProxyConversionTest.cpp +++ b/tests/ProxyConversionTest.cpp @@ -10,7 +10,6 @@ #include "Test.h" #if SK_SUPPORT_GPU -#include "GrBackendSurface.h" #include "GrRenderTargetProxy.h" #include "GrResourceProvider.h" #include "GrSurfaceProxy.h" @@ -19,12 +18,16 @@ static sk_sp make_wrapped_FBO0(GrResourceProvider* provider, skiatest::Reporter* reporter, const GrSurfaceDesc& desc) { - GrGLFramebufferInfo fboInfo; - fboInfo.fFBOID = 0; - GrBackendRenderTarget backendRT(desc.fWidth, desc.fHeight, desc.fSampleCnt, 8, - desc.fConfig, fboInfo); - - sk_sp defaultFBO(provider->wrapBackendRenderTarget(backendRT, desc.fOrigin)); + GrBackendRenderTargetDesc backendDesc; + backendDesc.fWidth = desc.fWidth; + backendDesc.fHeight = desc.fHeight; + backendDesc.fConfig = desc.fConfig; + backendDesc.fOrigin = desc.fOrigin; + backendDesc.fSampleCnt = desc.fSampleCnt; + backendDesc.fStencilBits = 8; + backendDesc.fRenderTargetHandle = 0; + + sk_sp defaultFBO(provider->wrapBackendRenderTarget(backendDesc)); SkASSERT(!defaultFBO->asTexture()); return GrSurfaceProxy::MakeWrapped(std::move(defaultFBO)); @@ -59,7 +62,6 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo desc.fWidth = 64; desc.fHeight = 64; desc.fConfig = kRGBA_8888_GrPixelConfig; - desc.fOrigin = kBottomLeft_GrSurfaceOrigin; if (kOpenGL_GrBackend == ctxInfo.backend()) { // External on-screen render target. diff --git a/tests/ProxyTest.cpp b/tests/ProxyTest.cpp index 6553b4e94f..db407d791f 100644 --- a/tests/ProxyTest.cpp +++ b/tests/ProxyTest.cpp @@ -10,7 +10,6 @@ #include "Test.h" #if SK_SUPPORT_GPU -#include "GrBackendSurface.h" #include "GrRenderTargetPriv.h" #include "GrRenderTargetProxy.h" #include "GrResourceProvider.h" @@ -21,7 +20,7 @@ static void check_surface(skiatest::Reporter* reporter, GrSurfaceProxy* proxy, GrSurfaceOrigin origin, - int width, int height, + int width, int height, GrPixelConfig config, const GrGpuResource::UniqueID& uniqueID, SkBudgeted budgeted) { @@ -229,13 +228,17 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) { // External on-screen render target. if (renderable && kOpenGL_GrBackend == ctxInfo.backend()) { - GrGLFramebufferInfo fboInfo; - fboInfo.fFBOID = 0; - GrBackendRenderTarget backendRT(kWidthHeight, kWidthHeight, numSamples, 8, - config, fboInfo); + GrBackendRenderTargetDesc backendDesc; + backendDesc.fWidth = kWidthHeight; + backendDesc.fHeight = kWidthHeight; + backendDesc.fConfig = config; + backendDesc.fOrigin = origin; + backendDesc.fSampleCnt = numSamples; + backendDesc.fStencilBits = 8; + backendDesc.fRenderTargetHandle = 0; sk_sp defaultFBO( - provider->wrapBackendRenderTarget(backendRT, origin)); + provider->wrapBackendRenderTarget(backendDesc)); sk_sp sProxy(GrSurfaceProxy::MakeWrapped(defaultFBO)); check_surface(reporter, sProxy.get(), origin, diff --git a/tests/VkWrapTests.cpp b/tests/VkWrapTests.cpp index 0ae3402da2..44b5e72bc9 100644 --- a/tests/VkWrapTests.cpp +++ b/tests/VkWrapTests.cpp @@ -93,24 +93,30 @@ void wrap_rt_test(skiatest::Reporter* reporter, GrContext* context) { true); const GrVkImageInfo* backendTex = reinterpret_cast(backendObj); - GrBackendRenderTarget backendRT(kW, kH, 0, 0, *backendTex); - - sk_sp rt = gpu->wrapBackendRenderTarget(backendRT, kTopLeft_GrSurfaceOrigin); + // check basic borrowed creation + GrBackendRenderTargetDesc desc; + desc.fWidth = kW; + desc.fHeight = kH; + desc.fConfig = kPixelConfig; + desc.fOrigin = kTopLeft_GrSurfaceOrigin; + desc.fSampleCnt = 0; + desc.fStencilBits = 0; + desc.fRenderTargetHandle = backendObj; + sk_sp rt = gpu->wrapBackendRenderTarget(desc); REPORTER_ASSERT(reporter, rt); // image is null GrVkImageInfo backendCopy = *backendTex; backendCopy.fImage = VK_NULL_HANDLE; - GrBackendRenderTarget backendRT2(kW, kH, 0, 0, backendCopy); - rt = gpu->wrapBackendRenderTarget(backendRT2, kTopLeft_GrSurfaceOrigin); + desc.fRenderTargetHandle = (GrBackendObject)&backendCopy; + rt = gpu->wrapBackendRenderTarget(desc); REPORTER_ASSERT(reporter, !rt); // alloc is null backendCopy.fImage = backendTex->fImage; backendCopy.fAlloc = { VK_NULL_HANDLE, 0, 0, 0 }; // can wrap null alloc - GrBackendRenderTarget backendRT3(kW, kH, 0, 0, backendCopy); - rt = gpu->wrapBackendRenderTarget(backendRT3, kTopLeft_GrSurfaceOrigin); + rt = gpu->wrapBackendRenderTarget(desc); REPORTER_ASSERT(reporter, rt); // When we wrapBackendRenderTarget it is always borrowed, so we must make sure to free the diff --git a/tools/gpu/GrTest.cpp b/tools/gpu/GrTest.cpp index c7751ec60a..2e34d2ff5b 100644 --- a/tools/gpu/GrTest.cpp +++ b/tools/gpu/GrTest.cpp @@ -359,8 +359,7 @@ private: return nullptr; } - sk_sp onWrapBackendRenderTarget(const GrBackendRenderTarget&, - GrSurfaceOrigin) override { + sk_sp onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) override { return nullptr; } diff --git a/tools/viewer/sk_app/GLWindowContext.cpp b/tools/viewer/sk_app/GLWindowContext.cpp index 6195199ce0..ff56ce8668 100644 --- a/tools/viewer/sk_app/GLWindowContext.cpp +++ b/tools/viewer/sk_app/GLWindowContext.cpp @@ -6,18 +6,19 @@ * found in the LICENSE file. */ -#include "GrBackendSurface.h" #include "GrContext.h" -#include "GrRenderTarget.h" +#include "SkSurface.h" #include "GLWindowContext.h" #include "gl/GrGLDefines.h" + #include "gl/GrGLUtil.h" +#include "GrRenderTarget.h" +#include "GrContext.h" #include "SkCanvas.h" #include "SkImage_Base.h" #include "SkMathPriv.h" -#include "SkSurface.h" namespace sk_app { @@ -63,7 +64,7 @@ void GLWindowContext::destroyContext() { fContext->unref(); fContext = nullptr; } - + fBackendContext.reset(nullptr); this->onDestroyContext(); @@ -72,21 +73,18 @@ void GLWindowContext::destroyContext() { sk_sp GLWindowContext::getBackbufferSurface() { if (nullptr == fSurface) { if (fContext) { - GrGLFramebufferInfo fbInfo; + GrBackendRenderTargetDesc desc; + desc.fWidth = this->fWidth; + desc.fHeight = this->fHeight; + desc.fConfig = fPixelConfig; + desc.fOrigin = kBottomLeft_GrSurfaceOrigin; + desc.fSampleCnt = fSampleCount; + desc.fStencilBits = fStencilBits; GrGLint buffer; - GR_GL_CALL(fBackendContext.get(), GetIntegerv(GR_GL_FRAMEBUFFER_BINDING, - &buffer)); - fbInfo.fFBOID = buffer; - - GrBackendRenderTarget backendRT(fWidth, - fHeight, - fSampleCount, - fStencilBits, - fPixelConfig, - fbInfo); - - fSurface = SkSurface::MakeFromBackendRenderTarget(fContext, backendRT, - kBottomLeft_GrSurfaceOrigin, + GR_GL_CALL(fBackendContext.get(), GetIntegerv(GR_GL_FRAMEBUFFER_BINDING, &buffer)); + desc.fRenderTargetHandle = buffer; + + fSurface = SkSurface::MakeFromBackendRenderTarget(fContext, desc, fDisplayParams.fColorSpace, &fSurfaceProps); } -- cgit v1.2.3