AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Plumb the use of GrBackendRenderTarget throughout Skia

Browse Source 
Bug: skia:
Change-Id: Ib99a58d9552f5c7b8d77c09dcc72fa88326c26aa
Reviewed-on: https://skia-review.googlesource.com/14148
Reviewed-by: Brian Salomon <bsalomon@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
This commit is contained in:
Greg Daniel 2017-04-26 12:19:14 -04:00 committed by Skia Commit-Bot
parent a41d48b739
commit fdd77daedb
22 changed files with 179 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
example/SkiaSDLExample.cpp
View File

@ -6,6 +6,7 @@
*
*/
#include "GrBackendSurface.h"
#include "GrContext.h"
#include "SDL.h"
#include "SkCanvas.h"
@ -192,16 +193,12 @@ 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
GrBackendRenderTargetDesc desc;
desc.fWidth = dm.w;
desc.fHeight = dm.h;
desc.fConfig = kSkia8888_GrPixelConfig;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
desc.fSampleCnt = kMsaaSampleCount;
desc.fStencilBits = kStencilBits;
GrGLFrameBufferInfo fbInfo;
GrGLint buffer;
GR_GL_GetIntegerv(interface, GR_GL_FRAMEBUFFER_BINDING, &buffer);
desc.fRenderTargetHandle = buffer;
fbInfo.fFBOID = buffer;
GrBackendRenderTarget backendRT(dm.w, dm.h, kMsaaSampleCount, kStencilBits,
kSkia8888_GrPixelConfig, fbInfo);
// setup SkSurface
// To use distance field text, use commented out SkSurfaceProps instead
@ -209,7 +206,10 @@ int main(int argc, char** argv) {
// SkSurfaceProps::kLegacyFontHost_InitType);
SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
sk_sp<SkSurface> surface(SkSurface::MakeFromBackendRenderTarget(grContext, desc, &props));
sk_sp<SkSurface> surface(SkSurface::MakeFromBackendRenderTarget(grContext,
backendRT,
kBottomLeft_GrSurfaceOrigin,
&props));
SkCanvas* canvas = surface->getCanvas();

24
include/gpu/GrBackendSurface.h
View File

@ -9,9 +9,8 @@
#define GrBackendSurface_DEFINED
#include "GrTypes.h"
struct GrVkImageInfo;
struct GrGLTextureInfo;
#include "gl/GrGLTypes.h"
#include "vk/GrVkTypes.h"
class GrBackendTexture {
public:
@ -63,22 +62,18 @@ 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 GrGLTextureInfo* glInfo);
const GrGLFramebufferInfo& glInfo);
int width() const { return fWidth; }
int height() const { return fHeight; }
@ -88,12 +83,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 GrGLTextureInfo struct. Otherwise
// If the backend API is GL, this returns a pointer to the GrGLFramebufferInfo struct. Otherwise
// it returns nullptr.
const GrGLTextureInfo* getGLTextureInfo() const;
const GrGLFramebufferInfo* getGLFramebufferInfo() const;
private:
// Temporary constructor which can be used to convert from a GrBackendRenderTargetDesc.
@ -112,9 +107,8 @@ private:
GrBackend fBackend;
union {
const GrVkImageInfo* fVkInfo;
const GrGLTextureInfo* fGLInfo;
GrBackendObject fHandle;
GrVkImageInfo fVkInfo;
GrGLFramebufferInfo fGLInfo;
};
};

6
include/gpu/gl/GrGLTypes.h
View File

@ -135,4 +135,10 @@ protected:
GR_STATIC_ASSERT(sizeof(GrBackendObject) >= sizeof(const GrGLTextureInfo*));
struct GrGLFramebufferInfo {
GrGLuint fFBOID;
};
GR_STATIC_ASSERT(sizeof(GrBackendObject) >= sizeof(const GrGLFramebufferInfo*));
#endif

4
include/gpu/vk/GrVkDefines.h
View File

@ -9,6 +9,8 @@
#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
@ -29,8 +31,6 @@
# endif
#endif
#if defined(Bool) || defined(Status) || defined(True) || defined(False)
# pragma error "Macros unexpectedly defined."
#endif
#include <vulkan/vulkan.h>

31
src/gpu/GrBackendSurface.cpp
View File

@ -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 GrGLTextureInfo* glInfo)
const GrGLFramebufferInfo& glInfo)
: fWidth(width)
, fHeight(height)
, fSampleCnt(sampleCnt)
@ -105,26 +105,33 @@ GrBackendRenderTarget::GrBackendRenderTarget(const GrBackendRenderTargetDesc& de
, fHeight(desc.fHeight)
, fSampleCnt(desc.fSampleCnt)
, fStencilBits(desc.fStencilBits)
, fConfig(kVulkan_GrBackend == backend
, fConfig(desc.fConfig)
, fBackend(backend) {
if (kOpenGL_GrBackend == backend) {
fGLInfo = *reinterpret_cast<const GrGLFramebufferInfo*>(desc.fRenderTargetHandle);
} else {
SkASSERT(kVulkan_GrBackend == backend);
#ifdef SK_VULKAN
? GrVkFormatToPixelConfig(((GrVkImageInfo*)desc.fRenderTargetHandle)->fFormat)
const GrVkImageInfo* vkInfo =
reinterpret_cast<const GrVkImageInfo*>(desc.fRenderTargetHandle);
fConfig = GrVkFormatToPixelConfig(vkInfo->fFormat);
fVkInfo = *vkInfo;
#else
? kUnknown_GrPixelConfig
fConfig = 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 GrGLTextureInfo* GrBackendRenderTarget::getGLTextureInfo() const {
const GrGLFramebufferInfo* GrBackendRenderTarget::getGLFramebufferInfo() const {
if (kOpenGL_GrBackend == fBackend) {
return fGLInfo;
return &fGLInfo;
}
return nullptr;
}

6
src/gpu/GrContext.cpp
View File

@ -702,12 +702,14 @@ sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendTextureRenderTargetContex
}
sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendRenderTargetRenderTargetContext(
const GrBackendRenderTargetDesc& desc,
const GrBackendRenderTarget& backendRT,
GrSurfaceOrigin origin,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* surfaceProps) {
ASSERT_SINGLE_OWNER_PRIV
sk_sp<GrRenderTarget> rt(fContext->resourceProvider()->wrapBackendRenderTarget(desc));
sk_sp<GrRenderTarget> rt(fContext->resourceProvider()->wrapBackendRenderTarget(backendRT,
origin));
if (!rt) {
return nullptr;
}

4
src/gpu/GrContextPriv.h
View File

@ -11,6 +11,7 @@
#include "GrContext.h"
#include "GrSurfaceContext.h"
class GrBackendRenderTarget;
class GrSemaphore;
class GrSurfaceProxy;
class GrPreFlushCallbackObject;
@ -52,7 +53,8 @@ public:
const SkSurfaceProps* = nullptr);
sk_sp<GrRenderTargetContext> makeBackendRenderTargetRenderTargetContext(
const GrBackendRenderTargetDesc& desc,
const GrBackendRenderTarget&,
GrSurfaceOrigin origin,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* = nullptr);

7
src/gpu/GrGpu.cpp
View File

@ -223,12 +223,13 @@ sk_sp<GrTexture> GrGpu::wrapBackendTexture(const GrBackendTexture& backendTex,
return tex;
}
sk_sp<GrRenderTarget> GrGpu::wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc) {
if (!this->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
sk_sp<GrRenderTarget> GrGpu::wrapBackendRenderTarget(const GrBackendRenderTarget& backendRT,
GrSurfaceOrigin origin) {
if (!this->caps()->isConfigRenderable(backendRT.config(), backendRT.sampleCnt() > 0)) {
return nullptr;
}
this->handleDirtyContext();
return this->onWrapBackendRenderTarget(desc);
return this->onWrapBackendRenderTarget(backendRT, origin);
}
sk_sp<GrRenderTarget> GrGpu::wrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,

6
src/gpu/GrGpu.h
View File

@ -20,6 +20,7 @@
#include "SkTArray.h"
#include <map>
class GrBackendRenderTarget;
class GrBuffer;
class GrContext;
struct GrContextOptions;
@ -135,7 +136,7 @@ public:
/**
* Implements GrResourceProvider::wrapBackendRenderTarget
*/
sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTargetDesc&);
sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTarget&, GrSurfaceOrigin);
/**
* Implements GrResourceProvider::wrapBackendTextureAsRenderTarget
@ -556,7 +557,8 @@ private:
GrBackendTextureFlags,
int sampleCnt,
GrWrapOwnership) = 0;
virtual sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) = 0;
virtual sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
GrSurfaceOrigin) = 0;
virtual sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt)=0;

4
src/gpu/GrResourceProvider.cpp
View File

@ -254,10 +254,10 @@ sk_sp<GrTexture> GrResourceProvider::wrapBackendTexture(const GrBackendTexture&
}
sk_sp<GrRenderTarget> GrResourceProvider::wrapBackendRenderTarget(
const GrBackendRenderTargetDesc& desc)
const GrBackendRenderTarget& backendRT, GrSurfaceOrigin origin)
{
ASSERT_SINGLE_OWNER
return this->isAbandoned() ? nullptr : fGpu->wrapBackendRenderTarget(desc);
return this->isAbandoned() ? nullptr : fGpu->wrapBackendRenderTarget(backendRT, origin);
}
void GrResourceProvider::assignUniqueKeyToResource(const GrUniqueKey& key,

3
src/gpu/GrResourceProvider.h
View File

@ -12,6 +12,7 @@
#include "GrGpu.h"
#include "GrPathRange.h"
class GrBackendRenderTarget;
class GrPath;
class GrRenderTarget;
class GrSingleOwner;
@ -100,7 +101,7 @@ public:
*
* @return GrRenderTarget object or NULL on failure.
*/
sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc);
sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTarget&, GrSurfaceOrigin);
static const int kMinScratchTextureSize;

34
src/gpu/gl/GrGLGpu.cpp
View File

@ -504,17 +504,6 @@ 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<GrTexture> GrGLGpu::onWrapBackendTexture(const GrBackendTexture& backendTex,
GrSurfaceOrigin origin,
GrBackendTextureFlags flags,
@ -591,23 +580,30 @@ sk_sp<GrTexture> GrGLGpu::onWrapBackendTexture(const GrBackendTexture& backendTe
}
}
sk_sp<GrRenderTarget> GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& wrapDesc){
sk_sp<GrRenderTarget> GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT,
GrSurfaceOrigin origin) {
const GrGLFramebufferInfo* info = backendRT.getGLFramebufferInfo();
if (!info) {
return nullptr;
}
GrGLRenderTarget::IDDesc idDesc;
idDesc.fRTFBOID = static_cast<GrGLuint>(wrapDesc.fRenderTargetHandle);
idDesc.fRTFBOID = info->fFBOID;
idDesc.fMSColorRenderbufferID = 0;
idDesc.fTexFBOID = GrGLRenderTarget::kUnresolvableFBOID;
idDesc.fRTFBOOwnership = GrBackendObjectOwnership::kBorrowed;
idDesc.fIsMixedSampled = false;
GrSurfaceDesc desc;
desc.fConfig = wrapDesc.fConfig;
desc.fConfig = backendRT.config();
desc.fFlags = kCheckAllocation_GrSurfaceFlag | kRenderTarget_GrSurfaceFlag;
desc.fWidth = wrapDesc.fWidth;
desc.fHeight = wrapDesc.fHeight;
desc.fSampleCnt = SkTMin(wrapDesc.fSampleCnt, this->caps()->maxSampleCount());
desc.fOrigin = resolve_origin(wrapDesc.fOrigin, true);
desc.fWidth = backendRT.width();
desc.fHeight = backendRT.height();
desc.fSampleCnt = SkTMin(backendRT.sampleCnt(), this->caps()->maxSampleCount());
SkASSERT(kDefault_GrSurfaceOrigin != origin);
desc.fOrigin = origin;
return GrGLRenderTarget::MakeWrapped(this, desc, idDesc, wrapDesc.fStencilBits);
return GrGLRenderTarget::MakeWrapped(this, desc, idDesc, backendRT.stencilBits());
}
sk_sp<GrRenderTarget> GrGLGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,

3
src/gpu/gl/GrGLGpu.h
View File

@ -176,7 +176,8 @@ private:
GrBackendTextureFlags,
int sampleCnt,
GrWrapOwnership) override;
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) override;
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
GrSurfaceOrigin origin) override;
sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt) override;

25
src/gpu/vk/GrVkGpu.cpp
View File

@ -815,32 +815,36 @@ sk_sp<GrTexture> GrVkGpu::onWrapBackendTexture(const GrBackendTexture& backendTe
return GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(this, surfDesc, ownership, info);
}
sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& wrapDesc){
sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT,
GrSurfaceOrigin origin){
// 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 (wrapDesc.fSampleCnt) {
if (backendRT.sampleCnt()) {
return nullptr;
}
const GrVkImageInfo* info =
reinterpret_cast<const GrVkImageInfo*>(wrapDesc.fRenderTargetHandle);
const GrVkImageInfo* info = backendRT.getVkImageInfo();
if (!info) {
return nullptr;
}
if (VK_NULL_HANDLE == info->fImage) {
return nullptr;
}
GrSurfaceDesc desc;
desc.fConfig = wrapDesc.fConfig;
desc.fConfig = backendRT.config();
desc.fFlags = kCheckAllocation_GrSurfaceFlag | kRenderTarget_GrSurfaceFlag;
desc.fWidth = wrapDesc.fWidth;
desc.fHeight = wrapDesc.fHeight;
desc.fWidth = backendRT.width();
desc.fHeight = backendRT.height();
desc.fSampleCnt = 0;
desc.fOrigin = resolve_origin(wrapDesc.fOrigin);
SkASSERT(kDefault_GrSurfaceOrigin != origin);
desc.fOrigin = origin;
sk_sp<GrVkRenderTarget> tgt = GrVkRenderTarget::MakeWrappedRenderTarget(this, desc, info);
if (tgt && wrapDesc.fStencilBits) {
if (tgt && backendRT.stencilBits()) {
if (!createStencilAttachmentForRenderTarget(tgt.get(), desc.fWidth, desc.fHeight)) {
return nullptr;
}
@ -853,6 +857,9 @@ sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendTextureAsRenderTarget(const GrBacken
int sampleCnt) {
const GrVkImageInfo* info = tex.getVkImageInfo();
if (!info) {
return nullptr;
}
if (VK_NULL_HANDLE == info->fImage) {
return nullptr;
}

3
src/gpu/vk/GrVkGpu.h
View File

@ -180,7 +180,8 @@ private:
GrBackendTextureFlags,
int sampleCnt,
GrWrapOwnership) override;
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) override;
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
GrSurfaceOrigin) override;
sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
GrSurfaceOrigin,

33
src/image/SkSurface_Gpu.cpp
View File

@ -261,19 +261,36 @@ sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext* context,
if (!context) {
return nullptr;
}
if (!SkSurface_Gpu::Valid(context, desc.fConfig, colorSpace.get())) {
GrBackendRenderTarget backendRT(desc, context->contextPriv().getBackend());
return MakeFromBackendRenderTarget(context, backendRT, desc.fOrigin,
std::move(colorSpace), props);
}
sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext* context,
const GrBackendRenderTarget& backendRT,
GrSurfaceOrigin origin,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* props) {
if (!context) {
return nullptr;
}
if (!SkSurface_Gpu::Valid(context, backendRT.config(), colorSpace.get())) {
return nullptr;
}
sk_sp<GrRenderTargetContext> rtc(
context->contextPriv().makeBackendRenderTargetRenderTargetContext(desc,
context->contextPriv().makeBackendRenderTargetRenderTargetContext(backendRT,
origin,
std::move(colorSpace),
props));
if (!rtc) {
return nullptr;
}
sk_sp<SkGpuDevice> device(SkGpuDevice::Make(context, std::move(rtc), desc.fWidth, desc.fHeight,
sk_sp<SkGpuDevice> device(SkGpuDevice::Make(context, std::move(rtc),
backendRT.width(), backendRT.height(),
SkGpuDevice::kUninit_InitContents));
if (!device) {
return nullptr;
@ -282,16 +299,6 @@ sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext* context,
return sk_make_sp<SkSurface_Gpu>(std::move(device));
}
sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext*,
const GrBackendRenderTarget&,
GrSurfaceOrigin origin,
sk_sp<SkColorSpace>,
const SkSurfaceProps*) {
// This function is not implemented yet
sk_throw();
return nullptr;
}
sk_sp<SkSurface> SkSurface::MakeFromBackendTextureAsRenderTarget(GrContext* context,
const GrBackendTextureDesc& desc,
sk_sp<SkColorSpace> colorSpace,

34
src/views/SkWindow.cpp
View File

@ -316,6 +316,7 @@ 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"
@ -324,10 +325,9 @@ bool SkWindow::onDispatchClick(int x, int y, Click::State state,
sk_sp<SkSurface> SkWindow::makeGpuBackedSurface(const AttachmentInfo& attachmentInfo,
const GrGLInterface* interface,
GrContext* grContext) {
GrBackendRenderTargetDesc desc;
desc.fWidth = SkScalarRoundToInt(this->width());
desc.fHeight = SkScalarRoundToInt(this->height());
if (0 == desc.fWidth || 0 == desc.fHeight) {
int width = SkScalarRoundToInt(this->width());
int height = SkScalarRoundToInt(this->height());
if (0 == width || 0 == height) {
return nullptr;
}
@ -340,22 +340,28 @@ sk_sp<SkSurface> 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:
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;
GrPixelConfig config = grContext->caps()->srgbSupport() &&
info().colorSpace() &&
(attachmentInfo.fColorBits != 30)
? kSRGBA_8888_GrPixelConfig : kRGBA_8888_GrPixelConfig;
GrGLFramebufferInfo fbInfo;
GrGLint buffer;
GR_GL_GetIntegerv(interface, GR_GL_FRAMEBUFFER_BINDING, &buffer);
desc.fRenderTargetHandle = buffer;
fbInfo.fFBOID = buffer;
GrBackendRenderTarget backendRT(width,
height,
attachmentInfo.fSampleCount,
attachmentInfo.fStencilBits,
config,
fbInfo);
sk_sp<SkColorSpace> colorSpace =
grContext->caps()->srgbSupport() && info().colorSpace()
? SkColorSpace::MakeSRGB() : nullptr;
return SkSurface::MakeFromBackendRenderTarget(grContext, desc, colorSpace, &fSurfaceProps);
return SkSurface::MakeFromBackendRenderTarget(grContext, backendRT, kBottomLeft_GrSurfaceOrigin,
colorSpace, &fSurfaceProps);
}
#endif

16
tests/ProxyConversionTest.cpp
View File

@ -10,6 +10,7 @@
#include "Test.h"
#if SK_SUPPORT_GPU
#include "GrBackendSurface.h"
#include "GrRenderTargetProxy.h"
#include "GrResourceProvider.h"
#include "GrSurfaceProxy.h"
@ -18,16 +19,12 @@
static sk_sp<GrSurfaceProxy> make_wrapped_FBO0(GrResourceProvider* provider,
skiatest::Reporter* reporter,
const GrSurfaceDesc& desc) {
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;
GrGLFramebufferInfo fboInfo;
fboInfo.fFBOID = 0;
GrBackendRenderTarget backendRT(desc.fWidth, desc.fHeight, desc.fSampleCnt, 8,
desc.fConfig, fboInfo);
sk_sp<GrRenderTarget> defaultFBO(provider->wrapBackendRenderTarget(backendDesc));
sk_sp<GrRenderTarget> defaultFBO(provider->wrapBackendRenderTarget(backendRT, desc.fOrigin));
SkASSERT(!defaultFBO->asTexture());
return GrSurfaceProxy::MakeWrapped(std::move(defaultFBO));
@ -62,6 +59,7 @@ 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.

17
tests/ProxyTest.cpp
View File

@ -10,6 +10,7 @@
#include "Test.h"
#if SK_SUPPORT_GPU
#include "GrBackendSurface.h"
#include "GrRenderTargetPriv.h"
#include "GrRenderTargetProxy.h"
#include "GrResourceProvider.h"
@ -20,7 +21,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) {
@ -228,17 +229,13 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) {
// External on-screen render target.
if (renderable && kOpenGL_GrBackend == ctxInfo.backend()) {
GrBackendRenderTargetDesc backendDesc;
backendDesc.fWidth = kWidthHeight;
backendDesc.fHeight = kWidthHeight;
backendDesc.fConfig = config;
backendDesc.fOrigin = origin;
backendDesc.fSampleCnt = numSamples;
backendDesc.fStencilBits = 8;
backendDesc.fRenderTargetHandle = 0;
GrGLFramebufferInfo fboInfo;
fboInfo.fFBOID = 0;
GrBackendRenderTarget backendRT(kWidthHeight, kWidthHeight, numSamples, 8,
config, fboInfo);
sk_sp<GrRenderTarget> defaultFBO(
provider->wrapBackendRenderTarget(backendDesc));
provider->wrapBackendRenderTarget(backendRT, origin));
sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(defaultFBO));
check_surface(reporter, sProxy.get(), origin,

20
tests/VkWrapTests.cpp
View File

@ -93,30 +93,24 @@ void wrap_rt_test(skiatest::Reporter* reporter, GrContext* context) {
true);
const GrVkImageInfo* backendTex = reinterpret_cast<const GrVkImageInfo*>(backendObj);
// 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<GrRenderTarget> rt = gpu->wrapBackendRenderTarget(desc);
GrBackendRenderTarget backendRT(kW, kH, 0, 0, *backendTex);
sk_sp<GrRenderTarget> rt = gpu->wrapBackendRenderTarget(backendRT, kTopLeft_GrSurfaceOrigin);
REPORTER_ASSERT(reporter, rt);
// image is null
GrVkImageInfo backendCopy = *backendTex;
backendCopy.fImage = VK_NULL_HANDLE;
desc.fRenderTargetHandle = (GrBackendObject)&backendCopy;
rt = gpu->wrapBackendRenderTarget(desc);
GrBackendRenderTarget backendRT2(kW, kH, 0, 0, backendCopy);
rt = gpu->wrapBackendRenderTarget(backendRT2, kTopLeft_GrSurfaceOrigin);
REPORTER_ASSERT(reporter, !rt);
// alloc is null
backendCopy.fImage = backendTex->fImage;
backendCopy.fAlloc = { VK_NULL_HANDLE, 0, 0, 0 };
// can wrap null alloc
rt = gpu->wrapBackendRenderTarget(desc);
GrBackendRenderTarget backendRT3(kW, kH, 0, 0, backendCopy);
rt = gpu->wrapBackendRenderTarget(backendRT3, kTopLeft_GrSurfaceOrigin);
REPORTER_ASSERT(reporter, rt);
// When we wrapBackendRenderTarget it is always borrowed, so we must make sure to free the

3
tools/gpu/GrTest.cpp
View File

@ -359,7 +359,8 @@ private:
return nullptr;
}
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) override {
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
GrSurfaceOrigin) override {
return nullptr;
}

32
tools/viewer/sk_app/GLWindowContext.cpp
View File

@ -6,19 +6,18 @@
* found in the LICENSE file.
*/
#include "GrBackendSurface.h"
#include "GrContext.h"
#include "SkSurface.h"
#include "GrRenderTarget.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 {
@ -64,7 +63,7 @@ void GLWindowContext::destroyContext() {
fContext->unref();
fContext = nullptr;
}
fBackendContext.reset(nullptr);
this->onDestroyContext();
@ -73,18 +72,21 @@ void GLWindowContext::destroyContext() {
sk_sp<SkSurface> GLWindowContext::getBackbufferSurface() {
if (nullptr == fSurface) {
if (fContext) {
GrBackendRenderTargetDesc desc;
desc.fWidth = this->fWidth;
desc.fHeight = this->fHeight;
desc.fConfig = fPixelConfig;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
desc.fSampleCnt = fSampleCount;
desc.fStencilBits = fStencilBits;
GrGLFramebufferInfo fbInfo;
GrGLint buffer;
GR_GL_CALL(fBackendContext.get(), GetIntegerv(GR_GL_FRAMEBUFFER_BINDING, &buffer));
desc.fRenderTargetHandle = buffer;
GR_GL_CALL(fBackendContext.get(), GetIntegerv(GR_GL_FRAMEBUFFER_BINDING,
&buffer));
fbInfo.fFBOID = buffer;
fSurface = SkSurface::MakeFromBackendRenderTarget(fContext, desc,
GrBackendRenderTarget backendRT(fWidth,
fHeight,
fSampleCount,
fStencilBits,
fPixelConfig,
fbInfo);
fSurface = SkSurface::MakeFromBackendRenderTarget(fContext, backendRT,
kBottomLeft_GrSurfaceOrigin,
fDisplayParams.fColorSpace,
&fSurfaceProps);
}