Revert "Remove origin field from GrSurface"
This reverts commit df0e09feacb29290fe94d37f921731b18f2edae0.
Reason for revert: Experimental revert to see if this is blocking the roll
Original change's description:
> Remove origin field from GrSurface
>
> 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>
TBR=bsalomon@google.com,robertphillips@google.com
Change-Id: Id606aa01e84e2b83be71d833eefca477c1ad0d01
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/29220
Reviewed-by: Robert Phillips <robertphillips@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
diff --git a/src/gpu/vk/GrVkCopyManager.cpp b/src/gpu/vk/GrVkCopyManager.cpp
index d64d04f..938596f 100644
--- a/src/gpu/vk/GrVkCopyManager.cpp
+++ b/src/gpu/vk/GrVkCopyManager.cpp
@@ -143,9 +143,10 @@
}
bool GrVkCopyManager::copySurfaceAsDraw(GrVkGpu* gpu,
- GrSurface* dst, GrSurfaceOrigin dstOrigin,
- GrSurface* src, GrSurfaceOrigin srcOrigin,
- const SkIRect& srcRect, const SkIPoint& dstPoint) {
+ GrSurface* dst,
+ GrSurface* src,
+ 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()) !=
@@ -203,7 +204,7 @@
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 == dstOrigin) {
+ if (kBottomLeft_GrSurfaceOrigin == dst->origin()) {
dy0 = -dy0;
dy1 = -dy1;
}
@@ -214,7 +215,7 @@
float sy0 = (float)srcRect.fTop;
float sy1 = (float)(srcRect.fTop + h);
int sh = src->height();
- if (kBottomLeft_GrSurfaceOrigin == srcOrigin) {
+ if (kBottomLeft_GrSurfaceOrigin == src->origin()) {
sy0 = sh - sy0;
sy1 = sh - sy1;
}
@@ -292,7 +293,7 @@
GrVkRenderTarget* texRT = static_cast<GrVkRenderTarget*>(srcTex->asRenderTarget());
if (texRT) {
- gpu->onResolveRenderTarget(texRT, srcOrigin);
+ gpu->onResolveRenderTarget(texRT);
}
GrVkPrimaryCommandBuffer* cmdBuffer = gpu->currentCommandBuffer();
diff --git a/src/gpu/vk/GrVkCopyManager.h b/src/gpu/vk/GrVkCopyManager.h
index 726faf3..36a08be 100644
--- a/src/gpu/vk/GrVkCopyManager.h
+++ b/src/gpu/vk/GrVkCopyManager.h
@@ -8,7 +8,6 @@
#ifndef GrVkCopyManager_DEFINED
#define GrVkCopyManager_DEFINED
-#include "GrTypes.h"
#include "GrVkDescriptorSetManager.h"
#include "vk/GrVkDefines.h"
@@ -28,9 +27,10 @@
~GrVkCopyManager();
bool copySurfaceAsDraw(GrVkGpu* gpu,
- GrSurface* dst, GrSurfaceOrigin dstOrigin,
- GrSurface* src, GrSurfaceOrigin srcOrigin,
- const SkIRect& srcRect, const SkIPoint& dstPoint);
+ GrSurface* dst,
+ GrSurface* src,
+ const SkIRect& srcRect,
+ const SkIPoint& dstPoint);
void destroyResources(GrVkGpu* gpu);
void abandonResources();
diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index 2f7cbe5..31e55de 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -332,8 +332,7 @@
}
////////////////////////////////////////////////////////////////////////////////
-bool GrVkGpu::onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin,
- int width, int height,
+bool GrVkGpu::onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
GrPixelConfig srcConfig, DrawPreference* drawPreference,
WritePixelTempDrawInfo* tempDrawInfo) {
GrRenderTarget* renderTarget = dstSurface->asRenderTarget();
@@ -376,7 +375,7 @@
return true;
}
-bool GrVkGpu::onWritePixels(GrSurface* surface, GrSurfaceOrigin origin,
+bool GrVkGpu::onWritePixels(GrSurface* surface,
int left, int top, int width, int height,
GrPixelConfig config,
const GrMipLevel texels[], int mipLevelCount) {
@@ -411,7 +410,7 @@
false);
this->submitCommandBuffer(kForce_SyncQueue);
}
- success = this->uploadTexDataLinear(vkTex, origin, left, top, width, height, config,
+ success = this->uploadTexDataLinear(vkTex, left, top, width, height, config,
texels[0].fPixels, texels[0].fRowBytes);
} else {
int currentMipLevels = vkTex->texturePriv().maxMipMapLevel() + 1;
@@ -420,7 +419,7 @@
return false;
}
}
- success = this->uploadTexDataOptimal(vkTex, origin, left, top, width, height, config,
+ success = this->uploadTexDataOptimal(vkTex, left, top, width, height, config,
texels, mipLevelCount);
}
@@ -488,9 +487,8 @@
return true;
}
-void GrVkGpu::resolveImage(GrSurface* dst, GrSurfaceOrigin dstOrigin,
- GrVkRenderTarget* src, GrSurfaceOrigin srcOrigin,
- const SkIRect& srcRect, const SkIPoint& dstPoint) {
+void GrVkGpu::resolveImage(GrSurface* dst, GrVkRenderTarget* src, const SkIRect& srcRect,
+ const SkIPoint& dstPoint) {
SkASSERT(dst);
SkASSERT(src && src->numColorSamples() > 1 && src->msaaImage());
@@ -502,8 +500,8 @@
SkIRect srcVkRect = srcRect;
int32_t dstY = dstPoint.fY;
- if (kBottomLeft_GrSurfaceOrigin == srcOrigin) {
- SkASSERT(kBottomLeft_GrSurfaceOrigin == dstOrigin);
+ if (kBottomLeft_GrSurfaceOrigin == src->origin()) {
+ SkASSERT(kBottomLeft_GrSurfaceOrigin == dst->origin());
srcVkRect.fTop = src->height() - srcRect.fBottom;
srcVkRect.fBottom = src->height() - srcRect.fTop;
dstY = dst->height() - dstPoint.fY - srcVkRect.height();
@@ -540,8 +538,7 @@
fCurrentCmdBuffer->resolveImage(this, *src->msaaImage(), *dstImage, 1, &resolveInfo);
}
-void GrVkGpu::internalResolveRenderTarget(GrRenderTarget* target, GrSurfaceOrigin origin,
- bool requiresSubmit) {
+void GrVkGpu::internalResolveRenderTarget(GrRenderTarget* target, bool requiresSubmit) {
if (target->needsResolve()) {
SkASSERT(target->numColorSamples() > 1);
GrVkRenderTarget* rt = static_cast<GrVkRenderTarget*>(target);
@@ -549,8 +546,7 @@
const SkIRect& srcRect = rt->getResolveRect();
- this->resolveImage(target, origin, rt, origin, srcRect,
- SkIPoint::Make(srcRect.fLeft, srcRect.fTop));
+ this->resolveImage(target, rt, srcRect, SkIPoint::Make(srcRect.fLeft, srcRect.fTop));
rt->flagAsResolved();
@@ -560,7 +556,7 @@
}
}
-bool GrVkGpu::uploadTexDataLinear(GrVkTexture* tex, GrSurfaceOrigin texOrigin,
+bool GrVkGpu::uploadTexDataLinear(GrVkTexture* tex,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
const void* data,
@@ -596,7 +592,7 @@
&subres,
&layout));
- int texTop = kBottomLeft_GrSurfaceOrigin == texOrigin ? tex->height() - top - height : top;
+ int texTop = kBottomLeft_GrSurfaceOrigin == tex->origin() ? tex->height() - top - height : top;
const GrVkAlloc& alloc = tex->alloc();
VkDeviceSize offset = alloc.fOffset + texTop*layout.rowPitch + left*bpp;
VkDeviceSize size = height*layout.rowPitch;
@@ -606,7 +602,7 @@
return false;
}
- if (kBottomLeft_GrSurfaceOrigin == texOrigin) {
+ if (kBottomLeft_GrSurfaceOrigin == tex->origin()) {
// copy into buffer by rows
const char* srcRow = reinterpret_cast<const char*>(data);
char* dstRow = reinterpret_cast<char*>(mapPtr)+(height - 1)*layout.rowPitch;
@@ -626,7 +622,7 @@
return true;
}
-bool GrVkGpu::uploadTexDataOptimal(GrVkTexture* tex, GrSurfaceOrigin texOrigin,
+bool GrVkGpu::uploadTexDataOptimal(GrVkTexture* tex,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
const GrMipLevel texels[], int mipLevelCount) {
@@ -661,7 +657,7 @@
}
// Determine whether we need to flip when we copy into the buffer
- bool flipY = (kBottomLeft_GrSurfaceOrigin == texOrigin && mipLevelCount);
+ bool flipY = (kBottomLeft_GrSurfaceOrigin == tex->origin() && mipLevelCount);
SkTArray<size_t> individualMipOffsets(mipLevelCount);
individualMipOffsets.push_back(0);
@@ -817,8 +813,8 @@
if (mipLevelCount) {
SkASSERT(texels[0].fPixels);
- if (!this->uploadTexDataOptimal(tex.get(), desc.fOrigin, 0, 0, desc.fWidth, desc.fHeight,
- desc.fConfig, texels, mipLevelCount)) {
+ if (!this->uploadTexDataOptimal(tex.get(), 0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
+ texels, mipLevelCount)) {
tex->unref();
return nullptr;
}
@@ -853,6 +849,15 @@
////////////////////////////////////////////////////////////////////////////////
+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) {
@@ -868,6 +873,7 @@
}
sk_sp<GrTexture> GrVkGpu::onWrapBackendTexture(const GrBackendTexture& backendTex,
+ GrSurfaceOrigin origin,
GrWrapOwnership ownership) {
if (!check_backend_texture(backendTex)) {
return nullptr;
@@ -875,16 +881,19 @@
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)) {
@@ -893,17 +902,20 @@
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){
+sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT,
+ GrSurfaceOrigin origin){
// Currently the Vulkan backend does not support wrapping of msaa render targets directly. In
// general this is not an issue since swapchain images in vulkan are never multisampled. Thus if
// you want a multisampled RT it is best to wrap the swapchain images and then let Skia handle
@@ -922,7 +934,8 @@
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
- desc.fOrigin = kBottomLeft_GrSurfaceOrigin; // Not actually used in the following
+ SkASSERT(kDefault_GrSurfaceOrigin != origin);
+ desc.fOrigin = origin;
desc.fWidth = backendRT.width();
desc.fHeight = backendRT.height();
desc.fConfig = backendRT.config();
@@ -938,6 +951,7 @@
}
sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
+ GrSurfaceOrigin origin,
int sampleCnt) {
const GrVkImageInfo* info = tex.getVkImageInfo();
@@ -950,7 +964,7 @@
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
- desc.fOrigin = kBottomLeft_GrSurfaceOrigin; // Not actually used in the following
+ desc.fOrigin = resolve_origin(origin);
desc.fWidth = tex.width();
desc.fHeight = tex.height();
desc.fConfig = tex.config();
@@ -960,7 +974,7 @@
return tgt;
}
-void GrVkGpu::generateMipmap(GrVkTexture* tex, GrSurfaceOrigin texOrigin) {
+void GrVkGpu::generateMipmap(GrVkTexture* tex) {
// don't do anything for linearly tiled textures (can't have mipmaps)
if (tex->isLinearTiled()) {
SkDebugf("Trying to create mipmap for linear tiled texture");
@@ -982,7 +996,7 @@
// 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, texOrigin, false);
+ this->internalResolveRenderTarget(texRT, false);
}
int width = tex->width();
@@ -1490,8 +1504,8 @@
fCurrentCmdBuffer->clearDepthStencilImage(this, vkStencil, &vkStencilColor, 1, &subRange);
}
-inline bool can_copy_image(const GrSurface* dst, GrSurfaceOrigin dstOrigin,
- const GrSurface* src, GrSurfaceOrigin srcOrigin,
+inline bool can_copy_image(const GrSurface* dst,
+ const GrSurface* src,
const GrVkGpu* gpu) {
const GrRenderTarget* dstRT = dst->asRenderTarget();
const GrRenderTarget* srcRT = src->asRenderTarget();
@@ -1511,7 +1525,7 @@
// We require that all vulkan GrSurfaces have been created with transfer_dst and transfer_src
// as image usage flags.
- if (srcOrigin == dstOrigin &&
+ if (src->origin() == dst->origin() &&
GrBytesPerPixel(src->config()) == GrBytesPerPixel(dst->config())) {
return true;
}
@@ -1519,13 +1533,13 @@
return false;
}
-void GrVkGpu::copySurfaceAsCopyImage(GrSurface* dst, GrSurfaceOrigin dstOrigin,
- GrSurface* src, GrSurfaceOrigin srcOrigin,
+void GrVkGpu::copySurfaceAsCopyImage(GrSurface* dst,
+ GrSurface* src,
GrVkImage* dstImage,
GrVkImage* srcImage,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
- SkASSERT(can_copy_image(dst, dstOrigin, src, srcOrigin, this));
+ SkASSERT(can_copy_image(dst, src, 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.
@@ -1545,8 +1559,8 @@
SkIRect srcVkRect = srcRect;
int32_t dstY = dstPoint.fY;
- if (kBottomLeft_GrSurfaceOrigin == srcOrigin) {
- SkASSERT(kBottomLeft_GrSurfaceOrigin == dstOrigin);
+ if (kBottomLeft_GrSurfaceOrigin == src->origin()) {
+ SkASSERT(kBottomLeft_GrSurfaceOrigin == dst->origin());
srcVkRect.fTop = src->height() - srcRect.fBottom;
srcVkRect.fBottom = src->height() - srcRect.fTop;
dstY = dst->height() - dstPoint.fY - srcVkRect.height();
@@ -1596,8 +1610,8 @@
return true;
}
-void GrVkGpu::copySurfaceAsBlit(GrSurface* dst, GrSurfaceOrigin dstOrigin,
- GrSurface* src, GrSurfaceOrigin srcOrigin,
+void GrVkGpu::copySurfaceAsBlit(GrSurface* dst,
+ GrSurface* src,
GrVkImage* dstImage,
GrVkImage* srcImage,
const SkIRect& srcRect,
@@ -1624,7 +1638,7 @@
dstRect.fLeft = dstPoint.fX;
dstRect.fRight = dstPoint.fX + srcRect.width();
- if (kBottomLeft_GrSurfaceOrigin == srcOrigin) {
+ if (kBottomLeft_GrSurfaceOrigin == src->origin()) {
srcVkRect.fTop = src->height() - srcRect.fBottom;
srcVkRect.fBottom = src->height() - srcRect.fTop;
} else {
@@ -1632,7 +1646,7 @@
srcVkRect.fBottom = srcRect.fBottom;
}
- if (kBottomLeft_GrSurfaceOrigin == dstOrigin) {
+ if (kBottomLeft_GrSurfaceOrigin == dst->origin()) {
dstRect.fTop = dst->height() - dstPoint.fY - srcVkRect.height();
} else {
dstRect.fTop = dstPoint.fY;
@@ -1641,7 +1655,7 @@
// 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 (srcOrigin != dstOrigin) {
+ if (src->origin() != dst->origin()) {
SkTSwap(dstRect.fTop, dstRect.fBottom);
}
@@ -1664,8 +1678,8 @@
this->didWriteToSurface(dst, &dstRect);
}
-inline bool can_copy_as_resolve(const GrSurface* dst, GrSurfaceOrigin dstOrigin,
- const GrSurface* src, GrSurfaceOrigin srcOrigin,
+inline bool can_copy_as_resolve(const GrSurface* dst,
+ const GrSurface* src,
const GrVkGpu* gpu) {
// Our src must be a multisampled render target
if (!src->asRenderTarget() || src->asRenderTarget()->numColorSamples() <= 1) {
@@ -1680,27 +1694,27 @@
}
// Surfaces must have the same origin.
- if (srcOrigin != dstOrigin) {
+ if (src->origin() != dst->origin()) {
return false;
}
return true;
}
-void GrVkGpu::copySurfaceAsResolve(GrSurface* dst, GrSurfaceOrigin dstOrigin,
- GrSurface* src, GrSurfaceOrigin srcOrigin,
+void GrVkGpu::copySurfaceAsResolve(GrSurface* dst,
+ GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
GrVkRenderTarget* srcRT = static_cast<GrVkRenderTarget*>(src->asRenderTarget());
- this->resolveImage(dst, dstOrigin, srcRT, srcOrigin, srcRect, dstPoint);
+ this->resolveImage(dst, srcRT, srcRect, dstPoint);
}
-bool GrVkGpu::onCopySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
- GrSurface* src, GrSurfaceOrigin srcOrigin,
+bool GrVkGpu::onCopySurface(GrSurface* dst,
+ GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
- if (can_copy_as_resolve(dst, dstOrigin, src, srcOrigin, this)) {
- this->copySurfaceAsResolve(dst, dstOrigin, src, srcOrigin, srcRect, dstPoint);
+ if (can_copy_as_resolve(dst, src, this)) {
+ this->copySurfaceAsResolve(dst, src, srcRect, dstPoint);
return true;
}
@@ -1708,7 +1722,7 @@
this->submitCommandBuffer(GrVkGpu::kSkip_SyncQueue);
}
- if (fCopyManager.copySurfaceAsDraw(this, dst, dstOrigin, src, srcOrigin, srcRect, dstPoint)) {
+ if (fCopyManager.copySurfaceAsDraw(this, dst, src, srcRect, dstPoint)) {
return true;
}
@@ -1736,30 +1750,27 @@
return false;
}
- if (can_copy_image(dst, dstOrigin, src, srcOrigin, this)) {
- this->copySurfaceAsCopyImage(dst, dstOrigin, src, srcOrigin, dstImage, srcImage,
- srcRect, dstPoint);
+ if (can_copy_image(dst, src, this)) {
+ this->copySurfaceAsCopyImage(dst, src, dstImage, srcImage, srcRect, dstPoint);
return true;
}
if (can_copy_as_blit(dst, src, dstImage, srcImage, this)) {
- this->copySurfaceAsBlit(dst, dstOrigin, src, srcOrigin, dstImage, srcImage,
- srcRect, dstPoint);
+ this->copySurfaceAsBlit(dst, src, dstImage, srcImage, srcRect, dstPoint);
return true;
}
return false;
}
-void GrVkGpu::onQueryMultisampleSpecs(GrRenderTarget* rt, GrSurfaceOrigin, const GrStencilSettings&,
+void GrVkGpu::onQueryMultisampleSpecs(GrRenderTarget* rt, const GrStencilSettings&,
int* effectiveSampleCnt, SamplePattern*) {
// TODO: stub.
SkASSERT(!this->caps()->sampleLocationsSupport());
*effectiveSampleCnt = rt->numStencilSamples();
}
-bool GrVkGpu::onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin,
- int width, int height, size_t rowBytes,
+bool GrVkGpu::onGetReadPixelsInfo(GrSurface* srcSurface, 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.
@@ -1792,7 +1803,7 @@
return true;
}
-bool GrVkGpu::onReadPixels(GrSurface* surface, GrSurfaceOrigin origin,
+bool GrVkGpu::onReadPixels(GrSurface* surface,
int left, int top, int width, int height,
GrPixelConfig config,
void* buffer,
@@ -1812,7 +1823,7 @@
case GrVkRenderTarget::kAutoResolves_ResolveType:
break;
case GrVkRenderTarget::kCanResolve_ResolveType:
- this->internalResolveRenderTarget(rt, origin, false);
+ this->internalResolveRenderTarget(rt, false);
break;
default:
SkFAIL("Unknown resolve type");
@@ -1835,7 +1846,7 @@
size_t bpp = GrBytesPerPixel(config);
size_t tightRowBytes = bpp * width;
- bool flipY = kBottomLeft_GrSurfaceOrigin == origin;
+ bool flipY = kBottomLeft_GrSurfaceOrigin == surface->origin();
VkBufferImageCopy region;
memset(®ion, 0, sizeof(VkBufferImageCopy));
@@ -1959,11 +1970,11 @@
void GrVkGpu::submitSecondaryCommandBuffer(const SkTArray<GrVkSecondaryCommandBuffer*>& buffers,
const GrVkRenderPass* renderPass,
const VkClearValue* colorClear,
- GrVkRenderTarget* target, GrSurfaceOrigin origin,
+ GrVkRenderTarget* target,
const SkIRect& bounds) {
const SkIRect* pBounds = &bounds;
SkIRect flippedBounds;
- if (kBottomLeft_GrSurfaceOrigin == origin) {
+ if (kBottomLeft_GrSurfaceOrigin == target->origin()) {
flippedBounds = bounds;
flippedBounds.fTop = target->height() - bounds.fBottom;
flippedBounds.fBottom = target->height() - bounds.fTop;
diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h
index cde9a18..7e95ca4 100644
--- a/src/gpu/vk/GrVkGpu.h
+++ b/src/gpu/vk/GrVkGpu.h
@@ -66,21 +66,20 @@
kSkip_SyncQueue
};
- bool onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin,
- int readWidth, int readHeight, size_t rowBytes,
+ bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
GrPixelConfig readConfig, DrawPreference*,
ReadPixelTempDrawInfo*) override;
- bool onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin,
- int width, int height,
+ bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
GrPixelConfig srcConfig, DrawPreference*,
WritePixelTempDrawInfo*) override;
- bool onCopySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
- GrSurface* src, GrSurfaceOrigin srcOrigin,
- const SkIRect& srcRect, const SkIPoint& dstPoint) override;
+ bool onCopySurface(GrSurface* dst,
+ GrSurface* src,
+ const SkIRect& srcRect,
+ const SkIPoint& dstPoint) override;
- void onQueryMultisampleSpecs(GrRenderTarget*, GrSurfaceOrigin, const GrStencilSettings&,
+ void onQueryMultisampleSpecs(GrRenderTarget* rt, const GrStencilSettings&,
int* effectiveSampleCnt, SamplePattern*) override;
void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {}
@@ -118,14 +117,14 @@
return fCompiler;
}
- void onResolveRenderTarget(GrRenderTarget* target, GrSurfaceOrigin origin) override {
- this->internalResolveRenderTarget(target, origin, true);
+ void onResolveRenderTarget(GrRenderTarget* target) override {
+ this->internalResolveRenderTarget(target, true);
}
void submitSecondaryCommandBuffer(const SkTArray<GrVkSecondaryCommandBuffer*>&,
const GrVkRenderPass*,
const VkClearValue*,
- GrVkRenderTarget*, GrSurfaceOrigin,
+ GrVkRenderTarget*,
const SkIRect& bounds);
void finishFlush() override;
@@ -142,7 +141,7 @@
sk_sp<GrSemaphore> prepareTextureForCrossContextUsage(GrTexture*) override;
- void generateMipmap(GrVkTexture* tex, GrSurfaceOrigin texOrigin);
+ void generateMipmap(GrVkTexture* tex);
bool updateBuffer(GrVkBuffer* buffer, const void* src, VkDeviceSize offset, VkDeviceSize size);
@@ -179,13 +178,18 @@
sk_sp<GrTexture> onCreateTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
const GrMipLevel texels[], int mipLevelCount) override;
- sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrWrapOwnership) override;
+ sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
+ GrSurfaceOrigin,
+ GrWrapOwnership) override;
sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
+ GrSurfaceOrigin,
int sampleCnt,
GrWrapOwnership) override;
- sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
+ sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
+ GrSurfaceOrigin) override;
sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
+ GrSurfaceOrigin,
int sampleCnt) override;
GrBuffer* onCreateBuffer(size_t size, GrBufferType type, GrAccessPattern,
@@ -193,13 +197,13 @@
gr_instanced::InstancedRendering* onCreateInstancedRendering() override { return nullptr; }
- bool onReadPixels(GrSurface* surface, GrSurfaceOrigin,
+ bool onReadPixels(GrSurface* surface,
int left, int top, int width, int height,
GrPixelConfig,
void* buffer,
size_t rowBytes) override;
- bool onWritePixels(GrSurface* surface, GrSurfaceOrigin,
+ bool onWritePixels(GrSurface* surface,
int left, int top, int width, int height,
GrPixelConfig config, const GrMipLevel texels[], int mipLevelCount) override;
@@ -216,39 +220,42 @@
// wait semaphores to the submission of this command buffer.
void submitCommandBuffer(SyncQueue sync);
- void internalResolveRenderTarget(GrRenderTarget*, GrSurfaceOrigin origin, bool requiresSubmit);
+ void internalResolveRenderTarget(GrRenderTarget* target, bool requiresSubmit);
- void copySurfaceAsCopyImage(GrSurface* dst, GrSurfaceOrigin dstOrigin,
- GrSurface* src, GrSurfaceOrigin srcOrigin,
- GrVkImage* dstImage, GrVkImage* srcImage,
+ void copySurfaceAsCopyImage(GrSurface* dst,
+ GrSurface* src,
+ GrVkImage* dstImage,
+ GrVkImage* srcImage,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
- void copySurfaceAsBlit(GrSurface* dst, GrSurfaceOrigin dstOrigin,
- GrSurface* src, GrSurfaceOrigin srcOrigin,
- GrVkImage* dstImage, GrVkImage* srcImage,
+ void copySurfaceAsBlit(GrSurface* dst,
+ GrSurface* src,
+ GrVkImage* dstImage,
+ GrVkImage* srcImage,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
- void copySurfaceAsResolve(GrSurface* dst, GrSurfaceOrigin dstOrigin,
- GrSurface* src, GrSurfaceOrigin srcOrigin,
+ void copySurfaceAsResolve(GrSurface* dst,
+ GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
// helpers for onCreateTexture and writeTexturePixels
- bool uploadTexDataLinear(GrVkTexture* tex, GrSurfaceOrigin texOrigin,
+ bool uploadTexDataLinear(GrVkTexture* tex,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
const void* data,
size_t rowBytes);
- bool uploadTexDataOptimal(GrVkTexture* tex, GrSurfaceOrigin texOrigin,
+ bool uploadTexDataOptimal(GrVkTexture* tex,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
const GrMipLevel texels[], int mipLevelCount);
- void resolveImage(GrSurface* dst, GrSurfaceOrigin dstOrigin,
- GrVkRenderTarget* src, GrSurfaceOrigin srcOrigin,
- const SkIRect& srcRect, const SkIPoint& dstPoint);
+ void resolveImage(GrSurface* dst,
+ GrVkRenderTarget* src,
+ const SkIRect& srcRect,
+ const SkIPoint& dstPoint);
sk_sp<const GrVkBackendContext> fBackendContext;
sk_sp<GrVkCaps> fVkCaps;
diff --git a/src/gpu/vk/GrVkGpuCommandBuffer.cpp b/src/gpu/vk/GrVkGpuCommandBuffer.cpp
index 50780b0..4c1ad8e 100644
--- a/src/gpu/vk/GrVkGpuCommandBuffer.cpp
+++ b/src/gpu/vk/GrVkGpuCommandBuffer.cpp
@@ -178,8 +178,7 @@
cbInfo.fBounds.roundOut(&iBounds);
fGpu->submitSecondaryCommandBuffer(cbInfo.fCommandBuffers, cbInfo.fRenderPass,
- &cbInfo.fColorClearValue, fRenderTarget, fOrigin,
- iBounds);
+ &cbInfo.fColorClearValue, fRenderTarget, iBounds);
}
}
}
@@ -500,12 +499,10 @@
GrRenderTarget* rt = pipeline.renderTarget();
if (!pipeline.getScissorState().enabled()) {
- GrVkPipeline::SetDynamicScissorRectState(fGpu, cbInfo.currentCmdBuf(),
- rt, pipeline.proxy()->origin(),
+ GrVkPipeline::SetDynamicScissorRectState(fGpu, cbInfo.currentCmdBuf(), rt,
SkIRect::MakeWH(rt->width(), rt->height()));
} else if (!hasDynamicState) {
- GrVkPipeline::SetDynamicScissorRectState(fGpu, cbInfo.currentCmdBuf(),
- rt, pipeline.proxy()->origin(),
+ GrVkPipeline::SetDynamicScissorRectState(fGpu, cbInfo.currentCmdBuf(), rt,
pipeline.getScissorState().rect());
}
GrVkPipeline::SetDynamicViewportState(fGpu, cbInfo.currentCmdBuf(), rt);
@@ -534,14 +531,14 @@
// 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, sampler.proxy()->origin());
+ gpu->onResolveRenderTarget(texRT);
}
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, sampler.proxy()->origin());
+ gpu->generateMipmap(vkTexture);
vkTexture->texturePriv().dirtyMipMaps(false);
}
}
@@ -605,8 +602,7 @@
if (dynamicStates) {
if (pipeline.getScissorState().enabled()) {
GrVkPipeline::SetDynamicScissorRectState(fGpu, cbInfo.currentCmdBuf(),
- target, pipeline.proxy()->origin(),
- dynamicStates[i].fScissorRect);
+ target, dynamicStates[i].fScissorRect);
}
}
diff --git a/src/gpu/vk/GrVkPipeline.cpp b/src/gpu/vk/GrVkPipeline.cpp
index 67005be..e356133 100644
--- a/src/gpu/vk/GrVkPipeline.cpp
+++ b/src/gpu/vk/GrVkPipeline.cpp
@@ -495,7 +495,6 @@
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();
@@ -504,10 +503,10 @@
VkRect2D scissor;
scissor.offset.x = scissorRect.fLeft;
scissor.extent.width = scissorRect.width();
- if (kTopLeft_GrSurfaceOrigin == rtOrigin) {
+ if (kTopLeft_GrSurfaceOrigin == renderTarget->origin()) {
scissor.offset.y = scissorRect.fTop;
} else {
- SkASSERT(kBottomLeft_GrSurfaceOrigin == rtOrigin);
+ SkASSERT(kBottomLeft_GrSurfaceOrigin == renderTarget->origin());
scissor.offset.y = renderTarget->height() - scissorRect.fBottom;
}
scissor.extent.height = scissorRect.height();
diff --git a/src/gpu/vk/GrVkPipeline.h b/src/gpu/vk/GrVkPipeline.h
index 88c3d5f..d05974b 100644
--- a/src/gpu/vk/GrVkPipeline.h
+++ b/src/gpu/vk/GrVkPipeline.h
@@ -40,7 +40,7 @@
VkPipeline pipeline() const { return fPipeline; }
static void SetDynamicScissorRectState(GrVkGpu*, GrVkCommandBuffer*, const GrRenderTarget*,
- GrSurfaceOrigin, SkIRect);
+ SkIRect);
static void SetDynamicViewportState(GrVkGpu*, GrVkCommandBuffer*, const GrRenderTarget*);
static void SetDynamicBlendConstantState(GrVkGpu*, GrVkCommandBuffer*, GrPixelConfig,
const GrXferProcessor&);