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

Remove origin field from GrSurface

Browse Source 
This mainly consists of rm origin from GrSurface and the wrapBackEnd*
methods and then re-adding an explicit origin parameter to all the 
GrGpu methods that need it.

Change-Id: Iabd79ae98b227b5b9409f3ab5bbcc48af9613c18
Reviewed-on: https://skia-review.googlesource.com/26363
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
This commit is contained in:
Robert Phillips 2017-07-28 11:56:47 -04:00 committed by Skia Commit-Bot
parent f57c0d6761
commit df0e09feac
40 changed files with 444 additions and 546 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/gpu/GrSurface.h
View File

@ -35,11 +35,6 @@ public:
*/
SkRect getBoundsRect() const { return SkRect::MakeIWH(this->width(), this->height()); }
GrSurfaceOrigin origin() const {
SkASSERT(kTopLeft_GrSurfaceOrigin == fOrigin || kBottomLeft_GrSurfaceOrigin == fOrigin);
return fOrigin;
}
/**
* Retrieves the pixel config specified when the surface was created.
* For render targets this can be kUnknown_GrPixelConfig
@ -81,8 +76,7 @@ protected:
: INHERITED(gpu)
, fConfig(desc.fConfig)
, fWidth(desc.fWidth)
, fHeight(desc.fHeight)
, fOrigin(desc.fOrigin) {}
, fHeight(desc.fHeight) {}
~GrSurface() override {}
@ -93,7 +87,6 @@ private:
GrPixelConfig fConfig;
int fWidth;
int fHeight;
GrSurfaceOrigin fOrigin;
typedef GrGpuResource INHERITED;
};

1
src/gpu/GrAHardwareBufferImageGenerator.cpp
View File

@ -192,7 +192,6 @@ sk_sp<GrTextureProxy> GrAHardwareBufferImageGenerator::makeProxy(GrContext* cont
return nullptr;
}
sk_sp<GrTexture> tex = context->resourceProvider()->wrapBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
kAdopt_GrWrapOwnership);
if (!tex) {
glDeleteTextures(1, &texID);

11
src/gpu/GrBackendTextureImageGenerator.cpp
View File

@ -54,7 +54,8 @@ static GrBackendTexture make_backend_texture_from_handle(GrBackend backend,
}
std::unique_ptr<SkImageGenerator>
GrBackendTextureImageGenerator::Make(sk_sp<GrTexture> texture, sk_sp<GrSemaphore> semaphore,
GrBackendTextureImageGenerator::Make(sk_sp<GrTexture> texture, GrSurfaceOrigin origin,
sk_sp<GrSemaphore> semaphore,
SkAlphaType alphaType, sk_sp<SkColorSpace> colorSpace) {
if (colorSpace && (!colorSpace->gammaCloseToSRGB() && !colorSpace->gammaIsLinear())) {
return nullptr;
@ -82,11 +83,12 @@ GrBackendTextureImageGenerator::Make(sk_sp<GrTexture> texture, sk_sp<GrSemaphore
SkImageInfo info = SkImageInfo::Make(texture->width(), texture->height(), colorType, alphaType,
std::move(colorSpace));
return std::unique_ptr<SkImageGenerator>(new GrBackendTextureImageGenerator(
info, texture.get(), context->uniqueID(), std::move(semaphore), backendTexture));
info, texture.get(), origin, context->uniqueID(), std::move(semaphore), backendTexture));
}
GrBackendTextureImageGenerator::GrBackendTextureImageGenerator(const SkImageInfo& info,
GrTexture* texture,
GrSurfaceOrigin origin,
uint32_t owningContextID,
sk_sp<GrSemaphore> semaphore,
const GrBackendTexture& backendTex)
@ -95,7 +97,7 @@ GrBackendTextureImageGenerator::GrBackendTextureImageGenerator(const SkImageInfo
, fSemaphore(std::move(semaphore))
, fLastBorrowingContextID(SK_InvalidGenID)
, fBackendTexture(backendTex)
, fSurfaceOrigin(texture->origin()) { }
, fSurfaceOrigin(origin) { }
GrBackendTextureImageGenerator::~GrBackendTextureImageGenerator() {
fRefHelper->unref();
@ -146,12 +148,13 @@ sk_sp<GrTextureProxy> GrBackendTextureImageGenerator::onGenerateTexture(
}
}
SkASSERT(kDefault_GrSurfaceOrigin != fSurfaceOrigin);
// We just gained access to the texture. If we're on the original context, we could use the
// original texture, but we'd have no way of detecting that it's no longer in-use. So we
// always make a wrapped copy, where the release proc informs us that the context is done
// with it. This is unfortunate - we'll have two texture objects referencing the same GPU
// object. However, no client can ever see the original texture, so this should be safe.
tex = context->resourceProvider()->wrapBackendTexture(fBackendTexture, fSurfaceOrigin,
tex = context->resourceProvider()->wrapBackendTexture(fBackendTexture,
kBorrow_GrWrapOwnership);
if (!tex) {
fRefHelper->fBorrowingContextID = SK_InvalidGenID;

5
src/gpu/GrBackendTextureImageGenerator.h
View File

@ -16,7 +16,8 @@ class GrSemaphore;
class GrBackendTextureImageGenerator : public SkImageGenerator {
public:
static std::unique_ptr<SkImageGenerator> Make(sk_sp<GrTexture>, sk_sp<GrSemaphore>,
static std::unique_ptr<SkImageGenerator> Make(sk_sp<GrTexture>, GrSurfaceOrigin,
sk_sp<GrSemaphore>,
SkAlphaType, sk_sp<SkColorSpace>);
~GrBackendTextureImageGenerator() override;
@ -33,7 +34,7 @@ protected:
#endif
private:
GrBackendTextureImageGenerator(const SkImageInfo& info, GrTexture*,
GrBackendTextureImageGenerator(const SkImageInfo& info, GrTexture*, GrSurfaceOrigin,
uint32_t owningContextID, sk_sp<GrSemaphore>,
const GrBackendTexture&);

27
src/gpu/GrContext.cpp
View File

@ -433,7 +433,7 @@ bool GrContextPriv::writeSurfacePixels(GrSurfaceContext* dst,
GrGpu::DrawPreference drawPreference = premulOnGpu ? GrGpu::kCallerPrefersDraw_DrawPreference
: GrGpu::kNoDraw_DrawPreference;
GrGpu::WritePixelTempDrawInfo tempDrawInfo;
if (!fContext->fGpu->getWritePixelsInfo(dstSurface, width, height,
if (!fContext->fGpu->getWritePixelsInfo(dstSurface, dstProxy->origin(), width, height,
srcConfig, &drawPreference, &tempDrawInfo)) {
return false;
}
@ -486,8 +486,8 @@ bool GrContextPriv::writeSurfacePixels(GrSurfaceContext* dst,
return false;
}
GrTexture* texture = tempProxy->priv().peekTexture();
if (!fContext->fGpu->writePixels(texture, 0, 0, width, height, tempDrawInfo.fWriteConfig,
buffer, rowBytes)) {
if (!fContext->fGpu->writePixels(texture, tempProxy->origin(), 0, 0, width, height,
tempDrawInfo.fWriteConfig, buffer, rowBytes)) {
return false;
}
SkMatrix matrix;
@ -509,8 +509,8 @@ bool GrContextPriv::writeSurfacePixels(GrSurfaceContext* dst,
this->flushSurfaceWrites(renderTargetContext->asRenderTargetProxy());
}
} else {
return fContext->fGpu->writePixels(dstSurface, left, top, width, height, srcConfig,
buffer, rowBytes);
return fContext->fGpu->writePixels(dstSurface, dstProxy->origin(), left, top, width,
height, srcConfig, buffer, rowBytes);
}
return true;
}
@ -564,7 +564,7 @@ bool GrContextPriv::readSurfacePixels(GrSurfaceContext* src,
GrGpu::DrawPreference drawPreference = unpremulOnGpu ? GrGpu::kCallerPrefersDraw_DrawPreference
: GrGpu::kNoDraw_DrawPreference;
GrGpu::ReadPixelTempDrawInfo tempDrawInfo;
if (!fContext->fGpu->getReadPixelsInfo(srcSurface, width, height, rowBytes,
if (!fContext->fGpu->getReadPixelsInfo(srcSurface, srcProxy->origin(), width, height, rowBytes,
dstConfig, &drawPreference, &tempDrawInfo)) {
return false;
}
@ -641,7 +641,7 @@ bool GrContextPriv::readSurfacePixels(GrSurfaceContext* src,
this->flushSurfaceWrites(proxyToRead.get());
configToRead = tempDrawInfo.fReadConfig;
}
if (!fContext->fGpu->readPixels(surfaceToRead,
if (!fContext->fGpu->readPixels(surfaceToRead, proxyToRead->origin(),
left, top, width, height, configToRead, buffer, rowBytes)) {
return false;
}
@ -742,7 +742,8 @@ sk_sp<GrTextureContext> GrContextPriv::makeBackendTextureContext(const GrBackend
sk_sp<SkColorSpace> colorSpace) {
ASSERT_SINGLE_OWNER_PRIV
sk_sp<GrSurface> surface(fContext->resourceProvider()->wrapBackendTexture(tex, origin));
SkASSERT(kDefault_GrSurfaceOrigin != origin);
sk_sp<GrSurface> surface(fContext->resourceProvider()->wrapBackendTexture(tex));
if (!surface) {
return nullptr;
}
@ -763,8 +764,10 @@ sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendTextureRenderTargetContex
const SkSurfaceProps* props) {
ASSERT_SINGLE_OWNER_PRIV
SkASSERT(kDefault_GrSurfaceOrigin != origin);
sk_sp<GrSurface> surface(
fContext->resourceProvider()->wrapRenderableBackendTexture(tex, origin, sampleCnt));
fContext->resourceProvider()->wrapRenderableBackendTexture(tex, sampleCnt));
if (!surface) {
return nullptr;
}
@ -785,8 +788,8 @@ sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendRenderTargetRenderTargetC
const SkSurfaceProps* surfaceProps) {
ASSERT_SINGLE_OWNER_PRIV
sk_sp<GrRenderTarget> rt(fContext->resourceProvider()->wrapBackendRenderTarget(backendRT,
origin));
SkASSERT(kDefault_GrSurfaceOrigin != origin);
sk_sp<GrRenderTarget> rt(fContext->resourceProvider()->wrapBackendRenderTarget(backendRT));
if (!rt) {
return nullptr;
}
@ -809,9 +812,9 @@ sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendTextureAsRenderTargetRend
const SkSurfaceProps* surfaceProps) {
ASSERT_SINGLE_OWNER_PRIV
SkASSERT(kDefault_GrSurfaceOrigin != origin);
sk_sp<GrSurface> surface(fContext->resourceProvider()->wrapBackendTextureAsRenderTarget(
tex,
origin,
sampleCnt));
if (!surface) {
return nullptr;

2
src/gpu/GrDrawingManager.cpp
View File

@ -220,7 +220,7 @@ void GrDrawingManager::prepareSurfaceForExternalIO(GrSurfaceProxy* proxy) {
GrSurface* surface = proxy->priv().peekSurface();
if (fContext->getGpu() && surface->asRenderTarget()) {
fContext->getGpu()->resolveRenderTarget(surface->asRenderTarget());
fContext->getGpu()->resolveRenderTarget(surface->asRenderTarget(), proxy->origin());
}
}

71
src/gpu/GrGpu.cpp
View File

@ -68,17 +68,6 @@ bool GrGpu::isACopyNeededForTextureParams(int width, int height,
return false;
}
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;
}
}
/**
* Prior to creating a texture, make sure the type of texture being created is
* supported by calling check_texture_creation_params.
@ -146,8 +135,7 @@ sk_sp<GrTexture> GrGpu::createTexture(const GrSurfaceDesc& origDesc, SkBudgeted
desc.fSampleCnt = caps->getSampleCount(desc.fSampleCnt, desc.fConfig);
// Attempt to catch un- or wrongly initialized sample counts.
SkASSERT(desc.fSampleCnt >= 0 && desc.fSampleCnt <= 64);
desc.fOrigin = resolve_origin(desc.fOrigin, isRT);
SkASSERT(kDefault_GrSurfaceOrigin != desc.fOrigin);
if (mipLevelCount && (desc.fFlags & kPerformInitialClear_GrSurfaceFlag)) {
return nullptr;
@ -174,7 +162,6 @@ sk_sp<GrTexture> GrGpu::createTexture(const GrSurfaceDesc& desc, SkBudgeted budg
}
sk_sp<GrTexture> GrGpu::wrapBackendTexture(const GrBackendTexture& backendTex,
GrSurfaceOrigin origin,
GrWrapOwnership ownership) {
this->handleDirtyContext();
if (!this->caps()->isConfigTexturable(backendTex.config())) {
@ -184,7 +171,7 @@ sk_sp<GrTexture> GrGpu::wrapBackendTexture(const GrBackendTexture& backendTex,
backendTex.height() > this->caps()->maxTextureSize()) {
return nullptr;
}
sk_sp<GrTexture> tex = this->onWrapBackendTexture(backendTex, origin, ownership);
sk_sp<GrTexture> tex = this->onWrapBackendTexture(backendTex, ownership);
if (!tex) {
return nullptr;
}
@ -192,8 +179,7 @@ sk_sp<GrTexture> GrGpu::wrapBackendTexture(const GrBackendTexture& backendTex,
}
sk_sp<GrTexture> GrGpu::wrapRenderableBackendTexture(const GrBackendTexture& backendTex,
GrSurfaceOrigin origin, int sampleCnt,
GrWrapOwnership ownership) {
int sampleCnt, GrWrapOwnership ownership) {
this->handleDirtyContext();
if (!this->caps()->isConfigTexturable(backendTex.config()) ||
!this->caps()->isConfigRenderable(backendTex.config(), sampleCnt > 0)) {
@ -205,7 +191,7 @@ sk_sp<GrTexture> GrGpu::wrapRenderableBackendTexture(const GrBackendTexture& bac
return nullptr;
}
sk_sp<GrTexture> tex =
this->onWrapRenderableBackendTexture(backendTex, origin, sampleCnt, ownership);
this->onWrapRenderableBackendTexture(backendTex, sampleCnt, ownership);
if (!tex) {
return nullptr;
}
@ -219,17 +205,15 @@ sk_sp<GrTexture> GrGpu::wrapRenderableBackendTexture(const GrBackendTexture& bac
return tex;
}
sk_sp<GrRenderTarget> GrGpu::wrapBackendRenderTarget(const GrBackendRenderTarget& backendRT,
GrSurfaceOrigin origin) {
sk_sp<GrRenderTarget> GrGpu::wrapBackendRenderTarget(const GrBackendRenderTarget& backendRT) {
if (!this->caps()->isConfigRenderable(backendRT.config(), backendRT.sampleCnt() > 0)) {
return nullptr;
}
this->handleDirtyContext();
return this->onWrapBackendRenderTarget(backendRT, origin);
return this->onWrapBackendRenderTarget(backendRT);
}
sk_sp<GrRenderTarget> GrGpu::wrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
GrSurfaceOrigin origin,
int sampleCnt) {
this->handleDirtyContext();
if (!this->caps()->isConfigRenderable(tex.config(), sampleCnt > 0)) {
@ -239,7 +223,7 @@ sk_sp<GrRenderTarget> GrGpu::wrapBackendTextureAsRenderTarget(const GrBackendTex
if (tex.width() > maxSize || tex.height() > maxSize) {
return nullptr;
}
return this->onWrapBackendTextureAsRenderTarget(tex, origin, sampleCnt);
return this->onWrapBackendTextureAsRenderTarget(tex, sampleCnt);
}
GrBuffer* GrGpu::createBuffer(size_t size, GrBufferType intendedType,
@ -262,10 +246,9 @@ gr_instanced::InstancedRendering* GrGpu::createInstancedRendering() {
return this->onCreateInstancedRendering();
}
bool GrGpu::copySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
bool GrGpu::copySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint) {
GR_CREATE_TRACE_MARKER_CONTEXT("GrGpu", "copySurface", fContext);
SkASSERT(dst && src);
this->handleDirtyContext();
@ -273,10 +256,11 @@ bool GrGpu::copySurface(GrSurface* dst,
if (GrPixelConfigIsSint(dst->config()) != GrPixelConfigIsSint(src->config())) {
return false;
}
return this->onCopySurface(dst, src, srcRect, dstPoint);
return this->onCopySurface(dst, dstOrigin, src, srcOrigin, srcRect, dstPoint);
}
bool GrGpu::getReadPixelsInfo(GrSurface* srcSurface, int width, int height, size_t rowBytes,
bool GrGpu::getReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin,
int width, int height, size_t rowBytes,
GrPixelConfig readConfig, DrawPreference* drawPreference,
ReadPixelTempDrawInfo* tempDrawInfo) {
SkASSERT(drawPreference);
@ -290,8 +274,8 @@ bool GrGpu::getReadPixelsInfo(GrSurface* srcSurface, int width, int height, size
return false;
}
if (!this->onGetReadPixelsInfo(srcSurface, width, height, rowBytes, readConfig, drawPreference,
tempDrawInfo)) {
if (!this->onGetReadPixelsInfo(srcSurface, srcOrigin, width, height, rowBytes, readConfig,
drawPreference, tempDrawInfo)) {
return false;
}
@ -307,7 +291,8 @@ bool GrGpu::getReadPixelsInfo(GrSurface* srcSurface, int width, int height, size
return true;
}
bool GrGpu::getWritePixelsInfo(GrSurface* dstSurface, int width, int height,
bool GrGpu::getWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin,
int width, int height,
GrPixelConfig srcConfig, DrawPreference* drawPreference,
WritePixelTempDrawInfo* tempDrawInfo) {
SkASSERT(drawPreference);
@ -315,7 +300,7 @@ bool GrGpu::getWritePixelsInfo(GrSurface* dstSurface, int width, int height,
SkASSERT(dstSurface);
SkASSERT(kGpuPrefersDraw_DrawPreference != *drawPreference);
if (!this->onGetWritePixelsInfo(dstSurface, width, height, srcConfig, drawPreference,
if (!this->onGetWritePixelsInfo(dstSurface, dstOrigin, width, height, srcConfig, drawPreference,
tempDrawInfo)) {
return false;
}
@ -333,7 +318,7 @@ bool GrGpu::getWritePixelsInfo(GrSurface* dstSurface, int width, int height,
return true;
}
bool GrGpu::readPixels(GrSurface* surface,
bool GrGpu::readPixels(GrSurface* surface, GrSurfaceOrigin origin,
int left, int top, int width, int height,
GrPixelConfig config, void* buffer,
size_t rowBytes) {
@ -354,13 +339,13 @@ bool GrGpu::readPixels(GrSurface* surface,
this->handleDirtyContext();
return this->onReadPixels(surface,
return this->onReadPixels(surface, origin,
left, top, width, height,
config, buffer,
rowBytes);
}
bool GrGpu::writePixels(GrSurface* surface,
bool GrGpu::writePixels(GrSurface* surface, GrSurfaceOrigin origin,
int left, int top, int width, int height,
GrPixelConfig config, const GrMipLevel texels[], int mipLevelCount) {
SkASSERT(surface);
@ -388,7 +373,8 @@ bool GrGpu::writePixels(GrSurface* surface,
}
this->handleDirtyContext();
if (this->onWritePixels(surface, left, top, width, height, config, texels, mipLevelCount)) {
if (this->onWritePixels(surface, origin, left, top, width, height, config,
texels, mipLevelCount)) {
SkIRect rect = SkIRect::MakeXYWH(left, top, width, height);
this->didWriteToSurface(surface, &rect, mipLevelCount);
fStats.incTextureUploads();
@ -397,13 +383,13 @@ bool GrGpu::writePixels(GrSurface* surface,
return false;
}
bool GrGpu::writePixels(GrSurface* surface,
bool GrGpu::writePixels(GrSurface* surface, GrSurfaceOrigin origin,
int left, int top, int width, int height,
GrPixelConfig config, const void* buffer,
size_t rowBytes) {
GrMipLevel mipLevel = { buffer, rowBytes };
return this->writePixels(surface, left, top, width, height, config, &mipLevel, 1);
return this->writePixels(surface, origin, left, top, width, height, config, &mipLevel, 1);
}
bool GrGpu::transferPixels(GrTexture* texture,
@ -436,10 +422,10 @@ bool GrGpu::transferPixels(GrTexture* texture,
return false;
}
void GrGpu::resolveRenderTarget(GrRenderTarget* target) {
void GrGpu::resolveRenderTarget(GrRenderTarget* target, GrSurfaceOrigin origin) {
SkASSERT(target);
this->handleDirtyContext();
this->onResolveRenderTarget(target);
this->onResolveRenderTarget(target, origin);
}
void GrGpu::didWriteToSurface(GrSurface* surface, const SkIRect* bounds, uint32_t mipLevels) const {
@ -470,7 +456,8 @@ const GrGpu::MultisampleSpecs& GrGpu::queryMultisampleSpecs(const GrPipeline& pi
int effectiveSampleCnt;
SkSTArray<16, SkPoint, true> pattern;
this->onQueryMultisampleSpecs(rt, stencil, &effectiveSampleCnt, &pattern);
this->onQueryMultisampleSpecs(rt, pipeline.proxy()->origin(), stencil,
&effectiveSampleCnt, &pattern);
SkASSERT(effectiveSampleCnt >= rt->numStencilSamples());
uint8_t id;

57
src/gpu/GrGpu.h
View File

@ -118,24 +118,23 @@ public:
/**
* Implements GrResourceProvider::wrapBackendTexture
*/
sk_sp<GrTexture> wrapBackendTexture(const GrBackendTexture&, GrSurfaceOrigin, GrWrapOwnership);
sk_sp<GrTexture> wrapBackendTexture(const GrBackendTexture&, GrWrapOwnership);
/**
* Implements GrResourceProvider::wrapRenderableBackendTexture
*/
sk_sp<GrTexture> wrapRenderableBackendTexture(const GrBackendTexture&, GrSurfaceOrigin,
sk_sp<GrTexture> wrapRenderableBackendTexture(const GrBackendTexture&,
int sampleCnt, GrWrapOwnership);
/**
* Implements GrResourceProvider::wrapBackendRenderTarget
*/
sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTarget&, GrSurfaceOrigin);
sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTarget&);
/**
* Implements GrResourceProvider::wrapBackendTextureAsRenderTarget
*/
sk_sp<GrRenderTarget> wrapBackendTextureAsRenderTarget(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt);
/**
@ -160,7 +159,7 @@ public:
/**
* Resolves MSAA.
*/
void resolveRenderTarget(GrRenderTarget* target);
void resolveRenderTarget(GrRenderTarget*, GrSurfaceOrigin);
/** Info struct returned by getReadPixelsInfo about performing intermediate draws before
reading pixels for performance or correctness. */
@ -210,7 +209,8 @@ public:
* that would allow a successful readPixels call. The passed width, height, and rowBytes,
* must be non-zero and already reflect clipping to the src bounds.
*/
bool getReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
bool getReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin,
int readWidth, int readHeight, size_t rowBytes,
GrPixelConfig readConfig, DrawPreference*, ReadPixelTempDrawInfo*);
/** Info struct returned by getWritePixelsInfo about performing an intermediate draw in order
@ -236,7 +236,7 @@ public:
* that would allow a successful transfer of the src pixels to the dst. The passed width,
* height, and rowBytes, must be non-zero and already reflect clipping to the dst bounds.
*/
bool getWritePixelsInfo(GrSurface* dstSurface, int width, int height,
bool getWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin, int width, int height,
GrPixelConfig srcConfig, DrawPreference*, WritePixelTempDrawInfo*);
/**
@ -258,7 +258,7 @@ public:
* because of a unsupported pixel config or because no render
* target is currently set.
*/
bool readPixels(GrSurface* surface,
bool readPixels(GrSurface* surface, GrSurfaceOrigin,
int left, int top, int width, int height,
GrPixelConfig config, void* buffer, size_t rowBytes);
@ -274,7 +274,7 @@ public:
* @param texels array of mipmap levels containing texture data
* @param mipLevelCount number of levels in 'texels'
*/
bool writePixels(GrSurface* surface,
bool writePixels(GrSurface* surface, GrSurfaceOrigin origin,
int left, int top, int width, int height,
GrPixelConfig config,
const GrMipLevel texels[], int mipLevelCount);
@ -287,7 +287,7 @@ public:
* @param rowBytes number of bytes between consecutive rows. Zero
* means rows are tightly packed.
*/
bool writePixels(GrSurface* surface,
bool writePixels(GrSurface* surface, GrSurfaceOrigin origin,
int left, int top, int width, int height,
GrPixelConfig config, const void* buffer,
size_t rowBytes);
@ -333,8 +333,8 @@ public:
// take place at the GrOpList level and this function implement faster copy paths. The rect
// and point are pre-clipped. The src rect and implied dst rect are guaranteed to be within the
// src/dst bounds and non-empty.
bool copySurface(GrSurface* dst,
GrSurface* src,
bool copySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
@ -548,18 +548,13 @@ private:
const GrMipLevel texels[],
int mipLevelCount) = 0;
virtual sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
GrSurfaceOrigin,
GrWrapOwnership) = 0;
virtual sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrWrapOwnership) = 0;
virtual sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt,
GrWrapOwnership) = 0;
virtual sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
GrSurfaceOrigin) = 0;
virtual sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) = 0;
virtual sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt)=0;
int sampleCnt) = 0;
virtual GrBuffer* onCreateBuffer(size_t size, GrBufferType intendedType, GrAccessPattern,
const void* data) = 0;
@ -574,15 +569,17 @@ private:
return false;
}
virtual bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight,
virtual bool onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin,
int readWidth, int readHeight,
size_t rowBytes, GrPixelConfig readConfig, DrawPreference*,
ReadPixelTempDrawInfo*) = 0;
virtual bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
virtual bool onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin,
int width, int height,
GrPixelConfig srcConfig, DrawPreference*,
WritePixelTempDrawInfo*) = 0;
// overridden by backend-specific derived class to perform the surface read
virtual bool onReadPixels(GrSurface*,
virtual bool onReadPixels(GrSurface*, GrSurfaceOrigin,
int left, int top,
int width, int height,
GrPixelConfig,
@ -590,7 +587,7 @@ private:
size_t rowBytes) = 0;
// overridden by backend-specific derived class to perform the surface write
virtual bool onWritePixels(GrSurface*,
virtual bool onWritePixels(GrSurface*, GrSurfaceOrigin,
int left, int top, int width, int height,
GrPixelConfig config,
const GrMipLevel texels[], int mipLevelCount) = 0;
@ -602,16 +599,16 @@ private:
size_t offset, size_t rowBytes) = 0;
// overridden by backend-specific derived class to perform the resolve
virtual void onResolveRenderTarget(GrRenderTarget* target) = 0;
virtual void onResolveRenderTarget(GrRenderTarget* target, GrSurfaceOrigin) = 0;
// overridden by backend specific derived class to perform the copy surface
virtual bool onCopySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) = 0;
virtual bool onCopySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint) = 0;
// overridden by backend specific derived class to perform the multisample queries
virtual void onQueryMultisampleSpecs(GrRenderTarget*, const GrStencilSettings&,
virtual void onQueryMultisampleSpecs(GrRenderTarget*, GrSurfaceOrigin rtOrigin,
const GrStencilSettings&,
int* effectiveSampleCnt, SamplePattern*) = 0;
void resetContext() {

8
src/gpu/GrOpFlushState.cpp
View File

@ -58,10 +58,10 @@ void GrOpFlushState::doUpload(GrDrawOp::DeferredUploadFn& upload) {
GrSurface* surface = proxy->priv().peekSurface();
GrGpu::DrawPreference drawPreference = GrGpu::kNoDraw_DrawPreference;
GrGpu::WritePixelTempDrawInfo tempInfo;
fGpu->getWritePixelsInfo(surface, width, height, proxy->config(),
fGpu->getWritePixelsInfo(surface, proxy->origin(), width, height, proxy->config(),
&drawPreference, &tempInfo);
if (GrGpu::kNoDraw_DrawPreference == drawPreference) {
return this->fGpu->writePixels(surface, left, top, width, height,
return this->fGpu->writePixels(surface, proxy->origin(), left, top, width, height,
config, buffer, rowBytes);
}
GrSurfaceDesc desc;
@ -74,11 +74,11 @@ void GrOpFlushState::doUpload(GrDrawOp::DeferredUploadFn& upload) {
if (!temp) {
return false;
}
if (!fGpu->writePixels(temp.get(), 0, 0, width, height, desc.fConfig,
if (!fGpu->writePixels(temp.get(), proxy->origin(), 0, 0, width, height, desc.fConfig,
buffer, rowBytes)) {
return false;
}
return fGpu->copySurface(surface, temp.get(),
return fGpu->copySurface(surface, proxy->origin(), temp.get(), proxy->origin(),
SkIRect::MakeWH(width, height), {left, top});
};
upload(wp);

1
src/gpu/GrPipeline.cpp
View File

@ -19,6 +19,7 @@
void GrPipeline::init(const InitArgs& args) {
SkASSERT(args.fProxy);
SkASSERT(kDefault_GrSurfaceOrigin != args.fProxy->origin());
SkASSERT(args.fProcessors);
SkASSERT(args.fProcessors->isFinalized());

19
src/gpu/GrResourceProvider.cpp
View File

@ -98,6 +98,8 @@ sk_sp<GrTexture> GrResourceProvider::createTexture(const GrSurfaceDesc& desc, Sk
sk_sp<GrTexture> GrResourceProvider::getExactScratch(const GrSurfaceDesc& desc,
SkBudgeted budgeted, uint32_t flags) {
SkASSERT(desc.fOrigin != kDefault_GrSurfaceOrigin);
flags |= kExact_Flag | kNoCreate_Flag;
sk_sp<GrTexture> tex(this->refScratchTexture(desc, flags));
if (tex && SkBudgeted::kNo == budgeted) {
@ -159,6 +161,7 @@ sk_sp<GrTextureProxy> GrResourceProvider::createTextureProxy(const GrSurfaceDesc
sk_sp<GrTexture> GrResourceProvider::createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
uint32_t flags) {
ASSERT_SINGLE_OWNER
SkASSERT(desc.fOrigin != kDefault_GrSurfaceOrigin);
if (this->isAbandoned()) {
return nullptr;
@ -180,6 +183,7 @@ sk_sp<GrTexture> GrResourceProvider::createApproxTexture(const GrSurfaceDesc& de
uint32_t flags) {
ASSERT_SINGLE_OWNER
SkASSERT(0 == flags || kNoPendingIO_Flag == flags);
SkASSERT(kDefault_GrSurfaceOrigin != desc.fOrigin);
if (this->isAbandoned()) {
return nullptr;
@ -197,6 +201,7 @@ sk_sp<GrTexture> GrResourceProvider::refScratchTexture(const GrSurfaceDesc& inDe
ASSERT_SINGLE_OWNER
SkASSERT(!this->isAbandoned());
SkASSERT(validate_desc(inDesc, *fCaps));
SkASSERT(inDesc.fOrigin != kDefault_GrSurfaceOrigin);
SkTCopyOnFirstWrite<GrSurfaceDesc> desc(inDesc);
@ -238,31 +243,29 @@ sk_sp<GrTexture> GrResourceProvider::refScratchTexture(const GrSurfaceDesc& inDe
}
sk_sp<GrTexture> GrResourceProvider::wrapBackendTexture(const GrBackendTexture& tex,
GrSurfaceOrigin origin,
GrWrapOwnership ownership) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned()) {
return nullptr;
}
return fGpu->wrapBackendTexture(tex, origin, ownership);
return fGpu->wrapBackendTexture(tex, ownership);
}
sk_sp<GrTexture> GrResourceProvider::wrapRenderableBackendTexture(const GrBackendTexture& tex,
GrSurfaceOrigin origin,
int sampleCnt,
GrWrapOwnership ownership) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned()) {
return nullptr;
}
return fGpu->wrapRenderableBackendTexture(tex, origin, sampleCnt, ownership);
return fGpu->wrapRenderableBackendTexture(tex, sampleCnt, ownership);
}
sk_sp<GrRenderTarget> GrResourceProvider::wrapBackendRenderTarget(
const GrBackendRenderTarget& backendRT, GrSurfaceOrigin origin)
const GrBackendRenderTarget& backendRT)
{
ASSERT_SINGLE_OWNER
return this->isAbandoned() ? nullptr : fGpu->wrapBackendRenderTarget(backendRT, origin);
return this->isAbandoned() ? nullptr : fGpu->wrapBackendRenderTarget(backendRT);
}
void GrResourceProvider::assignUniqueKeyToResource(const GrUniqueKey& key,
@ -481,12 +484,12 @@ GrStencilAttachment* GrResourceProvider::attachStencilAttachment(GrRenderTarget*
}
sk_sp<GrRenderTarget> GrResourceProvider::wrapBackendTextureAsRenderTarget(
const GrBackendTexture& tex, GrSurfaceOrigin origin, int sampleCnt)
const GrBackendTexture& tex, int sampleCnt)
{
if (this->isAbandoned()) {
return nullptr;
}
return this->gpu()->wrapBackendTextureAsRenderTarget(tex, origin, sampleCnt);
return this->gpu()->wrapBackendTextureAsRenderTarget(tex, sampleCnt);
}
sk_sp<GrSemaphore> SK_WARN_UNUSED_RESULT GrResourceProvider::makeSemaphore(bool isOwned) {

5
src/gpu/GrResourceProvider.h
View File

@ -87,7 +87,6 @@ public:
* @return GrTexture object or NULL on failure.
*/
sk_sp<GrTexture> wrapBackendTexture(const GrBackendTexture& tex,
GrSurfaceOrigin origin,
GrWrapOwnership = kBorrow_GrWrapOwnership);
/**
@ -96,7 +95,6 @@ public:
* to the texture.
*/
sk_sp<GrTexture> wrapRenderableBackendTexture(const GrBackendTexture& tex,
GrSurfaceOrigin origin,
int sampleCnt,
GrWrapOwnership = kBorrow_GrWrapOwnership);
@ -109,7 +107,7 @@ public:
*
* @return GrRenderTarget object or NULL on failure.
*/
sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTarget&, GrSurfaceOrigin);
sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTarget&);
static const uint32_t kMinScratchTextureSize;
@ -212,7 +210,6 @@ public:
* @return GrRenderTarget object or NULL on failure.
*/
sk_sp<GrRenderTarget> wrapBackendTextureAsRenderTarget(const GrBackendTexture&,
GrSurfaceOrigin origin,
int sampleCnt);
/**

10
src/gpu/GrSurfaceProxy.cpp
View File

@ -34,7 +34,6 @@ GrSurfaceProxy::GrSurfaceProxy(sk_sp<GrSurface> surface, GrSurfaceOrigin origin,
, fGpuMemorySize(kInvalidGpuMemorySize)
, fLastOpList(nullptr) {
SkASSERT(kDefault_GrSurfaceOrigin != fOrigin);
SkASSERT(fTarget->origin() == fOrigin);
}
GrSurfaceProxy::~GrSurfaceProxy() {
@ -47,6 +46,8 @@ sk_sp<GrSurface> GrSurfaceProxy::createSurfaceImpl(
GrResourceProvider* resourceProvider, int sampleCnt,
GrSurfaceFlags flags, bool isMipMapped,
SkDestinationSurfaceColorMode mipColorMode) const {
SkASSERT(kDefault_GrSurfaceOrigin != fOrigin);
GrSurfaceDesc desc;
desc.fFlags = flags;
if (fNeedsClear) {
@ -122,8 +123,7 @@ void GrSurfaceProxy::computeScratchKey(GrScratchKey* key) const {
height = SkTMax(GrResourceProvider::kMinScratchTextureSize, GrNextPow2(height));
}
GrTexturePriv::ComputeScratchKey(this->config(), width, height,
this->origin(), SkToBool(rtp), sampleCount,
GrTexturePriv::ComputeScratchKey(this->config(), width, height, SkToBool(rtp), sampleCount,
hasMipMaps, key);
}
@ -183,6 +183,7 @@ sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferred(GrResourceProvider* resourceP
SkBudgeted budgeted,
uint32_t flags) {
SkASSERT(0 == flags || GrResourceProvider::kNoPendingIO_Flag == flags);
SkASSERT(kDefault_GrSurfaceOrigin != desc.fOrigin);
const GrCaps* caps = resourceProvider->caps();
@ -277,7 +278,8 @@ sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferredMipMap(
sk_sp<GrTextureProxy> GrSurfaceProxy::MakeWrappedBackend(GrContext* context,
GrBackendTexture& backendTex,
GrSurfaceOrigin origin) {
sk_sp<GrTexture> tex(context->resourceProvider()->wrapBackendTexture(backendTex, origin));
SkASSERT(kDefault_GrSurfaceOrigin != origin);
sk_sp<GrTexture> tex(context->resourceProvider()->wrapBackendTexture(backendTex));
return GrSurfaceProxy::MakeWrapped(std::move(tex), origin);
}

31
src/gpu/GrTexture.cpp
View File

@ -40,24 +40,6 @@ size_t GrTexture::onGpuMemorySize() const {
}
/////////////////////////////////////////////////////////////////////////////
namespace {
// FIXME: This should be refactored with the code in gl/GrGLGpu.cpp.
GrSurfaceOrigin resolve_origin(const GrSurfaceDesc& desc) {
// 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.
bool renderTarget = 0 != (desc.fFlags & kRenderTarget_GrSurfaceFlag);
if (kDefault_GrSurfaceOrigin == desc.fOrigin) {
return renderTarget ? kBottomLeft_GrSurfaceOrigin : kTopLeft_GrSurfaceOrigin;
} else {
return desc.fOrigin;
}
}
}
//////////////////////////////////////////////////////////////////////////////
GrTexture::GrTexture(GrGpu* gpu, const GrSurfaceDesc& desc, GrSLType samplerType,
GrSamplerParams::FilterMode highestFilterMode, bool wasMipMapDataProvided)
: INHERITED(gpu, desc)
@ -81,12 +63,12 @@ void GrTexture::computeScratchKey(GrScratchKey* key) const {
sampleCount = rt->numStencilSamples();
}
GrTexturePriv::ComputeScratchKey(this->config(), this->width(), this->height(),
this->origin(), SkToBool(rt), sampleCount,
SkToBool(rt), sampleCount,
this->texturePriv().hasMipMaps(), key);
}
void GrTexturePriv::ComputeScratchKey(GrPixelConfig config, int width, int height,
GrSurfaceOrigin origin, bool isRenderTarget, int sampleCnt,
bool isRenderTarget, int sampleCnt,
bool isMipMapped, GrScratchKey* key) {
static const GrScratchKey::ResourceType kType = GrScratchKey::GenerateResourceType();
uint32_t flags = isRenderTarget;
@ -98,17 +80,18 @@ void GrTexturePriv::ComputeScratchKey(GrPixelConfig config, int width, int heigh
SkASSERT(static_cast<int>(config) < (1 << 5));
SkASSERT(sampleCnt < (1 << 8));
SkASSERT(flags < (1 << 10));
SkASSERT(static_cast<int>(origin) < (1 << 8));
GrScratchKey::Builder builder(key, kType, 3);
builder[0] = width;
builder[1] = height;
builder[2] = config | (isMipMapped << 5) | (sampleCnt << 6) | (flags << 14) | (origin << 24);
builder[2] = config | (isMipMapped << 5) | (sampleCnt << 6) | (flags << 14);
}
void GrTexturePriv::ComputeScratchKey(const GrSurfaceDesc& desc, GrScratchKey* key) {
GrSurfaceOrigin origin = resolve_origin(desc);
return ComputeScratchKey(desc.fConfig, desc.fWidth, desc.fHeight, origin,
SkASSERT(kDefault_GrSurfaceOrigin != desc.fOrigin);
// Note: the fOrigin field is not used in the scratch key
return ComputeScratchKey(desc.fConfig, desc.fWidth, desc.fHeight,
SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag), desc.fSampleCnt,
desc.fIsMipMapped, key);
}

2
src/gpu/GrTexturePriv.h
View File

@ -57,7 +57,7 @@ public:
static void ComputeScratchKey(const GrSurfaceDesc&, GrScratchKey*);
static void ComputeScratchKey(GrPixelConfig config, int width, int height,
GrSurfaceOrigin origin, bool isRenderTarget, int sampleCnt,
bool isRenderTarget, int sampleCnt,
bool isMipMapped, GrScratchKey* key);

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

@ -551,7 +551,6 @@ static bool check_backend_texture(const GrBackendTexture& backendTex, const GrGL
}
sk_sp<GrTexture> GrGLGpu::onWrapBackendTexture(const GrBackendTexture& backendTex,
GrSurfaceOrigin origin,
GrWrapOwnership ownership) {
GrGLTexture::IDDesc idDesc;
if (!check_backend_texture(backendTex, this->glCaps(), &idDesc)) {
@ -565,24 +564,16 @@ sk_sp<GrTexture> GrGLGpu::onWrapBackendTexture(const GrBackendTexture& backendTe
GrSurfaceDesc surfDesc;
surfDesc.fFlags = kNone_GrSurfaceFlags;
surfDesc.fOrigin = kTopLeft_GrSurfaceOrigin; // This isn't used in the following
surfDesc.fWidth = backendTex.width();
surfDesc.fHeight = backendTex.height();
surfDesc.fConfig = backendTex.config();
surfDesc.fSampleCnt = 0;
// FIXME: this should be calling resolve_origin(), but Chrome code is currently
// assuming the old behaviour, which is that backend textures are always
// BottomLeft, even for non-RT's. Once Chrome is fixed, change this to:
// glTexDesc.fOrigin = resolve_origin(desc.fOrigin, renderTarget);
if (kDefault_GrSurfaceOrigin == origin) {
surfDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
} else {
surfDesc.fOrigin = origin;
}
return GrGLTexture::MakeWrapped(this, surfDesc, idDesc);
}
sk_sp<GrTexture> GrGLGpu::onWrapRenderableBackendTexture(const GrBackendTexture& backendTex,
GrSurfaceOrigin origin,
int sampleCnt,
GrWrapOwnership ownership) {
GrGLTexture::IDDesc idDesc;
@ -603,19 +594,11 @@ sk_sp<GrTexture> GrGLGpu::onWrapRenderableBackendTexture(const GrBackendTexture&
GrSurfaceDesc surfDesc;
surfDesc.fFlags = kRenderTarget_GrSurfaceFlag;
surfDesc.fOrigin = kBottomLeft_GrSurfaceOrigin; // This isn't actually used in the following
surfDesc.fWidth = backendTex.width();
surfDesc.fHeight = backendTex.height();
surfDesc.fConfig = backendTex.config();
surfDesc.fSampleCnt = this->caps()->getSampleCount(sampleCnt, backendTex.config());
// FIXME: this should be calling resolve_origin(), but Chrome code is currently
// assuming the old behaviour, which is that backend textures are always
// BottomLeft, even for non-RT's. Once Chrome is fixed, change this to:
// glTexDesc.fOrigin = resolve_origin(desc.fOrigin, renderTarget);
if (kDefault_GrSurfaceOrigin == origin) {
surfDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
} else {
surfDesc.fOrigin = origin;
}
GrGLRenderTarget::IDDesc rtIDDesc;
if (!this->createRenderTargetObjects(surfDesc, idDesc.fInfo, &rtIDDesc)) {
@ -627,8 +610,7 @@ sk_sp<GrTexture> GrGLGpu::onWrapRenderableBackendTexture(const GrBackendTexture&
return std::move(texRT);
}
sk_sp<GrRenderTarget> GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT,
GrSurfaceOrigin origin) {
sk_sp<GrRenderTarget> GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT) {
const GrGLFramebufferInfo* info = backendRT.getGLFramebufferInfo();
if (!info) {
return nullptr;
@ -642,19 +624,17 @@ sk_sp<GrRenderTarget> GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTa
idDesc.fIsMixedSampled = false;
GrSurfaceDesc desc;
desc.fConfig = backendRT.config();
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin; // This isn't actually used in the following
desc.fWidth = backendRT.width();
desc.fHeight = backendRT.height();
desc.fConfig = backendRT.config();
desc.fSampleCnt = this->caps()->getSampleCount(backendRT.sampleCnt(), backendRT.config());
SkASSERT(kDefault_GrSurfaceOrigin != origin);
desc.fOrigin = origin;
return GrGLRenderTarget::MakeWrapped(this, desc, idDesc, backendRT.stencilBits());
}
sk_sp<GrRenderTarget> GrGLGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
GrSurfaceOrigin origin,
int sampleCnt) {
const GrGLTextureInfo* info = tex.getGLTextureInfo();
if (!info || !info->fID) {
@ -674,19 +654,11 @@ sk_sp<GrRenderTarget> GrGLGpu::onWrapBackendTextureAsRenderTarget(const GrBacken
GrSurfaceDesc surfDesc;
surfDesc.fFlags = kRenderTarget_GrSurfaceFlag;
surfDesc.fOrigin = kBottomLeft_GrSurfaceOrigin; // This isn't actually used in the following
surfDesc.fWidth = tex.width();
surfDesc.fHeight = tex.height();
surfDesc.fConfig = tex.config();
surfDesc.fSampleCnt = this->caps()->getSampleCount(sampleCnt, tex.config());
// FIXME: this should be calling resolve_origin(), but Chrome code is currently
// assuming the old behaviour, which is that backend textures are always
// BottomLeft, even for non-RT's. Once Chrome is fixed, change this to:
// glTexDesc.fOrigin = resolve_origin(desc.fOrigin, renderTarget);
if (kDefault_GrSurfaceOrigin == origin) {
surfDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
} else {
surfDesc.fOrigin = origin;
}
GrGLRenderTarget::IDDesc rtIDDesc;
if (!this->createRenderTargetObjects(surfDesc, texInfo, &rtIDDesc)) {
@ -697,7 +669,8 @@ sk_sp<GrRenderTarget> GrGLGpu::onWrapBackendTextureAsRenderTarget(const GrBacken
////////////////////////////////////////////////////////////////////////////////
bool GrGLGpu::onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
bool GrGLGpu::onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin,
int width, int height,
GrPixelConfig srcConfig,
DrawPreference* drawPreference,
WritePixelTempDrawInfo* tempDrawInfo) {
@ -772,8 +745,7 @@ bool GrGLGpu::onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
}
}
if (!this->glCaps().unpackFlipYSupport() &&
kBottomLeft_GrSurfaceOrigin == dstSurface->origin()) {
if (!this->glCaps().unpackFlipYSupport() && kBottomLeft_GrSurfaceOrigin == dstOrigin) {
ElevateDrawPreference(drawPreference, kGpuPrefersDraw_DrawPreference);
}
@ -799,7 +771,7 @@ static bool check_write_and_transfer_input(GrGLTexture* glTex, GrSurface* surfac
return true;
}
bool GrGLGpu::onWritePixels(GrSurface* surface,
bool GrGLGpu::onWritePixels(GrSurface* surface, GrSurfaceOrigin origin,
int left, int top, int width, int height,
GrPixelConfig config,
const GrMipLevel texels[],
@ -814,7 +786,7 @@ bool GrGLGpu::onWritePixels(GrSurface* surface,
GL_CALL(BindTexture(glTex->target(), glTex->textureID()));
return this->uploadTexData(glTex->config(), glTex->width(), glTex->height(),
glTex->origin(), glTex->target(), kWrite_UploadType,
origin, glTex->target(), kWrite_UploadType,
left, top, width, height, config, texels, mipLevelCount);
}
@ -1763,14 +1735,14 @@ void GrGLGpu::flushScissor(const GrScissorState& scissorState,
}
void GrGLGpu::flushWindowRectangles(const GrWindowRectsState& windowState,
const GrGLRenderTarget* rt) {
const GrGLRenderTarget* rt, GrSurfaceOrigin origin) {
#ifndef USE_NSIGHT
typedef GrWindowRectsState::Mode Mode;
SkASSERT(!windowState.enabled() || rt->renderFBOID()); // Window rects can't be used on-screen.
SkASSERT(windowState.numWindows() <= this->caps()->maxWindowRectangles());
if (!this->caps()->maxWindowRectangles() ||
fHWWindowRectsState.knownEqualTo(rt->origin(), rt->getViewport(), windowState)) {
fHWWindowRectsState.knownEqualTo(origin, rt->getViewport(), windowState)) {
return;
}
@ -1782,13 +1754,13 @@ void GrGLGpu::flushWindowRectangles(const GrWindowRectsState& windowState,
GrGLIRect glwindows[GrWindowRectangles::kMaxWindows];
const SkIRect* skwindows = windowState.windows().data();
for (int i = 0; i < numWindows; ++i) {
glwindows[i].setRelativeTo(rt->getViewport(), skwindows[i], rt->origin());
glwindows[i].setRelativeTo(rt->getViewport(), skwindows[i], origin);
}
GrGLenum glmode = (Mode::kExclusive == windowState.mode()) ? GR_GL_EXCLUSIVE : GR_GL_INCLUSIVE;
GL_CALL(WindowRectangles(glmode, numWindows, glwindows->asInts()));
fHWWindowRectsState.set(rt->origin(), rt->getViewport(), windowState);
fHWWindowRectsState.set(origin, rt->getViewport(), windowState);
#endif
}
@ -1856,7 +1828,7 @@ bool GrGLGpu::flushGLState(const GrPipeline& pipeline, const GrPrimitiveProcesso
}
this->flushStencil(stencil);
this->flushScissor(pipeline.getScissorState(), glRT->getViewport(), pipeline.proxy()->origin());
this->flushWindowRectangles(pipeline.getWindowRectsState(), glRT);
this->flushWindowRectangles(pipeline.getWindowRectsState(), glRT, pipeline.proxy()->origin());
this->flushHWAAState(glRT, pipeline.isHWAntialiasState(), !stencil.isDisabled());
// This must come after textures are flushed because a texture may need
@ -1972,7 +1944,8 @@ void GrGLGpu::disableScissor() {
}
}
void GrGLGpu::clear(const GrFixedClip& clip, GrColor color, GrRenderTarget* target) {
void GrGLGpu::clear(const GrFixedClip& clip, GrColor color,
GrRenderTarget* target, GrSurfaceOrigin origin) {
this->handleDirtyContext();
// parent class should never let us get here with no RT
@ -1980,8 +1953,8 @@ void GrGLGpu::clear(const GrFixedClip& clip, GrColor color, GrRenderTarget* targ
GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(target);
this->flushRenderTarget(glRT, clip.scissorEnabled() ? &clip.scissorRect() : nullptr);
this->flushScissor(clip.scissorState(), glRT->getViewport(), glRT->origin());
this->flushWindowRectangles(clip.windowRectsState(), glRT);
this->flushScissor(clip.scissorState(), glRT->getViewport(), origin);
this->flushWindowRectangles(clip.windowRectsState(), glRT, origin);
GrGLfloat r, g, b, a;
static const GrGLfloat scale255 = 1.f / 255.f;
@ -2022,12 +1995,12 @@ void GrGLGpu::clearStencil(GrRenderTarget* target) {
void GrGLGpu::clearStencilClip(const GrFixedClip& clip,
bool insideStencilMask,
GrRenderTarget* target) {
GrRenderTarget* target, GrSurfaceOrigin origin) {
SkASSERT(target);
this->handleDirtyContext();
if (this->glCaps().useDrawToClearStencilClip()) {
this->clearStencilClipAsDraw(clip, insideStencilMask, target);
this->clearStencilClipAsDraw(clip, insideStencilMask, target, origin);
return;
}
@ -2056,8 +2029,8 @@ void GrGLGpu::clearStencilClip(const GrFixedClip& clip,
GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(target);
this->flushRenderTarget(glRT, &SkIRect::EmptyIRect());
this->flushScissor(clip.scissorState(), glRT->getViewport(), glRT->origin());
this->flushWindowRectangles(clip.windowRectsState(), glRT);
this->flushScissor(clip.scissorState(), glRT->getViewport(), origin);
this->flushWindowRectangles(clip.windowRectsState(), glRT, origin);
GL_CALL(StencilMask((uint32_t) clipStencilMask));
GL_CALL(ClearStencil(value));
@ -2172,7 +2145,8 @@ static bool requires_srgb_conversion(GrPixelConfig a, GrPixelConfig b) {
return false;
}
bool GrGLGpu::onGetReadPixelsInfo(GrSurface* srcSurface, int width, int height, size_t rowBytes,
bool GrGLGpu::onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin,
int width, int height, size_t rowBytes,
GrPixelConfig readConfig, DrawPreference* drawPreference,
ReadPixelTempDrawInfo* tempDrawInfo) {
GrPixelConfig srcConfig = srcSurface->config();
@ -2277,7 +2251,7 @@ bool GrGLGpu::onGetReadPixelsInfo(GrSurface* srcSurface, int width, int height,
}
if ((srcSurface->asRenderTarget() || this->glCaps().canConfigBeFBOColorAttachment(srcConfig)) &&
read_pixels_pays_for_y_flip(srcSurface->origin(), this->glCaps(), width, height, readConfig,
read_pixels_pays_for_y_flip(srcOrigin, this->glCaps(), width, height, readConfig,
rowBytes)) {
ElevateDrawPreference(drawPreference, kGpuPrefersDraw_DrawPreference);
}
@ -2285,7 +2259,7 @@ bool GrGLGpu::onGetReadPixelsInfo(GrSurface* srcSurface, int width, int height,
return true;
}
bool GrGLGpu::onReadPixels(GrSurface* surface,
bool GrGLGpu::onReadPixels(GrSurface* surface, GrSurfaceOrigin origin,
int left, int top,
int width, int height,
GrPixelConfig config,
@ -2314,8 +2288,8 @@ bool GrGLGpu::onReadPixels(GrSurface* surface,
if (kAlpha_8_GrPixelConfig == config &&
this->readPixelsSupported(surface, tempConfig)) {
std::unique_ptr<uint32_t[]> temp(new uint32_t[width * height * 4]);
if (this->onReadPixels(surface, left, top, width, height, tempConfig, temp.get(),
width*4)) {
if (this->onReadPixels(surface, origin, left, top, width, height,
tempConfig, temp.get(), width*4)) {
uint8_t* dst = reinterpret_cast<uint8_t*>(buffer);
for (int j = 0; j < height; ++j) {
for (int i = 0; i < width; ++i) {
@ -2334,7 +2308,7 @@ bool GrGLGpu::onReadPixels(GrSurface* surface,
&externalType)) {
return false;
}
bool flipY = kBottomLeft_GrSurfaceOrigin == surface->origin();
bool flipY = kBottomLeft_GrSurfaceOrigin == origin;
GrGLIRect glvp;
if (renderTarget) {
@ -2346,7 +2320,7 @@ bool GrGLGpu::onReadPixels(GrSurface* surface,
this->flushRenderTarget(renderTarget, &SkIRect::EmptyIRect());
break;
case GrGLRenderTarget::kCanResolve_ResolveType:
this->onResolveRenderTarget(renderTarget);
this->onResolveRenderTarget(renderTarget, origin);
// we don't track the state of the READ FBO ID.
fStats.incRenderTargetBinds();
GL_CALL(BindFramebuffer(GR_GL_READ_FRAMEBUFFER, renderTarget->textureFBOID()));
@ -2363,7 +2337,7 @@ bool GrGLGpu::onReadPixels(GrSurface* surface,
// the read rect is viewport-relative
GrGLIRect readRect;
readRect.setRelativeTo(glvp, left, top, width, height, surface->origin());
readRect.setRelativeTo(glvp, left, top, width, height, origin);
size_t bytesPerPixel = GrBytesPerPixel(config);
size_t tightRowBytes = bytesPerPixel * width;
@ -2658,7 +2632,7 @@ void GrGLGpu::sendIndexedInstancedMeshToGpu(const GrPrimitiveProcessor& primProc
fStats.incNumDraws();
}
void GrGLGpu::onResolveRenderTarget(GrRenderTarget* target) {
void GrGLGpu::onResolveRenderTarget(GrRenderTarget* target, GrSurfaceOrigin origin) {
GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(target);
if (rt->needsResolve()) {
// Some extensions automatically resolves the texture when it is read.
@ -2678,7 +2652,7 @@ void GrGLGpu::onResolveRenderTarget(GrRenderTarget* target) {
// Apple's extension uses the scissor as the blit bounds.
GrScissorState scissorState;
scissorState.set(dirtyRect);
this->flushScissor(scissorState, vp, rt->origin());
this->flushScissor(scissorState, vp, origin);
this->disableWindowRectangles();
GL_CALL(ResolveMultisampleFramebuffer());
} else {
@ -2691,7 +2665,7 @@ void GrGLGpu::onResolveRenderTarget(GrRenderTarget* target) {
t = target->height();
} else {
GrGLIRect rect;
rect.setRelativeTo(vp, dirtyRect, target->origin());
rect.setRelativeTo(vp, dirtyRect, origin);
l = rect.fLeft;
b = rect.fBottom;
r = rect.fLeft + rect.fWidth;
@ -2944,7 +2918,7 @@ static void get_tex_param_swizzle(GrPixelConfig config,
}
void GrGLGpu::bindTexture(int unitIdx, const GrSamplerParams& params, bool allowSRGBInputs,
GrGLTexture* texture) {
GrGLTexture* texture, GrSurfaceOrigin textureOrigin) {
SkASSERT(texture);
#ifdef SK_DEBUG
@ -2964,7 +2938,7 @@ void GrGLGpu::bindTexture(int unitIdx, const GrSamplerParams& params, bool allow
// out of the "last != next" check.
GrGLRenderTarget* texRT = static_cast<GrGLRenderTarget*>(texture->asRenderTarget());
if (texRT) {
this->onResolveRenderTarget(texRT);
this->onResolveRenderTarget(texRT, textureOrigin);
}
GrGpuResource::UniqueID textureID = texture->uniqueID();
@ -3132,7 +3106,7 @@ void GrGLGpu::bindImageStorage(int unitIdx, GrIOType ioType, GrGLTexture *textur
}
void GrGLGpu::generateMipmaps(const GrSamplerParams& params, bool allowSRGBInputs,
GrGLTexture* texture) {
GrGLTexture* texture, GrSurfaceOrigin textureOrigin) {
SkASSERT(texture);
// First, figure out if we need mips for this texture at all:
@ -3168,7 +3142,7 @@ void GrGLGpu::generateMipmaps(const GrSamplerParams& params, bool allowSRGBInput
// from the rt it will still be the last bound texture, but it needs resolving.
GrGLRenderTarget* texRT = static_cast<GrGLRenderTarget*>(texture->asRenderTarget());
if (texRT) {
this->onResolveRenderTarget(texRT);
this->onResolveRenderTarget(texRT, textureOrigin);
}
GrGLenum target = texture->target();
@ -3191,7 +3165,7 @@ void GrGLGpu::generateMipmaps(const GrSamplerParams& params, bool allowSRGBInput
}
// Either do manual mipmap generation or (if that fails), just rely on the driver:
if (!this->generateMipmap(texture, allowSRGBInputs)) {
if (!this->generateMipmap(texture, textureOrigin, allowSRGBInputs)) {
GL_CALL(GenerateMipmap(target));
}
@ -3255,11 +3229,12 @@ void GrGLGpu::setScratchTextureUnit() {
}
// Determines whether glBlitFramebuffer could be used between src and dst by onCopySurface.
static inline bool can_blit_framebuffer_for_copy_surface(const GrSurface* dst,
const GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint,
const GrGLGpu* gpu) {
static inline bool can_blit_framebuffer_for_copy_surface(
const GrSurface* dst, GrSurfaceOrigin dstOrigin,
const GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect,
const SkIPoint& dstPoint,
const GrGLGpu* gpu) {
auto blitFramebufferFlags = gpu->glCaps().blitFramebufferSupportFlags();
if (!gpu->glCaps().canConfigBeFBOColorAttachment(dst->config()) ||
!gpu->glCaps().canConfigBeFBOColorAttachment(src->config())) {
@ -3284,7 +3259,7 @@ static inline bool can_blit_framebuffer_for_copy_surface(const GrSurface* dst,
if (GrGLCaps::kNoScalingOrMirroring_BlitFramebufferFlag & blitFramebufferFlags) {
// We would mirror to compensate for origin changes. Note that copySurface is
// specified such that the src and dst rects are the same.
if (dst->origin() != src->origin()) {
if (dstOrigin != srcOrigin) {
return false;
}
}
@ -3318,7 +3293,7 @@ static inline bool can_blit_framebuffer_for_copy_surface(const GrSurface* dst,
if (dstPoint.fX != srcRect.fLeft || dstPoint.fY != srcRect.fTop) {
return false;
}
if (dst->origin() != src->origin()) {
if (dstOrigin != srcOrigin) {
return false;
}
}
@ -3326,8 +3301,8 @@ static inline bool can_blit_framebuffer_for_copy_surface(const GrSurface* dst,
return true;
}
static inline bool can_copy_texsubimage(const GrSurface* dst,
const GrSurface* src,
static inline bool can_copy_texsubimage(const GrSurface* dst, GrSurfaceOrigin dstOrigin,
const GrSurface* src, GrSurfaceOrigin srcOrigin,
const GrGLGpu* gpu) {
// Table 3.9 of the ES2 spec indicates the supported formats with CopyTexSubImage
// and BGRA isn't in the spec. There doesn't appear to be any extension that adds it. Perhaps
@ -3362,7 +3337,7 @@ static inline bool can_copy_texsubimage(const GrSurface* dst,
// is required.
if (gpu->glCaps().canConfigBeFBOColorAttachment(src->config()) &&
(!srcTex || srcTex->target() == GR_GL_TEXTURE_2D) && dstTex->target() == GR_GL_TEXTURE_2D &&
dst->origin() == src->origin()) {
dstOrigin == srcOrigin) {
return true;
} else {
return false;
@ -3418,10 +3393,9 @@ void GrGLGpu::unbindTextureFBOForPixelOps(GrGLenum fboTarget, GrSurface* surface
}
}
bool GrGLGpu::onCopySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
bool GrGLGpu::onCopySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint) {
// None of our copy methods can handle a swizzle. TODO: Make copySurfaceAsDraw handle the
// swizzle.
if (this->caps()->shaderCaps()->configOutputSwizzle(src->config()) !=
@ -3431,22 +3405,24 @@ bool GrGLGpu::onCopySurface(GrSurface* dst,
// Don't prefer copying as a draw if the dst doesn't already have a FBO object.
bool preferCopy = SkToBool(dst->asRenderTarget());
if (preferCopy && src->asTexture()) {
if (this->copySurfaceAsDraw(dst, src, srcRect, dstPoint)) {
if (this->copySurfaceAsDraw(dst, dstOrigin, src, srcOrigin, srcRect, dstPoint)) {
return true;
}
}
if (can_copy_texsubimage(dst, src, this)) {
this->copySurfaceAsCopyTexSubImage(dst, src, srcRect, dstPoint);
if (can_copy_texsubimage(dst, dstOrigin, src, srcOrigin, this)) {
this->copySurfaceAsCopyTexSubImage(dst, dstOrigin, src, srcOrigin, srcRect, dstPoint);
return true;
}
if (can_blit_framebuffer_for_copy_surface(dst, src, srcRect, dstPoint, this)) {
return this->copySurfaceAsBlitFramebuffer(dst, src, srcRect, dstPoint);
if (can_blit_framebuffer_for_copy_surface(dst, dstOrigin, src, srcOrigin,
srcRect, dstPoint, this)) {
return this->copySurfaceAsBlitFramebuffer(dst, dstOrigin, src, srcOrigin,
srcRect, dstPoint);
}
if (!preferCopy && src->asTexture()) {
if (this->copySurfaceAsDraw(dst, src, srcRect, dstPoint)) {
if (this->copySurfaceAsDraw(dst, dstOrigin, src, srcOrigin, srcRect, dstPoint)) {
return true;
}
}
@ -3804,7 +3780,7 @@ bool GrGLGpu::createStencilClipClearProgram() {
}
void GrGLGpu::clearStencilClipAsDraw(const GrFixedClip& clip, bool insideStencilMask,
GrRenderTarget* rt) {
GrRenderTarget* rt, GrSurfaceOrigin origin) {
// TODO: This should swizzle the output to match dst's config, though it is a debugging
// visualization.
@ -3834,8 +3810,8 @@ void GrGLGpu::clearStencilClipAsDraw(const GrFixedClip& clip, bool insideStencil
this->flushBlend(blendInfo, GrSwizzle::RGBA());
this->flushColorWrite(false);
this->flushHWAAState(glRT, false, false);
this->flushScissor(clip.scissorState(), glRT->getViewport(), glRT->origin());
this->flushWindowRectangles(clip.windowRectsState(), glRT);
this->flushScissor(clip.scissorState(), glRT->getViewport(), origin);
this->flushWindowRectangles(clip.windowRectsState(), glRT, origin);
GrStencilAttachment* sb = rt->renderTargetPriv().getStencilAttachment();
// This should only be called internally when we know we have a stencil buffer.
SkASSERT(sb);
@ -3846,8 +3822,8 @@ void GrGLGpu::clearStencilClipAsDraw(const GrFixedClip& clip, bool insideStencil
}
bool GrGLGpu::copySurfaceAsDraw(GrSurface* dst,
GrSurface* src,
bool GrGLGpu::copySurfaceAsDraw(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
GrGLTexture* srcTex = static_cast<GrGLTexture*>(src->asTexture());
@ -3864,7 +3840,7 @@ bool GrGLGpu::copySurfaceAsDraw(GrSurface* dst,
int h = srcRect.height();
GrSamplerParams params(SkShader::kClamp_TileMode, GrSamplerParams::kNone_FilterMode);
this->bindTexture(0, params, true, srcTex);
this->bindTexture(0, params, true, srcTex, srcOrigin);
GrGLIRect dstVP;
this->bindSurfaceFBOForPixelOps(dst, GR_GL_FRAMEBUFFER, &dstVP, kDst_TempFBOTarget);
@ -3890,7 +3866,7 @@ bool GrGLGpu::copySurfaceAsDraw(GrSurface* dst,
GrGLfloat dx1 = 2.f * (dstPoint.fX + w) / dw - 1.f;
GrGLfloat dy0 = 2.f * dstPoint.fY / dh - 1.f;
GrGLfloat dy1 = 2.f * (dstPoint.fY + h) / dh - 1.f;
if (kBottomLeft_GrSurfaceOrigin == dst->origin()) {
if (kBottomLeft_GrSurfaceOrigin == dstOrigin) {
dy0 = -dy0;
dy1 = -dy1;
}
@ -3901,7 +3877,7 @@ bool GrGLGpu::copySurfaceAsDraw(GrSurface* dst,
GrGLfloat sy1 = (GrGLfloat)(srcRect.fTop + h);
int sw = src->width();
int sh = src->height();
if (kBottomLeft_GrSurfaceOrigin == src->origin()) {
if (kBottomLeft_GrSurfaceOrigin == srcOrigin) {
sy0 = sh - sy0;
sy1 = sh - sy1;
}
@ -3935,11 +3911,11 @@ bool GrGLGpu::copySurfaceAsDraw(GrSurface* dst,
return true;
}
void GrGLGpu::copySurfaceAsCopyTexSubImage(GrSurface* dst,
GrSurface* src,
void GrGLGpu::copySurfaceAsCopyTexSubImage(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
SkASSERT(can_copy_texsubimage(dst, src, this));
SkASSERT(can_copy_texsubimage(dst, dstOrigin, src, srcOrigin, this));
GrGLIRect srcVP;
this->bindSurfaceFBOForPixelOps(src, GR_GL_FRAMEBUFFER, &srcVP, kSrc_TempFBOTarget);
GrGLTexture* dstTex = static_cast<GrGLTexture *>(dst->asTexture());
@ -3947,12 +3923,12 @@ void GrGLGpu::copySurfaceAsCopyTexSubImage(GrSurface* dst,
// We modified the bound FBO
fHWBoundRenderTargetUniqueID.makeInvalid();
GrGLIRect srcGLRect;
srcGLRect.setRelativeTo(srcVP, srcRect, src->origin());
srcGLRect.setRelativeTo(srcVP, srcRect, srcOrigin);
this->setScratchTextureUnit();
GL_CALL(BindTexture(dstTex->target(), dstTex->textureID()));
GrGLint dstY;
if (kBottomLeft_GrSurfaceOrigin == dst->origin()) {
if (kBottomLeft_GrSurfaceOrigin == dstOrigin) {
dstY = dst->height() - (dstPoint.fY + srcGLRect.fHeight);
} else {
dstY = dstPoint.fY;
@ -3967,11 +3943,12 @@ void GrGLGpu::copySurfaceAsCopyTexSubImage(GrSurface* dst,
this->didWriteToSurface(dst, &dstRect);
}
bool GrGLGpu::copySurfaceAsBlitFramebuffer(GrSurface* dst,
GrSurface* src,
bool GrGLGpu::copySurfaceAsBlitFramebuffer(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
SkASSERT(can_blit_framebuffer_for_copy_surface(dst, src, srcRect, dstPoint, this));
SkASSERT(can_blit_framebuffer_for_copy_surface(dst, dstOrigin, src, srcOrigin,
srcRect, dstPoint, this));
SkIRect dstRect = SkIRect::MakeXYWH(dstPoint.fX, dstPoint.fY,
srcRect.width(), srcRect.height());
if (dst == src) {
@ -3988,8 +3965,8 @@ bool GrGLGpu::copySurfaceAsBlitFramebuffer(GrSurface* dst,
fHWBoundRenderTargetUniqueID.makeInvalid();
GrGLIRect srcGLRect;
GrGLIRect dstGLRect;
srcGLRect.setRelativeTo(srcVP, srcRect, src->origin());
dstGLRect.setRelativeTo(dstVP, dstRect, dst->origin());
srcGLRect.setRelativeTo(srcVP, srcRect, srcOrigin);
dstGLRect.setRelativeTo(dstVP, dstRect, dstOrigin);
// BlitFrameBuffer respects the scissor, so disable it.
this->disableScissor();
@ -3998,7 +3975,7 @@ bool GrGLGpu::copySurfaceAsBlitFramebuffer(GrSurface* dst,
GrGLint srcY0;
GrGLint srcY1;
// Does the blit need to y-mirror or not?
if (src->origin() == dst->origin()) {
if (srcOrigin == dstOrigin) {
srcY0 = srcGLRect.fBottom;
srcY1 = srcGLRect.fBottom + srcGLRect.fHeight;
} else {
@ -4023,7 +4000,8 @@ bool GrGLGpu::copySurfaceAsBlitFramebuffer(GrSurface* dst,
// Manual implementation of mipmap generation, to work around driver bugs w/sRGB.
// Uses draw calls to do a series of downsample operations to successive mips.
// If this returns false, then the calling code falls back to using glGenerateMipmap.
bool GrGLGpu::generateMipmap(GrGLTexture* texture, bool gammaCorrect) {
bool GrGLGpu::generateMipmap(GrGLTexture* texture, GrSurfaceOrigin textureOrigin,
bool gammaCorrect) {
SkASSERT(!GrPixelConfigIsSint(texture->config()));
// Our iterative downsample requires the ability to limit which level we're sampling:
if (!this->glCaps().doManualMipmapping()) {
@ -4086,7 +4064,7 @@ bool GrGLGpu::generateMipmap(GrGLTexture* texture, bool gammaCorrect) {
// We'll be changing our base level further below:
this->setTextureUnit(0);
GrSamplerParams params(SkShader::kClamp_TileMode, GrSamplerParams::kBilerp_FilterMode);
this->bindTexture(0, params, gammaCorrect, texture);
this->bindTexture(0, params, gammaCorrect, texture, textureOrigin);
// Vertex data:
if (!fMipmapProgramArrayBuffer) {
@ -4168,7 +4146,8 @@ bool GrGLGpu::generateMipmap(GrGLTexture* texture, bool gammaCorrect) {
return true;
}
void GrGLGpu::onQueryMultisampleSpecs(GrRenderTarget* rt, const GrStencilSettings& stencil,
void GrGLGpu::onQueryMultisampleSpecs(GrRenderTarget* rt, GrSurfaceOrigin rtOrigin,
const GrStencilSettings& stencil,
int* effectiveSampleCnt, SamplePattern* samplePattern) {
SkASSERT(GrFSAAType::kMixedSamples != rt->fsaaType() ||
rt->renderTargetPriv().getStencilAttachment() || stencil.isDisabled());
@ -4190,7 +4169,7 @@ void GrGLGpu::onQueryMultisampleSpecs(GrRenderTarget* rt, const GrStencilSetting
for (int i = 0; i < *effectiveSampleCnt; ++i) {
GrGLfloat pos[2];
GL_CALL(GetMultisamplefv(GR_GL_SAMPLE_POSITION, i, pos));
if (kTopLeft_GrSurfaceOrigin == rt->origin()) {
if (kTopLeft_GrSurfaceOrigin == rtOrigin) {
(*samplePattern)[i].set(pos[0], pos[1]);
} else {
(*samplePattern)[i].set(pos[0], 1 - pos[1]);

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

@ -60,19 +60,22 @@ public:
// Used by GrGLProgram to configure OpenGL state.
void bindTexture(int unitIdx, const GrSamplerParams& params, bool allowSRGBInputs,
GrGLTexture* texture);
GrGLTexture* texture, GrSurfaceOrigin textureOrigin);
void bindTexelBuffer(int unitIdx, GrPixelConfig, GrGLBuffer*);
void bindImageStorage(int unitIdx, GrIOType, GrGLTexture *);
void generateMipmaps(const GrSamplerParams& params, bool allowSRGBInputs, GrGLTexture* texture);
void generateMipmaps(const GrSamplerParams& params, bool allowSRGBInputs,
GrGLTexture* texture, GrSurfaceOrigin textureOrigin);
bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
bool onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin,
int readWidth, int readHeight, size_t rowBytes,
GrPixelConfig readConfig, DrawPreference*,
ReadPixelTempDrawInfo*) override;
bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
bool onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin,
int width, int height,
GrPixelConfig srcConfig, DrawPreference*,
WritePixelTempDrawInfo*) override;
@ -131,12 +134,13 @@ public:
// The GrGLGpuCommandBuffer does not buffer up draws before submitting them to the gpu.
// Thus this is the implementation of the clear call for the corresponding passthrough function
// on GrGLGpuCommandBuffer.
void clear(const GrFixedClip&, GrColor, GrRenderTarget*);
void clear(const GrFixedClip&, GrColor, GrRenderTarget*, GrSurfaceOrigin);
// The GrGLGpuCommandBuffer does not buffer up draws before submitting them to the gpu.
// Thus this is the implementation of the clearStencil call for the corresponding passthrough
// function on GrGLGpuCommandBuffer.
void clearStencilClip(const GrFixedClip&, bool insideStencilMask, GrRenderTarget*);
void clearStencilClip(const GrFixedClip&, bool insideStencilMask,
GrRenderTarget*, GrSurfaceOrigin);
const GrGLContext* glContextForTesting() const override {
return &this->glContext();
@ -193,17 +197,12 @@ private:
GrBuffer* onCreateBuffer(size_t size, GrBufferType intendedType, GrAccessPattern,
const void* data) override;
sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
GrSurfaceOrigin,
GrWrapOwnership) override;
sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrWrapOwnership) override;
sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt,
GrWrapOwnership) override;
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
GrSurfaceOrigin origin) override;
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt) override;
std::unique_ptr<gr_instanced::OpAllocator> onCreateInstancedRenderingAllocator() override;
@ -240,14 +239,14 @@ private:
// variations above, depending on whether the surface is a render target or not.
bool readPixelsSupported(GrSurface* surfaceForConfig, GrPixelConfig readConfig);
bool onReadPixels(GrSurface*,
bool onReadPixels(GrSurface*, GrSurfaceOrigin,
int left, int top,
int width, int height,
GrPixelConfig,
void* buffer,
size_t rowBytes) override;
bool onWritePixels(GrSurface*,
bool onWritePixels(GrSurface*, GrSurfaceOrigin,
int left, int top, int width, int height,
GrPixelConfig config,
const GrMipLevel texels[], int mipLevelCount) override;
@ -257,14 +256,13 @@ private:
GrPixelConfig config, GrBuffer* transferBuffer,
size_t offset, size_t rowBytes) override;
void onResolveRenderTarget(GrRenderTarget* target) override;
void onResolveRenderTarget(GrRenderTarget* target, GrSurfaceOrigin) override;
bool onCopySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) override;
bool onCopySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint) override;
void onQueryMultisampleSpecs(GrRenderTarget*, const GrStencilSettings&,
void onQueryMultisampleSpecs(GrRenderTarget*, GrSurfaceOrigin, const GrStencilSettings&,
int* effectiveSampleCnt, SamplePattern*) override;
// binds texture unit in GL
@ -288,20 +286,18 @@ private:
bool hasExtension(const char* ext) const { return fGLContext->hasExtension(ext); }
bool copySurfaceAsDraw(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
void copySurfaceAsCopyTexSubImage(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
bool copySurfaceAsBlitFramebuffer(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
bool generateMipmap(GrGLTexture* texture, bool gammaCorrect);
void clearStencilClipAsDraw(const GrFixedClip&, bool insideStencilMask, GrRenderTarget*);
bool copySurfaceAsDraw(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint);
void copySurfaceAsCopyTexSubImage(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint);
bool copySurfaceAsBlitFramebuffer(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint);
bool generateMipmap(GrGLTexture* texture, GrSurfaceOrigin textureOrigin, bool gammaCorrect);
void clearStencilClipAsDraw(const GrFixedClip&, bool insideStencilMask,
GrRenderTarget*, GrSurfaceOrigin);
static bool BlendCoeffReferencesConstant(GrBlendCoeff coeff);
@ -352,7 +348,7 @@ private:
// disables the scissor
void disableScissor();
void flushWindowRectangles(const GrWindowRectsState&, const GrGLRenderTarget*);
void flushWindowRectangles(const GrWindowRectsState&, const GrGLRenderTarget*, GrSurfaceOrigin);
void disableWindowRectangles();
// sets a texture unit to use for texture operations other than binding a texture to a program.

14
src/gpu/gl/GrGLGpuCommandBuffer.h
View File

@ -1,9 +1,9 @@
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrGLGpuCommandBuffer_DEFINED
#define GrGLGpuCommandBuffer_DEFINED
@ -69,7 +69,7 @@ private:
fRenderTarget = target;
}
SkASSERT(target == fRenderTarget);
fGpu->clear(clip, color, fRenderTarget);
fGpu->clear(clip, color, fRenderTarget, proxy->origin());
}
void onClearStencilClip(GrRenderTargetProxy* proxy, const GrFixedClip& clip,
@ -79,7 +79,7 @@ private:
fRenderTarget = target;
}
SkASSERT(target == fRenderTarget);
fGpu->clearStencilClip(clip, insideStencilMask, fRenderTarget);
fGpu->clearStencilClip(clip, insideStencilMask, fRenderTarget, proxy->origin());
}
GrGLGpu* fGpu;

20
src/gpu/gl/GrGLProgram.cpp
View File

@ -70,7 +70,7 @@ void GrGLProgram::abandon() {
///////////////////////////////////////////////////////////////////////////////
void GrGLProgram::setData(const GrPrimitiveProcessor& primProc, const GrPipeline& pipeline) {
this->setRenderTargetState(primProc, pipeline.renderTarget());
this->setRenderTargetState(primProc, pipeline.proxy());
// we set the textures, and uniforms for installed processors in a generic way, but subclasses
// of GLProgram determine how to set coord transforms
@ -97,7 +97,8 @@ void GrGLProgram::setData(const GrPrimitiveProcessor& primProc, const GrPipeline
fXferProcessor->setData(fProgramDataManager, xp, dstTexture, offset);
if (dstTexture) {
fGpu->bindTexture(nextTexSamplerIdx++, GrSamplerParams::ClampNoFilter(), true,
static_cast<GrGLTexture*>(dstTexture));
static_cast<GrGLTexture*>(dstTexture),
pipeline.dstTextureProxy()->origin());
}
SkASSERT(nextTexSamplerIdx == fNumTextureSamplers);
SkASSERT(nextTexelBufferIdx == fNumTextureSamplers + fNumTexelBuffers);
@ -135,7 +136,8 @@ void GrGLProgram::setFragmentData(const GrPrimitiveProcessor& primProc,
void GrGLProgram::setRenderTargetState(const GrPrimitiveProcessor& primProc,
const GrRenderTarget* rt) {
const GrRenderTargetProxy* proxy) {
GrRenderTarget* rt = proxy->priv().peekRenderTarget();
// Load the RT height uniform if it is needed to y-flip gl_FragCoord.
if (fBuiltinUniformHandles.fRTHeightUni.isValid() &&
fRenderTargetState.fRenderTargetSize.fHeight != rt->height()) {
@ -146,10 +148,10 @@ void GrGLProgram::setRenderTargetState(const GrPrimitiveProcessor& primProc,
SkISize size;
size.set(rt->width(), rt->height());
if (!primProc.isPathRendering()) {
if (fRenderTargetState.fRenderTargetOrigin != rt->origin() ||
if (fRenderTargetState.fRenderTargetOrigin != proxy->origin() ||
fRenderTargetState.fRenderTargetSize != size) {
fRenderTargetState.fRenderTargetSize = size;
fRenderTargetState.fRenderTargetOrigin = rt->origin();
fRenderTargetState.fRenderTargetOrigin = proxy->origin();
float rtAdjustmentVec[4];
fRenderTargetState.getRTAdjustmentVec(rtAdjustmentVec);
@ -159,7 +161,7 @@ void GrGLProgram::setRenderTargetState(const GrPrimitiveProcessor& primProc,
SkASSERT(fGpu->glCaps().shaderCaps()->pathRenderingSupport());
const GrPathProcessor& pathProc = primProc.cast<GrPathProcessor>();
fGpu->glPathRendering()->setProjectionMatrix(pathProc.viewMatrix(),
size, rt->origin());
size, proxy->origin());
}
}
@ -171,7 +173,8 @@ void GrGLProgram::bindTextures(const GrResourceIOProcessor& processor,
for (int i = 0; i < processor.numTextureSamplers(); ++i) {
const GrResourceIOProcessor::TextureSampler& sampler = processor.textureSampler(i);
fGpu->bindTexture((*nextTexSamplerIdx)++, sampler.params(),
allowSRGBInputs, static_cast<GrGLTexture*>(sampler.peekTexture()));
allowSRGBInputs, static_cast<GrGLTexture*>(sampler.peekTexture()),
sampler.proxy()->origin());
}
for (int i = 0; i < processor.numBuffers(); ++i) {
const GrResourceIOProcessor::BufferAccess& access = processor.bufferAccess(i);
@ -189,6 +192,7 @@ void GrGLProgram::generateMipmaps(const GrResourceIOProcessor& processor, bool a
for (int i = 0; i < processor.numTextureSamplers(); ++i) {
const GrResourceIOProcessor::TextureSampler& sampler = processor.textureSampler(i);
fGpu->generateMipmaps(sampler.params(), allowSRGBInputs,
static_cast<GrGLTexture*>(sampler.peekTexture()));
static_cast<GrGLTexture*>(sampler.peekTexture()),
sampler.proxy()->origin());
}
}

2
src/gpu/gl/GrGLProgram.h
View File

@ -124,7 +124,7 @@ protected:
int* nextTexelBufferIdx, int* nextImageStorageIdx);
// Helper for setData() that sets the view matrix and loads the render target height uniform
void setRenderTargetState(const GrPrimitiveProcessor&, const GrRenderTarget*);
void setRenderTargetState(const GrPrimitiveProcessor&, const GrRenderTargetProxy*);
// Helper for setData() that binds textures and texel buffers to the appropriate texture units
void bindTextures(const GrResourceIOProcessor&, bool allowSRGBInputs, int* nextSamplerIdx,

30
src/gpu/mock/GrMockGpu.h
View File

@ -25,20 +25,21 @@ public:
~GrMockGpu() override {}
bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
bool onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin,
int readWidth, int readHeight, size_t rowBytes,
GrPixelConfig readConfig, DrawPreference*,
ReadPixelTempDrawInfo*) override { return true; }
bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
bool onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin,
int width, int height,
GrPixelConfig srcConfig, DrawPreference*,
WritePixelTempDrawInfo*) override { return true; }
bool onCopySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) override { return true; }
bool onCopySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint) override { return true; }
void onQueryMultisampleSpecs(GrRenderTarget* rt, const GrStencilSettings&,
void onQueryMultisampleSpecs(GrRenderTarget* rt, GrSurfaceOrigin, const GrStencilSettings&,
int* effectiveSampleCnt, SamplePattern*) override {
*effectiveSampleCnt = rt->numStencilSamples();
}
@ -71,26 +72,21 @@ private:
sk_sp<GrTexture> onCreateTexture(const GrSurfaceDesc&, SkBudgeted,
const GrMipLevel texels[], int mipLevelCount) override;
sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
GrSurfaceOrigin,
GrWrapOwnership) override {
sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrWrapOwnership) override {
return nullptr;
}
sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt,
GrWrapOwnership) override {
return nullptr;
}
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
GrSurfaceOrigin) override {
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override {
return nullptr;
}
sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt) override {
return nullptr;
}
@ -100,7 +96,7 @@ private:
gr_instanced::InstancedRendering* onCreateInstancedRendering() override { return nullptr; }
bool onReadPixels(GrSurface* surface,
bool onReadPixels(GrSurface* surface, GrSurfaceOrigin,
int left, int top, int width, int height,
GrPixelConfig,
void* buffer,
@ -108,7 +104,7 @@ private:
return true;
}
bool onWritePixels(GrSurface* surface,
bool onWritePixels(GrSurface* surface, GrSurfaceOrigin,
int left, int top, int width, int height,
GrPixelConfig config,
const GrMipLevel texels[], int mipLevelCount) override {
@ -122,7 +118,7 @@ private:
return true;
}
void onResolveRenderTarget(GrRenderTarget* target) override { return; }
void onResolveRenderTarget(GrRenderTarget* target, GrSurfaceOrigin) override { return; }
GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
int width,

2
src/gpu/mock/GrMockTexture.h
View File

@ -90,7 +90,7 @@ private:
void computeScratchKey(GrScratchKey* key) const override {
GrTexturePriv::ComputeScratchKey(this->config(), this->width(), this->height(),
this->origin(), true, this->numStencilSamples(),
true, this->numStencilSamples(),
this->texturePriv().hasMipMaps(), key);
}
};

27
src/gpu/mtl/GrMtlGpu.h
View File

@ -29,20 +29,22 @@ public:
const GrMtlCaps& mtlCaps() const { return *fMtlCaps.get(); }
bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
bool onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin,
int readWidth, int readHeight, size_t rowBytes,
GrPixelConfig readConfig, DrawPreference*,
ReadPixelTempDrawInfo*) override { return false; }
bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
bool onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin,
int width, int height,
GrPixelConfig srcConfig, DrawPreference*,
WritePixelTempDrawInfo*) override { return false; }
bool onCopySurface(GrSurface* dst,
GrSurface* src,
bool onCopySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect,
const SkIPoint& dstPoint) override { return false; }
void onQueryMultisampleSpecs(GrRenderTarget* rt, const GrStencilSettings&,
void onQueryMultisampleSpecs(GrRenderTarget*, GrSurfaceOrigin, const GrStencilSettings&,
int* effectiveSampleCnt, SamplePattern*) override {}
GrGpuCommandBuffer* createCommandBuffer(const GrGpuCommandBuffer::LoadAndStoreInfo&,
@ -76,26 +78,21 @@ private:
return nullptr;
}
sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
GrSurfaceOrigin,
GrWrapOwnership) override {
sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrWrapOwnership) override {
return nullptr;
}
sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt,
GrWrapOwnership) override {
return nullptr;
}
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
GrSurfaceOrigin) override {
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override {
return nullptr;
}
sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt) override {
return nullptr;
}
@ -106,7 +103,7 @@ private:
gr_instanced::InstancedRendering* onCreateInstancedRendering() override { return nullptr; }
bool onReadPixels(GrSurface* surface,
bool onReadPixels(GrSurface* surface, GrSurfaceOrigin,
int left, int top, int width, int height,
GrPixelConfig,
void* buffer,
@ -114,7 +111,7 @@ private:
return false;
}
bool onWritePixels(GrSurface* surface,
bool onWritePixels(GrSurface* surface, GrSurfaceOrigin,
int left, int top, int width, int height,
GrPixelConfig config,
const GrMipLevel texels[], int mipLevelCount) override {
@ -128,7 +125,7 @@ private:
return false;
}
void onResolveRenderTarget(GrRenderTarget* target) override { return; }
void onResolveRenderTarget(GrRenderTarget* target, GrSurfaceOrigin) override { return; }
GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
int width,

14
src/gpu/ops/GrClearOp.cpp
View File

@ -3,14 +3,14 @@
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrClearOp.h"
#include "GrGpuCommandBuffer.h"
#include "GrOpFlushState.h"
*/
#include "GrClearOp.h"
#include "GrGpuCommandBuffer.h"
#include "GrOpFlushState.h"
#include "GrResourceProvider.h"
GrClearOp::GrClearOp(const GrFixedClip& clip, GrColor color, GrSurfaceProxy* proxy)
: INHERITED(ClassID())
, fClip(clip)

5
src/gpu/ops/GrCopySurfaceOp.cpp
View File

@ -87,6 +87,7 @@ void GrCopySurfaceOp::onExecute(GrOpFlushState* state) {
return;
}
state->gpu()->copySurface(fDst.get()->priv().peekSurface(),
fSrc.get()->priv().peekSurface(), fSrcRect, fDstPoint);
state->gpu()->copySurface(fDst.get()->priv().peekSurface(), fDst.get()->origin(),
fSrc.get()->priv().peekSurface(), fSrc.get()->origin(),
fSrcRect, fDstPoint);
}

13
src/gpu/vk/GrVkCopyManager.cpp
View File

@ -143,10 +143,9 @@ bool GrVkCopyManager::createCopyProgram(GrVkGpu* gpu) {
}
bool GrVkCopyManager::copySurfaceAsDraw(GrVkGpu* gpu,
GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint) {
// None of our copy methods can handle a swizzle. TODO: Make copySurfaceAsDraw handle the
// swizzle.
if (gpu->caps()->shaderCaps()->configOutputSwizzle(src->config()) !=
@ -204,7 +203,7 @@ bool GrVkCopyManager::copySurfaceAsDraw(GrVkGpu* gpu,
float dx1 = 2.f * (dstPoint.fX + w) / dw - 1.f;
float dy0 = 2.f * dstPoint.fY / dh - 1.f;
float dy1 = 2.f * (dstPoint.fY + h) / dh - 1.f;
if (kBottomLeft_GrSurfaceOrigin == dst->origin()) {
if (kBottomLeft_GrSurfaceOrigin == dstOrigin) {
dy0 = -dy0;
dy1 = -dy1;
}
@ -215,7 +214,7 @@ bool GrVkCopyManager::copySurfaceAsDraw(GrVkGpu* gpu,
float sy0 = (float)srcRect.fTop;
float sy1 = (float)(srcRect.fTop + h);
int sh = src->height();
if (kBottomLeft_GrSurfaceOrigin == src->origin()) {
if (kBottomLeft_GrSurfaceOrigin == srcOrigin) {
sy0 = sh - sy0;
sy1 = sh - sy1;
}
@ -293,7 +292,7 @@ bool GrVkCopyManager::copySurfaceAsDraw(GrVkGpu* gpu,
GrVkRenderTarget* texRT = static_cast<GrVkRenderTarget*>(srcTex->asRenderTarget());
if (texRT) {
gpu->onResolveRenderTarget(texRT);
gpu->onResolveRenderTarget(texRT, srcOrigin);
}
GrVkPrimaryCommandBuffer* cmdBuffer = gpu->currentCommandBuffer();

8
src/gpu/vk/GrVkCopyManager.h
View File

@ -8,6 +8,7 @@
#ifndef GrVkCopyManager_DEFINED
#define GrVkCopyManager_DEFINED
#include "GrTypes.h"
#include "GrVkDescriptorSetManager.h"
#include "vk/GrVkDefines.h"
@ -27,10 +28,9 @@ public:
~GrVkCopyManager();
bool copySurfaceAsDraw(GrVkGpu* gpu,
GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint);
void destroyResources(GrVkGpu* gpu);
void abandonResources();

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

@ -332,7 +332,8 @@ GrBuffer* GrVkGpu::onCreateBuffer(size_t size, GrBufferType type, GrAccessPatter
}
////////////////////////////////////////////////////////////////////////////////
bool GrVkGpu::onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
bool GrVkGpu::onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin,
int width, int height,
GrPixelConfig srcConfig, DrawPreference* drawPreference,
WritePixelTempDrawInfo* tempDrawInfo) {
GrRenderTarget* renderTarget = dstSurface->asRenderTarget();
@ -375,7 +376,7 @@ bool GrVkGpu::onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
return true;
}
bool GrVkGpu::onWritePixels(GrSurface* surface,
bool GrVkGpu::onWritePixels(GrSurface* surface, GrSurfaceOrigin origin,
int left, int top, int width, int height,
GrPixelConfig config,
const GrMipLevel texels[], int mipLevelCount) {
@ -410,7 +411,7 @@ bool GrVkGpu::onWritePixels(GrSurface* surface,
false);
this->submitCommandBuffer(kForce_SyncQueue);
}
success = this->uploadTexDataLinear(vkTex, left, top, width, height, config,
success = this->uploadTexDataLinear(vkTex, origin, left, top, width, height, config,
texels[0].fPixels, texels[0].fRowBytes);
} else {
int currentMipLevels = vkTex->texturePriv().maxMipMapLevel() + 1;
@ -419,7 +420,7 @@ bool GrVkGpu::onWritePixels(GrSurface* surface,
return false;
}
}
success = this->uploadTexDataOptimal(vkTex, left, top, width, height, config,
success = this->uploadTexDataOptimal(vkTex, origin, left, top, width, height, config,
texels, mipLevelCount);
}
@ -487,8 +488,9 @@ bool GrVkGpu::onTransferPixels(GrTexture* texture,
return true;
}
void GrVkGpu::resolveImage(GrSurface* dst, GrVkRenderTarget* src, const SkIRect& srcRect,
const SkIPoint& dstPoint) {
void GrVkGpu::resolveImage(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrVkRenderTarget* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint) {
SkASSERT(dst);
SkASSERT(src && src->numColorSamples() > 1 && src->msaaImage());
@ -500,8 +502,8 @@ void GrVkGpu::resolveImage(GrSurface* dst, GrVkRenderTarget* src, const SkIRect&
SkIRect srcVkRect = srcRect;
int32_t dstY = dstPoint.fY;
if (kBottomLeft_GrSurfaceOrigin == src->origin()) {
SkASSERT(kBottomLeft_GrSurfaceOrigin == dst->origin());
if (kBottomLeft_GrSurfaceOrigin == srcOrigin) {
SkASSERT(kBottomLeft_GrSurfaceOrigin == dstOrigin);
srcVkRect.fTop = src->height() - srcRect.fBottom;
srcVkRect.fBottom = src->height() - srcRect.fTop;
dstY = dst->height() - dstPoint.fY - srcVkRect.height();
@ -538,7 +540,8 @@ void GrVkGpu::resolveImage(GrSurface* dst, GrVkRenderTarget* src, const SkIRect&
fCurrentCmdBuffer->resolveImage(this, *src->msaaImage(), *dstImage, 1, &resolveInfo);
}
void GrVkGpu::internalResolveRenderTarget(GrRenderTarget* target, bool requiresSubmit) {
void GrVkGpu::internalResolveRenderTarget(GrRenderTarget* target, GrSurfaceOrigin origin,
bool requiresSubmit) {
if (target->needsResolve()) {
SkASSERT(target->numColorSamples() > 1);
GrVkRenderTarget* rt = static_cast<GrVkRenderTarget*>(target);
@ -546,7 +549,8 @@ void GrVkGpu::internalResolveRenderTarget(GrRenderTarget* target, bool requiresS
const SkIRect& srcRect = rt->getResolveRect();
this->resolveImage(target, rt, srcRect, SkIPoint::Make(srcRect.fLeft, srcRect.fTop));
this->resolveImage(target, origin, rt, origin, srcRect,
SkIPoint::Make(srcRect.fLeft, srcRect.fTop));
rt->flagAsResolved();
@ -556,7 +560,7 @@ void GrVkGpu::internalResolveRenderTarget(GrRenderTarget* target, bool requiresS
}
}
bool GrVkGpu::uploadTexDataLinear(GrVkTexture* tex,
bool GrVkGpu::uploadTexDataLinear(GrVkTexture* tex, GrSurfaceOrigin texOrigin,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
const void* data,
@ -592,7 +596,7 @@ bool GrVkGpu::uploadTexDataLinear(GrVkTexture* tex,
&subres,
&layout));
int texTop = kBottomLeft_GrSurfaceOrigin == tex->origin() ? tex->height() - top - height : top;
int texTop = kBottomLeft_GrSurfaceOrigin == texOrigin ? tex->height() - top - height : top;
const GrVkAlloc& alloc = tex->alloc();
VkDeviceSize offset = alloc.fOffset + texTop*layout.rowPitch + left*bpp;
VkDeviceSize size = height*layout.rowPitch;
@ -602,7 +606,7 @@ bool GrVkGpu::uploadTexDataLinear(GrVkTexture* tex,
return false;
}
if (kBottomLeft_GrSurfaceOrigin == tex->origin()) {
if (kBottomLeft_GrSurfaceOrigin == texOrigin) {
// copy into buffer by rows
const char* srcRow = reinterpret_cast<const char*>(data);
char* dstRow = reinterpret_cast<char*>(mapPtr)+(height - 1)*layout.rowPitch;
@ -622,7 +626,7 @@ bool GrVkGpu::uploadTexDataLinear(GrVkTexture* tex,
return true;
}
bool GrVkGpu::uploadTexDataOptimal(GrVkTexture* tex,
bool GrVkGpu::uploadTexDataOptimal(GrVkTexture* tex, GrSurfaceOrigin texOrigin,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
const GrMipLevel texels[], int mipLevelCount) {
@ -657,7 +661,7 @@ bool GrVkGpu::uploadTexDataOptimal(GrVkTexture* tex,
}
// Determine whether we need to flip when we copy into the buffer
bool flipY = (kBottomLeft_GrSurfaceOrigin == tex->origin() && mipLevelCount);
bool flipY = (kBottomLeft_GrSurfaceOrigin == texOrigin && mipLevelCount);
SkTArray<size_t> individualMipOffsets(mipLevelCount);
individualMipOffsets.push_back(0);
@ -813,8 +817,8 @@ sk_sp<GrTexture> GrVkGpu::onCreateTexture(const GrSurfaceDesc& desc, SkBudgeted
if (mipLevelCount) {
SkASSERT(texels[0].fPixels);
if (!this->uploadTexDataOptimal(tex.get(), 0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
texels, mipLevelCount)) {
if (!this->uploadTexDataOptimal(tex.get(), desc.fOrigin, 0, 0, desc.fWidth, desc.fHeight,
desc.fConfig, texels, mipLevelCount)) {
tex->unref();
return nullptr;
}
@ -849,15 +853,6 @@ bool GrVkGpu::updateBuffer(GrVkBuffer* buffer, const void* src,
////////////////////////////////////////////////////////////////////////////////
static GrSurfaceOrigin resolve_origin(GrSurfaceOrigin origin) {
// By default, all textures in Vk use TopLeft
if (kDefault_GrSurfaceOrigin == origin) {
return kTopLeft_GrSurfaceOrigin;
} else {
return origin;
}
}
static bool check_backend_texture(const GrBackendTexture& backendTex) {
const GrVkImageInfo* info = backendTex.getVkImageInfo();
if (!info) {
@ -873,7 +868,6 @@ static bool check_backend_texture(const GrBackendTexture& backendTex) {
}
sk_sp<GrTexture> GrVkGpu::onWrapBackendTexture(const GrBackendTexture& backendTex,
GrSurfaceOrigin origin,
GrWrapOwnership ownership) {
if (!check_backend_texture(backendTex)) {
return nullptr;
@ -881,19 +875,16 @@ sk_sp<GrTexture> GrVkGpu::onWrapBackendTexture(const GrBackendTexture& backendTe
GrSurfaceDesc surfDesc;
surfDesc.fFlags = kNone_GrSurfaceFlags;
surfDesc.fOrigin = kTopLeft_GrSurfaceOrigin; // Not actually used in the following
surfDesc.fWidth = backendTex.width();
surfDesc.fHeight = backendTex.height();
surfDesc.fConfig = backendTex.config();
surfDesc.fSampleCnt = 0;
// In GL, Chrome assumes all textures are BottomLeft
// In VK, we don't have this restriction
surfDesc.fOrigin = resolve_origin(origin);
return GrVkTexture::MakeWrappedTexture(this, surfDesc, ownership, backendTex.getVkImageInfo());
}
sk_sp<GrTexture> GrVkGpu::onWrapRenderableBackendTexture(const GrBackendTexture& backendTex,
GrSurfaceOrigin origin,
int sampleCnt,
GrWrapOwnership ownership) {
if (!check_backend_texture(backendTex)) {
@ -902,20 +893,17 @@ sk_sp<GrTexture> GrVkGpu::onWrapRenderableBackendTexture(const GrBackendTexture&
GrSurfaceDesc surfDesc;
surfDesc.fFlags = kRenderTarget_GrSurfaceFlag;
surfDesc.fOrigin = kBottomLeft_GrSurfaceOrigin; // Not actually used in the following
surfDesc.fWidth = backendTex.width();
surfDesc.fHeight = backendTex.height();
surfDesc.fConfig = backendTex.config();
surfDesc.fSampleCnt = this->caps()->getSampleCount(sampleCnt, backendTex.config());
// In GL, Chrome assumes all textures are BottomLeft
// In VK, we don't have this restriction
surfDesc.fOrigin = resolve_origin(origin);
return GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(this, surfDesc, ownership,
backendTex.getVkImageInfo());
}
sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT,
GrSurfaceOrigin origin){
sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT){
// 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
@ -934,8 +922,7 @@ sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTa
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
SkASSERT(kDefault_GrSurfaceOrigin != origin);
desc.fOrigin = origin;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin; // Not actually used in the following
desc.fWidth = backendRT.width();
desc.fHeight = backendRT.height();
desc.fConfig = backendRT.config();
@ -951,7 +938,6 @@ sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTa
}
sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
GrSurfaceOrigin origin,
int sampleCnt) {
const GrVkImageInfo* info = tex.getVkImageInfo();
@ -964,7 +950,7 @@ sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendTextureAsRenderTarget(const GrBacken
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fOrigin = resolve_origin(origin);
desc.fOrigin = kBottomLeft_GrSurfaceOrigin; // Not actually used in the following
desc.fWidth = tex.width();
desc.fHeight = tex.height();
desc.fConfig = tex.config();
@ -974,7 +960,7 @@ sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendTextureAsRenderTarget(const GrBacken
return tgt;
}
void GrVkGpu::generateMipmap(GrVkTexture* tex) {
void GrVkGpu::generateMipmap(GrVkTexture* tex, GrSurfaceOrigin texOrigin) {
// don't do anything for linearly tiled textures (can't have mipmaps)
if (tex->isLinearTiled()) {
SkDebugf("Trying to create mipmap for linear tiled texture");
@ -996,7 +982,7 @@ void GrVkGpu::generateMipmap(GrVkTexture* tex) {
// We may need to resolve the texture first if it is also a render target
GrVkRenderTarget* texRT = static_cast<GrVkRenderTarget*>(tex->asRenderTarget());
if (texRT) {
this->internalResolveRenderTarget(texRT, false);
this->internalResolveRenderTarget(texRT, texOrigin, false);
}
int width = tex->width();
@ -1504,8 +1490,8 @@ void GrVkGpu::clearStencil(GrRenderTarget* target) {
fCurrentCmdBuffer->clearDepthStencilImage(this, vkStencil, &vkStencilColor, 1, &subRange);
}
inline bool can_copy_image(const GrSurface* dst,
const GrSurface* src,
inline bool can_copy_image(const GrSurface* dst, GrSurfaceOrigin dstOrigin,
const GrSurface* src, GrSurfaceOrigin srcOrigin,
const GrVkGpu* gpu) {
const GrRenderTarget* dstRT = dst->asRenderTarget();
const GrRenderTarget* srcRT = src->asRenderTarget();
@ -1525,7 +1511,7 @@ inline bool can_copy_image(const GrSurface* dst,
// We require that all vulkan GrSurfaces have been created with transfer_dst and transfer_src
// as image usage flags.
if (src->origin() == dst->origin() &&
if (srcOrigin == dstOrigin &&
GrBytesPerPixel(src->config()) == GrBytesPerPixel(dst->config())) {
return true;
}
@ -1533,13 +1519,13 @@ inline bool can_copy_image(const GrSurface* dst,
return false;
}
void GrVkGpu::copySurfaceAsCopyImage(GrSurface* dst,
GrSurface* src,
void GrVkGpu::copySurfaceAsCopyImage(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
GrVkImage* dstImage,
GrVkImage* srcImage,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
SkASSERT(can_copy_image(dst, src, this));
SkASSERT(can_copy_image(dst, dstOrigin, src, srcOrigin, this));
// These flags are for flushing/invalidating caches and for the dst image it doesn't matter if
// the cache is flushed since it is only being written to.
@ -1559,8 +1545,8 @@ void GrVkGpu::copySurfaceAsCopyImage(GrSurface* dst,
SkIRect srcVkRect = srcRect;
int32_t dstY = dstPoint.fY;
if (kBottomLeft_GrSurfaceOrigin == src->origin()) {
SkASSERT(kBottomLeft_GrSurfaceOrigin == dst->origin());
if (kBottomLeft_GrSurfaceOrigin == srcOrigin) {
SkASSERT(kBottomLeft_GrSurfaceOrigin == dstOrigin);
srcVkRect.fTop = src->height() - srcRect.fBottom;
srcVkRect.fBottom = src->height() - srcRect.fTop;
dstY = dst->height() - dstPoint.fY - srcVkRect.height();
@ -1610,8 +1596,8 @@ inline bool can_copy_as_blit(const GrSurface* dst,
return true;
}
void GrVkGpu::copySurfaceAsBlit(GrSurface* dst,
GrSurface* src,
void GrVkGpu::copySurfaceAsBlit(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
GrVkImage* dstImage,
GrVkImage* srcImage,
const SkIRect& srcRect,
@ -1638,7 +1624,7 @@ void GrVkGpu::copySurfaceAsBlit(GrSurface* dst,
dstRect.fLeft = dstPoint.fX;
dstRect.fRight = dstPoint.fX + srcRect.width();
if (kBottomLeft_GrSurfaceOrigin == src->origin()) {
if (kBottomLeft_GrSurfaceOrigin == srcOrigin) {
srcVkRect.fTop = src->height() - srcRect.fBottom;
srcVkRect.fBottom = src->height() - srcRect.fTop;
} else {
@ -1646,7 +1632,7 @@ void GrVkGpu::copySurfaceAsBlit(GrSurface* dst,
srcVkRect.fBottom = srcRect.fBottom;
}
if (kBottomLeft_GrSurfaceOrigin == dst->origin()) {
if (kBottomLeft_GrSurfaceOrigin == dstOrigin) {
dstRect.fTop = dst->height() - dstPoint.fY - srcVkRect.height();
} else {
dstRect.fTop = dstPoint.fY;
@ -1655,7 +1641,7 @@ void GrVkGpu::copySurfaceAsBlit(GrSurface* dst,
// If we have different origins, we need to flip the top and bottom of the dst rect so that we
// get the correct origintation of the copied data.
if (src->origin() != dst->origin()) {
if (srcOrigin != dstOrigin) {
SkTSwap(dstRect.fTop, dstRect.fBottom);
}
@ -1678,8 +1664,8 @@ void GrVkGpu::copySurfaceAsBlit(GrSurface* dst,
this->didWriteToSurface(dst, &dstRect);
}
inline bool can_copy_as_resolve(const GrSurface* dst,
const GrSurface* src,
inline bool can_copy_as_resolve(const GrSurface* dst, GrSurfaceOrigin dstOrigin,
const GrSurface* src, GrSurfaceOrigin srcOrigin,
const GrVkGpu* gpu) {
// Our src must be a multisampled render target
if (!src->asRenderTarget() || src->asRenderTarget()->numColorSamples() <= 1) {
@ -1694,27 +1680,27 @@ inline bool can_copy_as_resolve(const GrSurface* dst,
}
// Surfaces must have the same origin.
if (src->origin() != dst->origin()) {
if (srcOrigin != dstOrigin) {
return false;
}
return true;
}
void GrVkGpu::copySurfaceAsResolve(GrSurface* dst,
GrSurface* src,
void GrVkGpu::copySurfaceAsResolve(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
GrVkRenderTarget* srcRT = static_cast<GrVkRenderTarget*>(src->asRenderTarget());
this->resolveImage(dst, srcRT, srcRect, dstPoint);
this->resolveImage(dst, dstOrigin, srcRT, srcOrigin, srcRect, dstPoint);
}
bool GrVkGpu::onCopySurface(GrSurface* dst,
GrSurface* src,
bool GrVkGpu::onCopySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
if (can_copy_as_resolve(dst, src, this)) {
this->copySurfaceAsResolve(dst, src, srcRect, dstPoint);
if (can_copy_as_resolve(dst, dstOrigin, src, srcOrigin, this)) {
this->copySurfaceAsResolve(dst, dstOrigin, src, srcOrigin, srcRect, dstPoint);
return true;
}
@ -1722,7 +1708,7 @@ bool GrVkGpu::onCopySurface(GrSurface* dst,
this->submitCommandBuffer(GrVkGpu::kSkip_SyncQueue);
}
if (fCopyManager.copySurfaceAsDraw(this, dst, src, srcRect, dstPoint)) {
if (fCopyManager.copySurfaceAsDraw(this, dst, dstOrigin, src, srcOrigin, srcRect, dstPoint)) {
return true;
}
@ -1750,27 +1736,30 @@ bool GrVkGpu::onCopySurface(GrSurface* dst,
return false;
}
if (can_copy_image(dst, src, this)) {
this->copySurfaceAsCopyImage(dst, src, dstImage, srcImage, srcRect, dstPoint);
if (can_copy_image(dst, dstOrigin, src, srcOrigin, this)) {
this->copySurfaceAsCopyImage(dst, dstOrigin, src, srcOrigin, dstImage, srcImage,
srcRect, dstPoint);
return true;
}
if (can_copy_as_blit(dst, src, dstImage, srcImage, this)) {
this->copySurfaceAsBlit(dst, src, dstImage, srcImage, srcRect, dstPoint);
this->copySurfaceAsBlit(dst, dstOrigin, src, srcOrigin, dstImage, srcImage,
srcRect, dstPoint);
return true;
}
return false;
}
void GrVkGpu::onQueryMultisampleSpecs(GrRenderTarget* rt, const GrStencilSettings&,
void GrVkGpu::onQueryMultisampleSpecs(GrRenderTarget* rt, GrSurfaceOrigin, const GrStencilSettings&,
int* effectiveSampleCnt, SamplePattern*) {
// TODO: stub.
SkASSERT(!this->caps()->sampleLocationsSupport());
*effectiveSampleCnt = rt->numStencilSamples();
}
bool GrVkGpu::onGetReadPixelsInfo(GrSurface* srcSurface, int width, int height, size_t rowBytes,
bool GrVkGpu::onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin,
int width, int height, size_t rowBytes,
GrPixelConfig readConfig, DrawPreference* drawPreference,
ReadPixelTempDrawInfo* tempDrawInfo) {
// These settings we will always want if a temp draw is performed.
@ -1803,7 +1792,7 @@ bool GrVkGpu::onGetReadPixelsInfo(GrSurface* srcSurface, int width, int height,
return true;
}
bool GrVkGpu::onReadPixels(GrSurface* surface,
bool GrVkGpu::onReadPixels(GrSurface* surface, GrSurfaceOrigin origin,
int left, int top, int width, int height,
GrPixelConfig config,
void* buffer,
@ -1823,7 +1812,7 @@ bool GrVkGpu::onReadPixels(GrSurface* surface,
case GrVkRenderTarget::kAutoResolves_ResolveType:
break;
case GrVkRenderTarget::kCanResolve_ResolveType:
this->internalResolveRenderTarget(rt, false);
this->internalResolveRenderTarget(rt, origin, false);
break;
default:
SkFAIL("Unknown resolve type");
@ -1846,7 +1835,7 @@ bool GrVkGpu::onReadPixels(GrSurface* surface,
size_t bpp = GrBytesPerPixel(config);
size_t tightRowBytes = bpp * width;
bool flipY = kBottomLeft_GrSurfaceOrigin == surface->origin();
bool flipY = kBottomLeft_GrSurfaceOrigin == origin;
VkBufferImageCopy region;
memset(&region, 0, sizeof(VkBufferImageCopy));
@ -1970,11 +1959,11 @@ void adjust_bounds_to_granularity(SkIRect* dstBounds, const SkIRect& srcBounds,
void GrVkGpu::submitSecondaryCommandBuffer(const SkTArray<GrVkSecondaryCommandBuffer*>& buffers,
const GrVkRenderPass* renderPass,
const VkClearValue* colorClear,
GrVkRenderTarget* target,
GrVkRenderTarget* target, GrSurfaceOrigin origin,
const SkIRect& bounds) {
const SkIRect* pBounds = &bounds;
SkIRect flippedBounds;
if (kBottomLeft_GrSurfaceOrigin == target->origin()) {
if (kBottomLeft_GrSurfaceOrigin == origin) {
flippedBounds = bounds;
flippedBounds.fTop = target->height() - bounds.fBottom;
flippedBounds.fBottom = target->height() - bounds.fTop;

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

@ -66,20 +66,21 @@ public:
kSkip_SyncQueue
};
bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
bool onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin,
int readWidth, int readHeight, size_t rowBytes,
GrPixelConfig readConfig, DrawPreference*,
ReadPixelTempDrawInfo*) override;
bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
bool onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin,
int width, int height,
GrPixelConfig srcConfig, DrawPreference*,
WritePixelTempDrawInfo*) override;
bool onCopySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) override;
bool onCopySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint) override;
void onQueryMultisampleSpecs(GrRenderTarget* rt, const GrStencilSettings&,
void onQueryMultisampleSpecs(GrRenderTarget*, GrSurfaceOrigin, const GrStencilSettings&,
int* effectiveSampleCnt, SamplePattern*) override;
void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {}
@ -117,14 +118,14 @@ public:
return fCompiler;
}
void onResolveRenderTarget(GrRenderTarget* target) override {
this->internalResolveRenderTarget(target, true);
void onResolveRenderTarget(GrRenderTarget* target, GrSurfaceOrigin origin) override {
this->internalResolveRenderTarget(target, origin, true);
}
void submitSecondaryCommandBuffer(const SkTArray<GrVkSecondaryCommandBuffer*>&,
const GrVkRenderPass*,
const VkClearValue*,
GrVkRenderTarget*,
GrVkRenderTarget*, GrSurfaceOrigin,
const SkIRect& bounds);
void finishFlush() override;
@ -141,7 +142,7 @@ public:
sk_sp<GrSemaphore> prepareTextureForCrossContextUsage(GrTexture*) override;
void generateMipmap(GrVkTexture* tex);
void generateMipmap(GrVkTexture* tex, GrSurfaceOrigin texOrigin);
bool updateBuffer(GrVkBuffer* buffer, const void* src, VkDeviceSize offset, VkDeviceSize size);
@ -178,18 +179,13 @@ private:
sk_sp<GrTexture> onCreateTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
const GrMipLevel texels[], int mipLevelCount) override;
sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
GrSurfaceOrigin,
GrWrapOwnership) override;
sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrWrapOwnership) override;
sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt,
GrWrapOwnership) override;
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
GrSurfaceOrigin) override;
sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt) override;
GrBuffer* onCreateBuffer(size_t size, GrBufferType type, GrAccessPattern,
@ -197,13 +193,13 @@ private:
gr_instanced::InstancedRendering* onCreateInstancedRendering() override { return nullptr; }
bool onReadPixels(GrSurface* surface,
bool onReadPixels(GrSurface* surface, GrSurfaceOrigin,
int left, int top, int width, int height,
GrPixelConfig,
void* buffer,
size_t rowBytes) override;
bool onWritePixels(GrSurface* surface,
bool onWritePixels(GrSurface* surface, GrSurfaceOrigin,
int left, int top, int width, int height,
GrPixelConfig config, const GrMipLevel texels[], int mipLevelCount) override;
@ -220,42 +216,39 @@ private:
// wait semaphores to the submission of this command buffer.
void submitCommandBuffer(SyncQueue sync);
void internalResolveRenderTarget(GrRenderTarget* target, bool requiresSubmit);
void internalResolveRenderTarget(GrRenderTarget*, GrSurfaceOrigin origin, bool requiresSubmit);
void copySurfaceAsCopyImage(GrSurface* dst,
GrSurface* src,
GrVkImage* dstImage,
GrVkImage* srcImage,
void copySurfaceAsCopyImage(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
GrVkImage* dstImage, GrVkImage* srcImage,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
void copySurfaceAsBlit(GrSurface* dst,
GrSurface* src,
GrVkImage* dstImage,
GrVkImage* srcImage,
void copySurfaceAsBlit(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
GrVkImage* dstImage, GrVkImage* srcImage,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
void copySurfaceAsResolve(GrSurface* dst,
GrSurface* src,
void copySurfaceAsResolve(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrSurface* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
// helpers for onCreateTexture and writeTexturePixels
bool uploadTexDataLinear(GrVkTexture* tex,
bool uploadTexDataLinear(GrVkTexture* tex, GrSurfaceOrigin texOrigin,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
const void* data,
size_t rowBytes);
bool uploadTexDataOptimal(GrVkTexture* tex,
bool uploadTexDataOptimal(GrVkTexture* tex, GrSurfaceOrigin texOrigin,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
const GrMipLevel texels[], int mipLevelCount);
void resolveImage(GrSurface* dst,
GrVkRenderTarget* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
void resolveImage(GrSurface* dst, GrSurfaceOrigin dstOrigin,
GrVkRenderTarget* src, GrSurfaceOrigin srcOrigin,
const SkIRect& srcRect, const SkIPoint& dstPoint);
sk_sp<const GrVkBackendContext> fBackendContext;
sk_sp<GrVkCaps> fVkCaps;

16
src/gpu/vk/GrVkGpuCommandBuffer.cpp
View File

@ -178,7 +178,8 @@ void GrVkGpuCommandBuffer::onSubmit() {
cbInfo.fBounds.roundOut(&iBounds);
fGpu->submitSecondaryCommandBuffer(cbInfo.fCommandBuffers, cbInfo.fRenderPass,
&cbInfo.fColorClearValue, fRenderTarget, iBounds);
&cbInfo.fColorClearValue, fRenderTarget, fOrigin,
iBounds);
}
}
}
@ -499,10 +500,12 @@ sk_sp<GrVkPipelineState> GrVkGpuCommandBuffer::prepareDrawState(
GrRenderTarget* rt = pipeline.renderTarget();
if (!pipeline.getScissorState().enabled()) {
GrVkPipeline::SetDynamicScissorRectState(fGpu, cbInfo.currentCmdBuf(), rt,
GrVkPipeline::SetDynamicScissorRectState(fGpu, cbInfo.currentCmdBuf(),
rt, pipeline.proxy()->origin(),
SkIRect::MakeWH(rt->width(), rt->height()));
} else if (!hasDynamicState) {
GrVkPipeline::SetDynamicScissorRectState(fGpu, cbInfo.currentCmdBuf(), rt,
GrVkPipeline::SetDynamicScissorRectState(fGpu, cbInfo.currentCmdBuf(),
rt, pipeline.proxy()->origin(),
pipeline.getScissorState().rect());
}
GrVkPipeline::SetDynamicViewportState(fGpu, cbInfo.currentCmdBuf(), rt);
@ -531,14 +534,14 @@ static void prepare_sampled_images(const GrResourceIOProcessor& processor, GrVkG
// We may need to resolve the texture first if it is also a render target
GrVkRenderTarget* texRT = static_cast<GrVkRenderTarget*>(vkTexture->asRenderTarget());
if (texRT) {
gpu->onResolveRenderTarget(texRT);
gpu->onResolveRenderTarget(texRT, sampler.proxy()->origin());
}
const GrSamplerParams& params = sampler.params();
// Check if we need to regenerate any mip maps
if (GrSamplerParams::kMipMap_FilterMode == params.filterMode()) {
if (vkTexture->texturePriv().mipMapsAreDirty()) {
gpu->generateMipmap(vkTexture);
gpu->generateMipmap(vkTexture, sampler.proxy()->origin());
vkTexture->texturePriv().dirtyMipMaps(false);
}
}
@ -602,7 +605,8 @@ void GrVkGpuCommandBuffer::onDraw(const GrPipeline& pipeline,
if (dynamicStates) {
if (pipeline.getScissorState().enabled()) {
GrVkPipeline::SetDynamicScissorRectState(fGpu, cbInfo.currentCmdBuf(),
target, dynamicStates[i].fScissorRect);
target, pipeline.proxy()->origin(),
dynamicStates[i].fScissorRect);
}
}

5
src/gpu/vk/GrVkPipeline.cpp
View File

@ -495,6 +495,7 @@ void GrVkPipeline::freeGPUData(const GrVkGpu* gpu) const {
void GrVkPipeline::SetDynamicScissorRectState(GrVkGpu* gpu,
GrVkCommandBuffer* cmdBuffer,
const GrRenderTarget* renderTarget,
GrSurfaceOrigin rtOrigin,
SkIRect scissorRect) {
if (!scissorRect.intersect(SkIRect::MakeWH(renderTarget->width(), renderTarget->height()))) {
scissorRect.setEmpty();
@ -503,10 +504,10 @@ void GrVkPipeline::SetDynamicScissorRectState(GrVkGpu* gpu,
VkRect2D scissor;
scissor.offset.x = scissorRect.fLeft;
scissor.extent.width = scissorRect.width();
if (kTopLeft_GrSurfaceOrigin == renderTarget->origin()) {
if (kTopLeft_GrSurfaceOrigin == rtOrigin) {
scissor.offset.y = scissorRect.fTop;
} else {
SkASSERT(kBottomLeft_GrSurfaceOrigin == renderTarget->origin());
SkASSERT(kBottomLeft_GrSurfaceOrigin == rtOrigin);
scissor.offset.y = renderTarget->height() - scissorRect.fBottom;
}
scissor.extent.height = scissorRect.height();

2
src/gpu/vk/GrVkPipeline.h
View File

@ -40,7 +40,7 @@ public:
VkPipeline pipeline() const { return fPipeline; }
static void SetDynamicScissorRectState(GrVkGpu*, GrVkCommandBuffer*, const GrRenderTarget*,
SkIRect);
GrSurfaceOrigin, SkIRect);
static void SetDynamicViewportState(GrVkGpu*, GrVkCommandBuffer*, const GrRenderTarget*);
static void SetDynamicBlendConstantState(GrVkGpu*, GrVkCommandBuffer*, GrPixelConfig,
const GrXferProcessor&);

7
src/image/SkImage_Gpu.cpp
View File

@ -266,9 +266,8 @@ static sk_sp<SkImage> new_wrapped_texture_common(GrContext* ctx,
return nullptr;
}
sk_sp<GrTexture> tex = ctx->resourceProvider()->wrapBackendTexture(backendTex,
origin,
ownership);
SkASSERT(kDefault_GrSurfaceOrigin != origin);
sk_sp<GrTexture> tex = ctx->resourceProvider()->wrapBackendTexture(backendTex, ownership);
if (!tex) {
return nullptr;
}
@ -491,7 +490,7 @@ sk_sp<SkImage> SkImage::MakeCrossContextFromEncoded(GrContext* context, sk_sp<Sk
sk_sp<GrSemaphore> sema = context->getGpu()->prepareTextureForCrossContextUsage(texture.get());
auto gen = GrBackendTextureImageGenerator::Make(std::move(texture),
auto gen = GrBackendTextureImageGenerator::Make(std::move(texture), proxy->origin(),
std::move(sema), codecImage->alphaType(),
std::move(texColorSpace));
return SkImage::MakeFromGenerator(std::move(gen));

2
tests/GrSurfaceTest.cpp
View File

@ -58,7 +58,7 @@ DEF_GPUTEST_FOR_NULLGL_CONTEXT(GrSurface, reporter, ctxInfo) {
backendTexHandle);
sk_sp<GrSurface> texRT2 = context->resourceProvider()->wrapRenderableBackendTexture(
backendTex, kTopLeft_GrSurfaceOrigin, 0, kBorrow_GrWrapOwnership);
backendTex, 0, kBorrow_GrWrapOwnership);
REPORTER_ASSERT(reporter, texRT2.get() == texRT2->asRenderTarget());
REPORTER_ASSERT(reporter, texRT2.get() == texRT2->asTexture());

2
tests/ProxyConversionTest.cpp
View File

@ -27,7 +27,7 @@ static sk_sp<GrSurfaceProxy> make_wrapped_FBO0(GrResourceProvider* provider,
desc.fConfig, fboInfo);
SkASSERT(kDefault_GrSurfaceOrigin != desc.fOrigin);
sk_sp<GrRenderTarget> defaultFBO(provider->wrapBackendRenderTarget(backendRT, desc.fOrigin));
sk_sp<GrRenderTarget> defaultFBO(provider->wrapBackendRenderTarget(backendRT));
SkASSERT(!defaultFBO->asTexture());
return GrSurfaceProxy::MakeWrapped(std::move(defaultFBO), desc.fOrigin);

4
tests/ProxyTest.cpp
View File

@ -63,7 +63,6 @@ static void check_rendertarget(skiatest::Reporter* reporter,
REPORTER_ASSERT(reporter, rtProxy->uniqueID().asUInt() != rt->uniqueID().asUInt());
}
REPORTER_ASSERT(reporter, rt->origin() == rtProxy->origin());
if (SkBackingFit::kExact == fit) {
REPORTER_ASSERT(reporter, rt->width() == rtProxy->width());
REPORTER_ASSERT(reporter, rt->height() == rtProxy->height());
@ -98,7 +97,6 @@ static void check_texture(skiatest::Reporter* reporter,
REPORTER_ASSERT(reporter, texProxy->uniqueID().asUInt() != tex->uniqueID().asUInt());
}
REPORTER_ASSERT(reporter, tex->origin() == texProxy->origin());
if (SkBackingFit::kExact == fit) {
REPORTER_ASSERT(reporter, tex->width() == texProxy->width());
REPORTER_ASSERT(reporter, tex->height() == texProxy->height());
@ -234,7 +232,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) {
config, fboInfo);
sk_sp<GrRenderTarget> defaultFBO(
provider->wrapBackendRenderTarget(backendRT, origin));
provider->wrapBackendRenderTarget(backendRT));
sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(defaultFBO,
origin));

7
tests/ResourceAllocatorTest.cpp
View File

@ -54,7 +54,7 @@ static sk_sp<GrSurfaceProxy> make_backend(GrContext* context, const ProxyParams&
*backendTexHandle);
SkASSERT(kDefault_GrSurfaceOrigin != p.fOrigin);
sk_sp<GrSurface> tex = context->resourceProvider()->wrapBackendTexture(backendTex, p.fOrigin,
sk_sp<GrSurface> tex = context->resourceProvider()->wrapBackendTexture(backendTex,
kBorrow_GrWrapOwnership);
return GrSurfaceProxy::MakeWrapped(std::move(tex), p.fOrigin);
}
@ -169,9 +169,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceAllocatorTest, reporter, ctxInfo) {
// Two non-overlapping intervals w/ different RT classifications should never share
{ { 64, kRT, kRGBA, kA, 0, kTL }, { 64, kNotRT, kRGBA, kA, 0, kTL }, kDontShare },
{ { 64, kNotRT, kRGBA, kA, 0, kTL }, { 64, kRT, kRGBA, kA, 0, kTL }, kDontShare },
// Two non-overlapping intervals w/ different origins should not share
// TODO: rm this test case
{ { 64, kRT, kRGBA, kA, 0, kTL }, { 64, kRT, kRGBA, kA, 0, kBL }, kDontShare },
// Two non-overlapping intervals w/ different origins should share
{ { 64, kRT, kRGBA, kA, 0, kTL }, { 64, kRT, kRGBA, kA, 0, kBL }, kShare },
};
for (auto test : gNonOverlappingTests) {

11
tests/ResourceCacheTest.cpp
View File

@ -96,9 +96,10 @@ DEF_GPUTEST_FOR_CONTEXTS(ResourceCacheStencilBuffers, &is_rendering_and_not_angl
GrContext* context = ctxInfo.grContext();
GrSurfaceDesc smallDesc;
smallDesc.fFlags = kRenderTarget_GrSurfaceFlag;
smallDesc.fConfig = kRGBA_8888_GrPixelConfig;
smallDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
smallDesc.fWidth = 4;
smallDesc.fHeight = 4;
smallDesc.fConfig = kRGBA_8888_GrPixelConfig;
smallDesc.fSampleCnt = 0;
if (context->caps()->avoidStencilBuffers()) {
@ -136,9 +137,10 @@ DEF_GPUTEST_FOR_CONTEXTS(ResourceCacheStencilBuffers, &is_rendering_and_not_angl
// An RT with a much larger size should not share.
GrSurfaceDesc bigDesc;
bigDesc.fFlags = kRenderTarget_GrSurfaceFlag;
bigDesc.fConfig = kRGBA_8888_GrPixelConfig;
bigDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
bigDesc.fWidth = 400;
bigDesc.fHeight = 200;
bigDesc.fConfig = kRGBA_8888_GrPixelConfig;
bigDesc.fSampleCnt = 0;
sk_sp<GrTexture> bigRT(resourceProvider->createTexture(bigDesc, SkBudgeted::kNo));
if (bigRT && bigRT->asRenderTarget()) {
@ -228,7 +230,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheWrappedResources, reporter, ctxI
kRGBA_8888_GrPixelConfig,
texHandles[0]);
sk_sp<GrTexture> borrowed(context->resourceProvider()->wrapBackendTexture(
backendTex1, kTopLeft_GrSurfaceOrigin, kBorrow_GrWrapOwnership));
backendTex1, kBorrow_GrWrapOwnership));
GrBackendTexture backendTex2 = GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
kW,
@ -236,7 +238,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheWrappedResources, reporter, ctxI
kRGBA_8888_GrPixelConfig,
texHandles[1]);
sk_sp<GrTexture> adopted(context->resourceProvider()->wrapBackendTexture(
backendTex2, kTopLeft_GrSurfaceOrigin, kAdopt_GrWrapOwnership));
backendTex2, kAdopt_GrWrapOwnership));
REPORTER_ASSERT(reporter, borrowed != nullptr && adopted != nullptr);
if (!borrowed || !adopted) {
@ -1636,6 +1638,7 @@ static sk_sp<GrTexture> make_normal_texture(GrResourceProvider* provider,
int sampleCnt) {
GrSurfaceDesc desc;
desc.fFlags = flags;
desc.fOrigin = kTopLeft_GrSurfaceOrigin;
desc.fWidth = width;
desc.fHeight = height;
desc.fConfig = kRGBA_8888_GrPixelConfig;

4
tests/TransferPixelsTest.cpp
View File

@ -109,7 +109,7 @@ void basic_transfer_test(skiatest::Reporter* reporter, GrContext* context, GrPix
REPORTER_ASSERT(reporter, result);
memset(dstBuffer.get(), 0xCDCD, size);
result = context->getGpu()->readPixels(tex.get(), 0, 0, kTextureWidth, kTextureHeight,
result = context->getGpu()->readPixels(tex.get(), origin, 0, 0, kTextureWidth, kTextureHeight,
config, dstBuffer.get(), rowBytes);
if (result) {
REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_values(srcBuffer,
@ -141,7 +141,7 @@ void basic_transfer_test(skiatest::Reporter* reporter, GrContext* context, GrPix
REPORTER_ASSERT(reporter, result);
memset(dstBuffer.get(), 0xCDCD, size);
result = context->getGpu()->readPixels(tex.get(), 0, 0, kTextureWidth, kTextureHeight,
result = context->getGpu()->readPixels(tex.get(), origin, 0, 0, kTextureWidth, kTextureHeight,
config, dstBuffer.get(), rowBytes);
if (result) {
REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_values(srcBuffer,

59
tests/VkWrapTests.cpp
View File

@ -37,42 +37,30 @@ void wrap_tex_test(skiatest::Reporter* reporter, GrContext* context) {
const GrVkImageInfo* imageInfo = reinterpret_cast<const GrVkImageInfo*>(backendObj);
GrBackendTexture backendTex = GrBackendTexture(kW, kH, *imageInfo);
sk_sp<GrTexture> tex = gpu->wrapBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
kBorrow_GrWrapOwnership);
sk_sp<GrTexture> tex = gpu->wrapBackendTexture(backendTex, kBorrow_GrWrapOwnership);
REPORTER_ASSERT(reporter, tex);
// image is null
GrVkImageInfo backendCopy = *imageInfo;
backendCopy.fImage = VK_NULL_HANDLE;
backendTex = GrBackendTexture(kW, kH, backendCopy);
tex = gpu->wrapBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
kBorrow_GrWrapOwnership);
tex = gpu->wrapBackendTexture(backendTex, kBorrow_GrWrapOwnership);
REPORTER_ASSERT(reporter, !tex);
tex = gpu->wrapBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
kAdopt_GrWrapOwnership);
tex = gpu->wrapBackendTexture(backendTex, kAdopt_GrWrapOwnership);
REPORTER_ASSERT(reporter, !tex);
// alloc is null
backendCopy.fImage = imageInfo->fImage;
backendCopy.fAlloc = { VK_NULL_HANDLE, 0, 0, 0 };
backendTex = GrBackendTexture(kW, kH, backendCopy);
tex = gpu->wrapBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
kBorrow_GrWrapOwnership);
tex = gpu->wrapBackendTexture(backendTex, kBorrow_GrWrapOwnership);
REPORTER_ASSERT(reporter, !tex);
tex = gpu->wrapBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
kAdopt_GrWrapOwnership);
tex = gpu->wrapBackendTexture(backendTex, kAdopt_GrWrapOwnership);
REPORTER_ASSERT(reporter, !tex);
// check adopt creation
backendCopy.fAlloc = imageInfo->fAlloc;
backendTex = GrBackendTexture(kW, kH, backendCopy);
tex = gpu->wrapBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
kAdopt_GrWrapOwnership);
tex = gpu->wrapBackendTexture(backendTex, kAdopt_GrWrapOwnership);
REPORTER_ASSERT(reporter, tex);
@ -88,14 +76,14 @@ void wrap_rt_test(skiatest::Reporter* reporter, GrContext* context) {
GrBackendRenderTarget backendRT(kW, kH, 0, 0, *backendTex);
sk_sp<GrRenderTarget> rt = gpu->wrapBackendRenderTarget(backendRT, kTopLeft_GrSurfaceOrigin);
sk_sp<GrRenderTarget> rt = gpu->wrapBackendRenderTarget(backendRT);
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);
rt = gpu->wrapBackendRenderTarget(backendRT2);
REPORTER_ASSERT(reporter, !rt);
// alloc is null
@ -103,7 +91,7 @@ void wrap_rt_test(skiatest::Reporter* reporter, GrContext* context) {
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(backendRT3);
REPORTER_ASSERT(reporter, rt);
// When we wrapBackendRenderTarget it is always borrowed, so we must make sure to free the
@ -119,9 +107,7 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) {
const GrVkImageInfo* imageInfo = reinterpret_cast<const GrVkImageInfo*>(backendObj);
GrBackendTexture backendTex = GrBackendTexture(kW, kH, *imageInfo);
sk_sp<GrTexture> tex = gpu->wrapRenderableBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
0,
sk_sp<GrTexture> tex = gpu->wrapRenderableBackendTexture(backendTex, 0,
kBorrow_GrWrapOwnership);
REPORTER_ASSERT(reporter, tex);
@ -129,39 +115,24 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) {
GrVkImageInfo backendCopy = *imageInfo;
backendCopy.fImage = VK_NULL_HANDLE;
backendTex = GrBackendTexture(kW, kH, backendCopy);
tex = gpu->wrapRenderableBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
0,
kBorrow_GrWrapOwnership);
tex = gpu->wrapRenderableBackendTexture(backendTex, 0, kBorrow_GrWrapOwnership);
REPORTER_ASSERT(reporter, !tex);
tex = gpu->wrapRenderableBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
0,
kAdopt_GrWrapOwnership);
tex = gpu->wrapRenderableBackendTexture(backendTex, 0, kAdopt_GrWrapOwnership);
REPORTER_ASSERT(reporter, !tex);
// alloc is null
backendCopy.fImage = imageInfo->fImage;
backendCopy.fAlloc = { VK_NULL_HANDLE, 0, 0, 0 };
backendTex = GrBackendTexture(kW, kH, backendCopy);
tex = gpu->wrapRenderableBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
0,
kBorrow_GrWrapOwnership);
tex = gpu->wrapRenderableBackendTexture(backendTex, 0, kBorrow_GrWrapOwnership);
REPORTER_ASSERT(reporter, !tex);
tex = gpu->wrapRenderableBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
0,
kAdopt_GrWrapOwnership);
tex = gpu->wrapRenderableBackendTexture(backendTex, 0, kAdopt_GrWrapOwnership);
REPORTER_ASSERT(reporter, !tex);
// check adopt creation
backendCopy.fAlloc = imageInfo->fAlloc;
backendTex = GrBackendTexture(kW, kH, backendCopy);
tex = gpu->wrapRenderableBackendTexture(backendTex,
kTopLeft_GrSurfaceOrigin,
0,
kAdopt_GrWrapOwnership);
tex = gpu->wrapRenderableBackendTexture(backendTex, 0, kAdopt_GrWrapOwnership);
REPORTER_ASSERT(reporter, tex);
gpu->deleteTestingOnlyBackendTexture(backendObj, true);