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

Revert "Revert "Revert "Remove GrBackendRenderTargetDesc in favor of GrBackendRenderTarget."""

Browse Source 
This reverts commit 71554bc256.

Reason for revert: Google3

Original change's description:
> Revert "Revert "Remove GrBackendRenderTargetDesc in favor of GrBackendRenderTarget.""
> 
> This reverts commit 807371c15b.
> 
> Docs-Preview: https://skia.org/?cl=40260
> Change-Id: I28e0434c455155ff39a5aaa4141abdf442474e87
> Reviewed-on: https://skia-review.googlesource.com/40260
> Reviewed-by: Greg Daniel <egdaniel@google.com>
> Commit-Queue: Brian Salomon <bsalomon@google.com>

TBR=egdaniel@google.com,bsalomon@google.com

Change-Id: Ifdfa896a70db69935473276d12dce54de5c6b6f7
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/41500
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
This commit is contained in:
Brian Salomon 2017-08-31 15:57:32 +00:00 committed by Skia Commit-Bot
parent 2dafbd796d
commit 6df4d6be0d
12 changed files with 166 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
debugger/QT/SkGLWidget.cpp
View File

@ -55,10 +55,11 @@ void SkGLWidget::createRenderTarget() {
glClearStencil(0);
glClear(GL_STENCIL_BUFFER_BIT);
fCurContext->resetContext();
GrBackendRenderTarget backendRenderTarget = this->getBackendRenderTarget();
fGpuSurface = SkSurface::MakeFromBackendRenderTarget(fCurContext.get(), backendRenderTarget,
kBottomLeft_GrSurfaceOrigin,
nullptr, nullptr);
GrBackendRenderTargetDesc desc = this->getDesc(this->width(), this->height());
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
fGpuSurface = SkSurface::MakeFromBackendRenderTarget(fCurContext.get(), desc, nullptr);
fCanvas = fGpuSurface->getCanvas();
}
@ -77,19 +78,18 @@ void SkGLWidget::paintGL() {
}
}
GrBackendRenderTarget SkGLWidget::getBackendRenderTarget() {
GrGLFramebufferInfo info;
int stencilBits;
int sampleCnt;
GR_GL_GetIntegerv(fCurIntf.get(), GR_GL_FRAMEBUFFER_BINDING, &info.fFBOID);
GR_GL_GetIntegerv(fCurIntf.get(), GR_GL_SAMPLES, &sampleCnt);
GR_GL_GetIntegerv(fCurIntf.get(), GR_GL_STENCIL_BITS, &stencilBits);
return GrBackendRenderTarget(SkScalarRoundToInt(this->width()),
SkScalarRoundToInt(this->height()),
sampleCnt,
stencilBits,
kSkia8888_GrPixelConfig,
info);
GrBackendRenderTargetDesc SkGLWidget::getDesc(int w, int h) {
GrBackendRenderTargetDesc desc;
desc.fWidth = SkScalarRoundToInt(this->width());
desc.fHeight = SkScalarRoundToInt(this->height());
desc.fConfig = kSkia8888_GrPixelConfig;
GR_GL_GetIntegerv(fCurIntf.get(), GR_GL_SAMPLES, &desc.fSampleCnt);
GR_GL_GetIntegerv(fCurIntf.get(), GR_GL_STENCIL_BITS, &desc.fStencilBits);
GrGLint buffer;
GR_GL_GetIntegerv(fCurIntf.get(), GR_GL_FRAMEBUFFER_BINDING, &buffer);
desc.fRenderTargetHandle = buffer;
return desc;
}
#endif

3
debugger/QT/SkGLWidget.h
View File

@ -16,7 +16,6 @@
#include "SkDebugCanvas.h"
#include "SkDebugger.h"
#include "SkGpuDevice.h"
#include "GrBackendSurface.h"
#include "GrContext.h"
#include "gl/GrGLInterface.h"
#include "gl/GrGLUtil.h"
@ -52,7 +51,7 @@ private:
SkCanvas* fCanvas;
SkDebugger* fDebugger;
GrBackendRenderTarget getBackendRenderTarget();
GrBackendRenderTargetDesc getDesc(int w, int h);
};
#endif /* SK_SUPPORT_GPU */

26
experimental/GLFWTest/glfw_main.cpp
View File

@ -5,11 +5,12 @@
* found in the LICENSE file.
*/
#include "GLFW/glfw3.h"
#include <stdlib.h>
#include <stdio.h>
#include "GLFW/glfw3.h"
#include "GrBackendSurface.h"
#include "GrContext.h"
#include "SkCanvas.h"
#include "SkImage.h"
#include "SkRSXform.h"
@ -32,17 +33,16 @@ static void key_callback(GLFWwindow* window, int key, int scancode, int action,
static void init_skia(int w, int h) {
sContext = GrContext::MakeGL(nullptr).release();
GrGLFramebufferInfo framebufferInfo;
framebufferInfo.fFBOID = 0; // assume default framebuffer
GrBackendRenderTarget backendRenderTarget(w, h,
0, // sample count
0, // stencil bits
kSkia8888_GrPixelConfig,
framebufferInfo);
sSurface = SkSurface::MakeFromBackendRenderTarget(sContext, backendRenderTarget,
kBottomLeft_GrSurfaceOrigin,
nullptr, nullptr).release();
GrBackendRenderTargetDesc desc;
desc.fWidth = w;
desc.fHeight = h;
desc.fConfig = kSkia8888_GrPixelConfig;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
desc.fSampleCnt = 1;
desc.fStencilBits = 0;
desc.fRenderTargetHandle = 0; // assume default framebuffer
sSurface = SkSurface::MakeFromBackendRenderTarget(sContext, desc, nullptr, nullptr).release();
}
static void cleanup_skia() {

25
experimental/SkV8Example/SkV8Example.cpp
View File

@ -8,12 +8,13 @@
*/
#include <v8.h>
#include <include/libplatform/libplatform.h>
#include "SkV8Example.h"
#include "Global.h"
#include "JsContext.h"
#include "Path2D.h"
#include "Path2DBuilder.h"
#include "GrBackendSurface.h"
#include "gl/GrGLUtil.h"
#include "gl/GrGLDefines.h"
#include "gl/GrGLInterface.h"
@ -83,17 +84,19 @@ void SkV8ExampleWindow::windowSizeChanged() {
exit(1);
}
GrGLFramebufferInfo framebufferInfo;
GR_GL_GetIntegerv(fCurIntf, GR_GL_FRAMEBUFFER_BINDING, &framebufferInfo.fFBOID);
GrBackendRenderTarget backendRenderTarget(SkScalarRoundToInt(this->width()),
SkScalarRoundToInt(this->height()),
attachmentInfo.fSampleCount,
attachmentInfo.fStencilBits,
kSkia8888_GrPixelConfig,
framebufferInfo);
GrBackendRenderTargetDesc desc;
desc.fWidth = SkScalarRoundToInt(this->width());
desc.fHeight = SkScalarRoundToInt(this->height());
desc.fConfig = kSkia8888_GrPixelConfig;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
desc.fSampleCnt = attachmentInfo.fSampleCount;
desc.fStencilBits = attachmentInfo.fStencilBits;
GrGLint buffer;
GR_GL_GetIntegerv(fCurIntf, GR_GL_FRAMEBUFFER_BINDING, &buffer);
desc.fRenderTargetHandle = buffer;
SkSafeUnref(fCurSurface);
fCurSurface = SkSurface::MakeFromBackendRenderTarget(fCurContext, backendRenderTarget,
kBottomLeft_GrSurfaceOrigin,
fCurSurface = SkSurface::MakeFromBackendRenderTarget(fCurContext, desc,
nullptr, nullptr).release();
}
}

28
include/core/SkSurface.h
View File

@ -94,6 +94,16 @@ public:
GrSurfaceOrigin origin, int sampleCnt,
sk_sp<SkColorSpace>, const SkSurfaceProps*);
/**
* Used to wrap a pre-existing 3D API rendering target as a SkSurface. Skia will not assume
* ownership of the render target and the client must ensure the render target is valid for the
* lifetime of the SkSurface.
*/
static sk_sp<SkSurface> MakeFromBackendRenderTarget(GrContext*,
const GrBackendRenderTargetDesc&,
sk_sp<SkColorSpace>,
const SkSurfaceProps*);
static sk_sp<SkSurface> MakeFromBackendRenderTarget(GrContext*,
const GrBackendRenderTarget&,
GrSurfaceOrigin origin,
@ -103,9 +113,10 @@ public:
/**
* Used to wrap a pre-existing 3D API texture as a SkSurface. Skia will treat the texture as
* a rendering target only, but unlike NewFromBackendRenderTarget, Skia will manage and own
* the associated render target objects (but not the provided texture). Skia will not assume
* ownership of the texture and the client must ensure the texture is valid for the lifetime
* of the SkSurface.
* the associated render target objects (but not the provided texture). The kRenderTarget flag
* must be set on GrBackendTextureDesc for this to succeed. Skia will not assume ownership
* of the texture and the client must ensure the texture is valid for the lifetime of the
* SkSurface.
*/
static sk_sp<SkSurface> MakeFromBackendTextureAsRenderTarget(GrContext*,
const GrBackendTexture&,
@ -114,6 +125,17 @@ public:
sk_sp<SkColorSpace>,
const SkSurfaceProps*);
/**
* Legacy version of the above factory, without color space support. This creates a "legacy"
* surface that operate without gamma correction or color management.
*/
static sk_sp<SkSurface> MakeFromBackendRenderTarget(GrContext* ctx,
const GrBackendRenderTargetDesc& desc,
const SkSurfaceProps* props) {
return MakeFromBackendRenderTarget(ctx, desc, nullptr, props);
}
/**
* Return a new surface whose contents will be drawn to an offscreen
* render target, allocated by the surface.

6
include/gpu/GrBackendSurface.h
View File

@ -108,6 +108,12 @@ public:
#endif
private:
// Temporary constructor which can be used to convert from a GrBackendRenderTargetDesc.
GrBackendRenderTarget(const GrBackendRenderTargetDesc& desc, GrBackend backend);
// Friending for access to above constructor taking a GrBackendRenderTargetDesc
friend class SkSurface;
int fWidth; //<! width in pixels
int fHeight; //<! height in pixels

33
include/gpu/GrTypes.h
View File

@ -641,6 +641,39 @@ enum GrWrapOwnership {
///////////////////////////////////////////////////////////////////////////////
/**
* Gr can wrap an existing render target created by the client in the 3D API
* with a GrRenderTarget object. The client is responsible for ensuring that the
* underlying 3D API object lives at least as long as the GrRenderTarget object
* wrapping it. We require the client to explicitly provide information about
* the target, such as width, height, and pixel config rather than querying the
* 3D API for these values. We expect these properties to be immutable even if
* the 3D API doesn't require this (OpenGL).
*/
struct GrBackendRenderTargetDesc {
GrBackendRenderTargetDesc() { memset(this, 0, sizeof(*this)); }
int fWidth; //<! width in pixels
int fHeight; //<! height in pixels
GrPixelConfig fConfig; //<! color format
GrSurfaceOrigin fOrigin; //<! pixel origin
/**
* The number of samples per pixel. Gr uses this to influence decisions
* about applying other forms of anti-aliasing.
*/
int fSampleCnt;
/**
* Number of bits of stencil per-pixel.
*/
int fStencilBits;
/**
* Handle to the 3D API object.
* OpenGL: FBO ID
* Vulkan: GrVkImageInfo*
*/
GrBackendObject fRenderTargetHandle;
};
/**
* The GrContext's cache of backend context state can be partially invalidated.
* These enums are specific to the GL backend and we'd add a new set for an alternative backend.

11
site/user/sample/color.md
View File

@ -116,9 +116,11 @@ can be in any gamut, but must have a linear transfer function.
sk_sp<SkImage> MakeFromEncoded(sk_sp<SkData> encoded);
// Create an image from a texture in a particular color space
sk_sp<SkImage> MakeFromTexture(GrContext*, const GrBackendTexture&,
GrSurfaceOrigin, SkAlphaType, sk_sp<SkColorSpace>,
...);
// Caution: There are versions of this constructor that do not take an
// SkColorSpace. But without an SkColorSpace, Skia does not have
// enough information to draw correctly.
sk_sp<SkImage> MakeFromTexture(GrContext*, const GrBackendTextureDesc&,
SkAlphaType, sk_sp<SkColorSpace>, ...);
**SkBitmap** is another (not preferred) representation for image sources. Be careful to not forget
the color space.
@ -188,5 +190,4 @@ cannot know how to draw without knowing the color space of the source.
It is possible to create **an object that is both a source and destination**, if Skia will both
draw into it and then draw it somewhere else. The same rules from above still apply, but it is
subtle that the color space tag could have an effect (or no effect) depending on how the object is
used.
used.

16
site/user/special/vulkan.md
View File

@ -33,16 +33,14 @@ To create a GrContext that is backed by Vulkan the client creates a Vulkan devic
sk_sp<GrContext> context = GrContext::MakeVulkan(vkBackendContext);
When using the Vulkan backend, GrVkImageInfo is used to construct GrBackendTexture
and GrBackendRenderTarget objects that in turn are used to create SkSurface and SkImage
objects that refer to VkImages created by the Skia client.
When using the Vulkan backend the GrBackendObject field in
GrBackendRenderTargetDesc and GrBackendTextureDesc is interpeted as a pointer
to a GrVkImageInfo object. GrVkImageInfo specifies a VkImage and associated
state (tiling, layout, format, etc). This allows the client to import
externally created Vulkan images as destinations for Skia rendering via
SkSurface factory functions or for to composite Skia rendered content using
SkImage::getTextureHandle().
The GrBackendObject returned by SkImage::getTextureHandle(),
SkSurface::getTextureHandle(), and SkSurface::getRenderTargetHandle() should be
interpreted as a GrVkImageInfo*. This allows a client to get the backing VkImage
of a SkImage or SkSurface.
GrVkImageInfo specifies a VkImage and associated state (tiling, layout, format, etc).
After getting a GrVkImageInfo* via getTextureHandle() or
getRenderTargetHandle(), the client should check the fImageLayout field to know
what layout Skia left the VkImage in before using the VkImage. If the client

23
src/gpu/GrBackendSurface.cpp
View File

@ -97,6 +97,29 @@ GrBackendRenderTarget::GrBackendRenderTarget(int width,
, fBackend(kOpenGL_GrBackend)
, fGLInfo(glInfo) {}
GrBackendRenderTarget::GrBackendRenderTarget(const GrBackendRenderTargetDesc& desc,
GrBackend backend)
: fWidth(desc.fWidth)
, fHeight(desc.fHeight)
, fSampleCnt(desc.fSampleCnt)
, fStencilBits(desc.fStencilBits)
, fConfig(desc.fConfig)
, fBackend(backend) {
if (kOpenGL_GrBackend == backend) {
fGLInfo.fFBOID = static_cast<GrGLuint>(desc.fRenderTargetHandle);
} else {
SkASSERT(kVulkan_GrBackend == backend);
#ifdef SK_VULKAN
const GrVkImageInfo* vkInfo =
reinterpret_cast<const GrVkImageInfo*>(desc.fRenderTargetHandle);
fConfig = GrVkFormatToPixelConfig(vkInfo->fFormat);
fVkInfo = *vkInfo;
#else
fConfig = kUnknown_GrPixelConfig;
#endif
}
}
#ifdef SK_VULKAN
const GrVkImageInfo* GrBackendRenderTarget::getVkImageInfo() const {
if (kVulkan_GrBackend == fBackend) {

7
src/image/SkSurface.cpp
View File

@ -258,6 +258,13 @@ sk_sp<SkSurface> SkSurface::MakeFromBackendTexture(GrContext*, const GrBackendTe
return nullptr;
}
sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext*,
const GrBackendRenderTargetDesc&,
sk_sp<SkColorSpace>,
const SkSurfaceProps*) {
return nullptr;
}
sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext*,
const GrBackendRenderTarget&,
GrSurfaceOrigin origin,

14
src/image/SkSurface_Gpu.cpp
View File

@ -265,6 +265,20 @@ sk_sp<SkSurface> SkSurface::MakeFromBackendTexture(GrContext* context, const GrB
return sk_make_sp<SkSurface_Gpu>(std::move(device));
}
sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext* context,
const GrBackendRenderTargetDesc& desc,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* props) {
if (!context) {
return nullptr;
}
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,