Reland "Store GrSwizzle on proxies for texturing and swizzling."
This reverts commit 3ec1f54750a745482e06b2144a1cfd2e733e4200.
Reason for revert: Relanding with GrSwizzle now back in src
Original change's description:
> Revert "Store GrSwizzle on proxies for texturing and swizzling."
>
> This reverts commit 23093135d17427ef59385761d2d729ada6d961cf.
>
> Reason for revert: Breaking Google3 :(
>
> Original change's description:
> > Store GrSwizzle on proxies for texturing and swizzling.
> >
> > Bug: skia: 6718
> > Change-Id: I023d7507da9334e984ac8209a32323d616b3d79d
> > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/214305
> > Reviewed-by: Brian Salomon <bsalomon@google.com>
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com
>
> Change-Id: Ie2303ad090f58de07db7b0ac2d42e06e5e5bbcc1
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Bug: skia: 6718
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/221338
> Reviewed-by: Brian Salomon <bsalomon@google.com>
> Commit-Queue: Brian Salomon <bsalomon@google.com>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com
Change-Id: I42ad83892382b123b8dc4dc5e2cf375ad3c5eaeb
Bug: skia: 6718
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/221349
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
diff --git a/src/gpu/GrProxyProvider.cpp b/src/gpu/GrProxyProvider.cpp
index 1331fe4..ee8ab36 100644
--- a/src/gpu/GrProxyProvider.cpp
+++ b/src/gpu/GrProxyProvider.cpp
@@ -154,11 +154,15 @@
SkASSERT(!this->findProxyByUniqueKey(tex->getUniqueKey(), origin));
}
#endif
+ GrColorType colorType = GrPixelConfigToColorType(tex->config());
+ GrSwizzle texSwizzle = this->caps()->getTextureSwizzle(tex->backendFormat(), colorType);
if (tex->asRenderTarget()) {
- return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(std::move(tex), origin));
+ GrSwizzle outSwizzle = this->caps()->getOutputSwizzle(tex->backendFormat(), colorType);
+ return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(std::move(tex), origin,
+ texSwizzle, outSwizzle));
} else {
- return sk_sp<GrTextureProxy>(new GrTextureProxy(std::move(tex), origin));
+ return sk_sp<GrTextureProxy>(new GrTextureProxy(std::move(tex), origin, texSwizzle));
}
}
@@ -448,15 +452,20 @@
this->caps()->getRenderTargetSampleCount(desc.fSampleCnt, desc.fConfig);
}
+ GrColorType colorType = GrPixelConfigToColorType(desc.fConfig);
+ GrSwizzle texSwizzle = this->caps()->getTextureSwizzle(format, colorType);
+
if (copyDesc.fFlags & kRenderTarget_GrSurfaceFlag) {
// We know anything we instantiate later from this deferred path will be
// both texturable and renderable
+ GrSwizzle outSwizzle = this->caps()->getOutputSwizzle(format, colorType);
return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(*this->caps(), format, copyDesc,
- origin, mipMapped,
- fit, budgeted, surfaceFlags));
+ origin, mipMapped, texSwizzle,
+ outSwizzle, fit, budgeted,
+ surfaceFlags));
}
- return sk_sp<GrTextureProxy>(new GrTextureProxy(format, copyDesc, origin, mipMapped,
+ return sk_sp<GrTextureProxy>(new GrTextureProxy(format, copyDesc, origin, mipMapped, texSwizzle,
fit, budgeted, surfaceFlags));
}
@@ -535,7 +544,10 @@
// Make sure we match how we created the proxy with SkBudgeted::kNo
SkASSERT(GrBudgetedType::kBudgeted != tex->resourcePriv().budgetedType());
- return sk_sp<GrTextureProxy>(new GrTextureProxy(std::move(tex), origin));
+ GrColorType colorType = GrPixelConfigToColorType(tex->config());
+ GrSwizzle texSwizzle = this->caps()->getTextureSwizzle(tex->backendFormat(), colorType);
+
+ return sk_sp<GrTextureProxy>(new GrTextureProxy(std::move(tex), origin, texSwizzle));
}
sk_sp<GrTextureProxy> GrProxyProvider::wrapRenderableBackendTexture(
@@ -576,7 +588,12 @@
// Make sure we match how we created the proxy with SkBudgeted::kNo
SkASSERT(GrBudgetedType::kBudgeted != tex->resourcePriv().budgetedType());
- return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(std::move(tex), origin));
+ GrColorType colorType = GrPixelConfigToColorType(tex->config());
+ GrSwizzle texSwizzle = this->caps()->getTextureSwizzle(tex->backendFormat(), colorType);
+ GrSwizzle outSwizzle = this->caps()->getOutputSwizzle(tex->backendFormat(), colorType);
+
+ return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(std::move(tex), origin, texSwizzle,
+ outSwizzle));
}
sk_sp<GrSurfaceProxy> GrProxyProvider::wrapBackendRenderTarget(
@@ -592,8 +609,8 @@
return nullptr;
}
-#ifdef SK_DEBUG
GrColorType colorType = GrPixelConfigToColorType(backendRT.config());
+#ifdef SK_DEBUG
GrPixelConfig testConfig =
this->caps()->validateBackendRenderTarget(backendRT,
GrColorTypeToSkColorType(colorType));
@@ -616,7 +633,11 @@
// Make sure we match how we created the proxy with SkBudgeted::kNo
SkASSERT(GrBudgetedType::kBudgeted != rt->resourcePriv().budgetedType());
- return sk_sp<GrRenderTargetProxy>(new GrRenderTargetProxy(std::move(rt), origin));
+ GrSwizzle texSwizzle = this->caps()->getTextureSwizzle(rt->backendFormat(), colorType);
+ GrSwizzle outSwizzle = this->caps()->getOutputSwizzle(rt->backendFormat(), colorType);
+
+ return sk_sp<GrRenderTargetProxy>(new GrRenderTargetProxy(std::move(rt), origin, texSwizzle,
+ outSwizzle));
}
sk_sp<GrSurfaceProxy> GrProxyProvider::wrapBackendTextureAsRenderTarget(
@@ -646,7 +667,12 @@
// This proxy should be unbudgeted because we're just wrapping an external resource
SkASSERT(GrBudgetedType::kBudgeted != rt->resourcePriv().budgetedType());
- return sk_sp<GrSurfaceProxy>(new GrRenderTargetProxy(std::move(rt), origin));
+ GrColorType colorType = GrPixelConfigToColorType(rt->config());
+ GrSwizzle texSwizzle = this->caps()->getTextureSwizzle(rt->backendFormat(), colorType);
+ GrSwizzle outSwizzle = this->caps()->getOutputSwizzle(rt->backendFormat(), colorType);
+
+ return sk_sp<GrSurfaceProxy>(new GrRenderTargetProxy(std::move(rt), origin, texSwizzle,
+ outSwizzle));
}
sk_sp<GrRenderTargetProxy> GrProxyProvider::wrapVulkanSecondaryCBAsRenderTarget(
@@ -674,10 +700,14 @@
// This proxy should be unbudgeted because we're just wrapping an external resource
SkASSERT(GrBudgetedType::kBudgeted != rt->resourcePriv().budgetedType());
+ GrColorType colorType = GrPixelConfigToColorType(rt->config());
+ GrSwizzle texSwizzle = this->caps()->getTextureSwizzle(rt->backendFormat(), colorType);
+ GrSwizzle outSwizzle = this->caps()->getOutputSwizzle(rt->backendFormat(), colorType);
+
// All Vulkan surfaces uses top left origins.
return sk_sp<GrRenderTargetProxy>(
new GrRenderTargetProxy(std::move(rt),
- kTopLeft_GrSurfaceOrigin,
+ kTopLeft_GrSurfaceOrigin, texSwizzle, outSwizzle,
GrRenderTargetProxy::WrapsVkSecondaryCB::kYes));
}
@@ -734,12 +764,17 @@
}
#endif
+ GrColorType colorType = GrPixelConfigToColorType(desc.fConfig);
+ GrSwizzle texSwizzle = this->caps()->getTextureSwizzle(format, colorType);
+ GrSwizzle outSwizzle = this->caps()->getOutputSwizzle(format, colorType);
+
return sk_sp<GrTextureProxy>(
SkToBool(kRenderTarget_GrSurfaceFlag & desc.fFlags)
? new GrTextureRenderTargetProxy(std::move(callback), lazyType, format, desc,
- origin, mipMapped, fit, budgeted, surfaceFlags)
+ origin, mipMapped, texSwizzle, outSwizzle, fit,
+ budgeted, surfaceFlags)
: new GrTextureProxy(std::move(callback), lazyType, format, desc, origin,
- mipMapped, fit, budgeted, surfaceFlags));
+ mipMapped, texSwizzle, fit, budgeted, surfaceFlags));
}
sk_sp<GrRenderTargetProxy> GrProxyProvider::createLazyRenderTargetProxy(
@@ -769,13 +804,17 @@
LazyInstantiationType lazyType = this->renderingDirectly() ? LazyInstantiationType::kSingleUse
: LazyInstantiationType::kMultipleUse;
+ GrColorType colorType = GrPixelConfigToColorType(desc.fConfig);
+ GrSwizzle texSwizzle = this->caps()->getTextureSwizzle(format, colorType);
+ GrSwizzle outSwizzle = this->caps()->getOutputSwizzle(format, colorType);
+
if (textureInfo) {
// Wrapped vulkan secondary command buffers don't support texturing since we won't have an
// actual VkImage to texture from.
SkASSERT(!wrapsVkSecondaryCB);
return sk_sp<GrRenderTargetProxy>(new GrTextureRenderTargetProxy(
std::move(callback), lazyType, format, desc, origin, textureInfo->fMipMapped,
- fit, budgeted, surfaceFlags));
+ texSwizzle, outSwizzle, fit, budgeted, surfaceFlags));
}
GrRenderTargetProxy::WrapsVkSecondaryCB vkSCB =
@@ -783,8 +822,8 @@
: GrRenderTargetProxy::WrapsVkSecondaryCB::kNo;
return sk_sp<GrRenderTargetProxy>(new GrRenderTargetProxy(
- std::move(callback), lazyType, format, desc, origin, fit, budgeted, surfaceFlags,
- vkSCB));
+ std::move(callback), lazyType, format, desc, origin, texSwizzle, outSwizzle, fit,
+ budgeted, surfaceFlags, vkSCB));
}
sk_sp<GrTextureProxy> GrProxyProvider::MakeFullyLazyProxy(
@@ -804,14 +843,18 @@
desc.fConfig = config;
desc.fSampleCnt = sampleCnt;
+ GrColorType colorType = GrPixelConfigToColorType(desc.fConfig);
+ GrSwizzle texSwizzle = caps.getTextureSwizzle(format, colorType);
+ GrSwizzle outSwizzle = caps.getOutputSwizzle(format, colorType);
+
return sk_sp<GrTextureProxy>(
(Renderable::kYes == renderable)
? new GrTextureRenderTargetProxy(
std::move(callback), LazyInstantiationType::kSingleUse, format, desc,
- origin, GrMipMapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes,
- surfaceFlags)
+ origin, GrMipMapped::kNo, texSwizzle, outSwizzle,
+ SkBackingFit::kApprox, SkBudgeted::kYes, surfaceFlags)
: new GrTextureProxy(std::move(callback), LazyInstantiationType::kSingleUse,
- format, desc, origin, GrMipMapped::kNo,
+ format, desc, origin, GrMipMapped::kNo, texSwizzle,
SkBackingFit::kApprox, SkBudgeted::kYes, surfaceFlags));
}
diff --git a/src/gpu/GrRenderTargetProxy.cpp b/src/gpu/GrRenderTargetProxy.cpp
index 6dad311..50e0c5c 100644
--- a/src/gpu/GrRenderTargetProxy.cpp
+++ b/src/gpu/GrRenderTargetProxy.cpp
@@ -21,10 +21,12 @@
// cases to make the sampleConfig/numSamples stuff more rational.
GrRenderTargetProxy::GrRenderTargetProxy(const GrCaps& caps, const GrBackendFormat& format,
const GrSurfaceDesc& desc, GrSurfaceOrigin origin,
- SkBackingFit fit, SkBudgeted budgeted,
- GrInternalSurfaceFlags surfaceFlags)
- : INHERITED(format, desc, origin, fit, budgeted, surfaceFlags)
+ const GrSwizzle& textureSwizzle,
+ const GrSwizzle& outputSwizzle, SkBackingFit fit,
+ SkBudgeted budgeted, GrInternalSurfaceFlags surfaceFlags)
+ : INHERITED(format, desc, origin, textureSwizzle, fit, budgeted, surfaceFlags)
, fSampleCnt(desc.fSampleCnt)
+ , fOutputSwizzle(outputSwizzle)
, fNeedsStencil(false)
, fWrapsVkSecondaryCB(WrapsVkSecondaryCB::kNo) {
// Since we know the newly created render target will be internal, we are able to precompute
@@ -38,12 +40,14 @@
GrRenderTargetProxy::GrRenderTargetProxy(LazyInstantiateCallback&& callback,
LazyInstantiationType lazyType,
const GrBackendFormat& format, const GrSurfaceDesc& desc,
- GrSurfaceOrigin origin, SkBackingFit fit,
+ GrSurfaceOrigin origin, const GrSwizzle& textureSwizzle,
+ const GrSwizzle& outputSwizzle, SkBackingFit fit,
SkBudgeted budgeted, GrInternalSurfaceFlags surfaceFlags,
WrapsVkSecondaryCB wrapsVkSecondaryCB)
- : INHERITED(std::move(callback), lazyType, format, desc, origin, fit, budgeted,
- surfaceFlags)
+ : INHERITED(std::move(callback), lazyType, format, desc, origin, textureSwizzle, fit,
+ budgeted, surfaceFlags)
, fSampleCnt(desc.fSampleCnt)
+ , fOutputSwizzle(outputSwizzle)
, fNeedsStencil(false)
, fWrapsVkSecondaryCB(wrapsVkSecondaryCB) {
SkASSERT(SkToBool(kRenderTarget_GrSurfaceFlag & desc.fFlags));
@@ -51,9 +55,12 @@
// Wrapped version
GrRenderTargetProxy::GrRenderTargetProxy(sk_sp<GrSurface> surf, GrSurfaceOrigin origin,
+ const GrSwizzle& textureSwizzle,
+ const GrSwizzle& outputSwizzle,
WrapsVkSecondaryCB wrapsVkSecondaryCB)
- : INHERITED(std::move(surf), origin, SkBackingFit::kExact)
+ : INHERITED(std::move(surf), origin, textureSwizzle, SkBackingFit::kExact)
, fSampleCnt(fTarget->asRenderTarget()->numStencilSamples())
+ , fOutputSwizzle(outputSwizzle)
, fNeedsStencil(false)
, fWrapsVkSecondaryCB(wrapsVkSecondaryCB) {
}
diff --git a/src/gpu/GrRenderTargetProxy.h b/src/gpu/GrRenderTargetProxy.h
index 1a2b2fc..84d003a 100644
--- a/src/gpu/GrRenderTargetProxy.h
+++ b/src/gpu/GrRenderTargetProxy.h
@@ -10,6 +10,7 @@
#include "include/private/GrTypesPriv.h"
#include "src/gpu/GrSurfaceProxy.h"
+#include "src/gpu/GrSwizzle.h"
class GrResourceProvider;
class GrRenderTargetProxyPriv;
@@ -54,6 +55,8 @@
int maxWindowRectangles(const GrCaps& caps) const;
+ const GrSwizzle& outputSwizzle() const { return fOutputSwizzle; }
+
bool wrapsVkSecondaryCB() const { return fWrapsVkSecondaryCB == WrapsVkSecondaryCB::kYes; }
// TODO: move this to a priv class!
@@ -69,7 +72,9 @@
// Deferred version
GrRenderTargetProxy(const GrCaps&, const GrBackendFormat&, const GrSurfaceDesc&,
- GrSurfaceOrigin, SkBackingFit, SkBudgeted, GrInternalSurfaceFlags);
+ GrSurfaceOrigin, const GrSwizzle& textureSwizzle,
+ const GrSwizzle& outputSwizzle, SkBackingFit, SkBudgeted,
+ GrInternalSurfaceFlags);
enum class WrapsVkSecondaryCB : bool { kNo = false, kYes = true };
@@ -85,11 +90,13 @@
// know the final size until flush time.
GrRenderTargetProxy(LazyInstantiateCallback&&, LazyInstantiationType lazyType,
const GrBackendFormat&, const GrSurfaceDesc&, GrSurfaceOrigin,
+ const GrSwizzle& textureSwizzle, const GrSwizzle& outputSwizzle,
SkBackingFit, SkBudgeted, GrInternalSurfaceFlags,
WrapsVkSecondaryCB wrapsVkSecondaryCB);
// Wrapped version
- GrRenderTargetProxy(sk_sp<GrSurface>, GrSurfaceOrigin,
+ GrRenderTargetProxy(sk_sp<GrSurface>, GrSurfaceOrigin, const GrSwizzle& textureSwizzle,
+ const GrSwizzle& outputSwizzle,
WrapsVkSecondaryCB wrapsVkSecondaryCB = WrapsVkSecondaryCB::kNo);
sk_sp<GrSurface> createSurface(GrResourceProvider*) const override;
@@ -120,8 +127,15 @@
// address of other types, leading to this problem.
int fSampleCnt;
+ GrSwizzle fOutputSwizzle;
bool fNeedsStencil;
WrapsVkSecondaryCB fWrapsVkSecondaryCB;
+ // This is to fix issue in large comment above. Without the padding we end 6 bytes into a 16
+ // byte range, so the GrTextureProxy ends up starting 8 byte aligned by not 16. We add the
+ // padding here to get us right up to the 16 byte alignment (technically any padding of 3-10
+ // bytes would work since it always goes up to 8 byte alignment, but we use 10 to more explicit
+ // about what we're doing).
+ char fDummyPadding[10];
// For wrapped render targets the actual GrRenderTarget is stored in the GrIORefProxy class.
// For deferred proxies that pointer is filled in when we need to instantiate the
diff --git a/src/gpu/GrSurfaceProxy.cpp b/src/gpu/GrSurfaceProxy.cpp
index d3cf8ff..04b629e 100644
--- a/src/gpu/GrSurfaceProxy.cpp
+++ b/src/gpu/GrSurfaceProxy.cpp
@@ -54,14 +54,16 @@
// Lazy-callback version
GrSurfaceProxy::GrSurfaceProxy(LazyInstantiateCallback&& callback, LazyInstantiationType lazyType,
const GrBackendFormat& format, const GrSurfaceDesc& desc,
- GrSurfaceOrigin origin, SkBackingFit fit,
- SkBudgeted budgeted, GrInternalSurfaceFlags surfaceFlags)
+ GrSurfaceOrigin origin, const GrSwizzle& textureSwizzle,
+ SkBackingFit fit, SkBudgeted budgeted,
+ GrInternalSurfaceFlags surfaceFlags)
: fSurfaceFlags(surfaceFlags)
, fFormat(format)
, fConfig(desc.fConfig)
, fWidth(desc.fWidth)
, fHeight(desc.fHeight)
, fOrigin(origin)
+ , fTextureSwizzle(textureSwizzle)
, fFit(fit)
, fBudgeted(budgeted)
, fLazyInstantiateCallback(std::move(callback))
@@ -84,7 +86,8 @@
}
// Wrapped version
-GrSurfaceProxy::GrSurfaceProxy(sk_sp<GrSurface> surface, GrSurfaceOrigin origin, SkBackingFit fit)
+GrSurfaceProxy::GrSurfaceProxy(sk_sp<GrSurface> surface, GrSurfaceOrigin origin,
+ const GrSwizzle& textureSwizzle, SkBackingFit fit)
: INHERITED(std::move(surface))
, fSurfaceFlags(fTarget->surfacePriv().flags())
, fFormat(fTarget->backendFormat())
@@ -92,6 +95,7 @@
, fWidth(fTarget->width())
, fHeight(fTarget->height())
, fOrigin(origin)
+ , fTextureSwizzle(textureSwizzle)
, fFit(fit)
, fBudgeted(fTarget->resourcePriv().budgetedType() == GrBudgetedType::kBudgeted
? SkBudgeted::kYes
diff --git a/src/gpu/GrSurfaceProxy.h b/src/gpu/GrSurfaceProxy.h
index 7b938b1..30de3bb 100644
--- a/src/gpu/GrSurfaceProxy.h
+++ b/src/gpu/GrSurfaceProxy.h
@@ -14,6 +14,7 @@
#include "include/gpu/GrSurface.h"
#include "include/gpu/GrTexture.h"
#include "include/private/SkNoncopyable.h"
+#include "src/gpu/GrSwizzle.h"
class GrCaps;
class GrContext_Base;
@@ -249,6 +250,8 @@
return fOrigin;
}
+ const GrSwizzle& textureSwizzle() const { return fTextureSwizzle; }
+
const GrBackendFormat& backendFormat() const { return fFormat; }
class UniqueID {
@@ -414,20 +417,22 @@
protected:
// Deferred version
GrSurfaceProxy(const GrBackendFormat& format, const GrSurfaceDesc& desc,
- GrSurfaceOrigin origin, SkBackingFit fit,
+ GrSurfaceOrigin origin, const GrSwizzle& textureSwizzle, SkBackingFit fit,
SkBudgeted budgeted, GrInternalSurfaceFlags surfaceFlags)
- : GrSurfaceProxy(nullptr, LazyInstantiationType::kSingleUse, format, desc, origin, fit,
- budgeted, surfaceFlags) {
+ : GrSurfaceProxy(nullptr, LazyInstantiationType::kSingleUse, format, desc, origin,
+ textureSwizzle, fit, budgeted, surfaceFlags) {
// Note: this ctor pulls a new uniqueID from the same pool at the GrGpuResources
}
// Lazy-callback version
GrSurfaceProxy(LazyInstantiateCallback&&, LazyInstantiationType,
const GrBackendFormat& format, const GrSurfaceDesc&, GrSurfaceOrigin,
- SkBackingFit, SkBudgeted, GrInternalSurfaceFlags);
+ const GrSwizzle& textureSwizzle, SkBackingFit, SkBudgeted,
+ GrInternalSurfaceFlags);
// Wrapped version.
- GrSurfaceProxy(sk_sp<GrSurface>, GrSurfaceOrigin, SkBackingFit);
+ GrSurfaceProxy(sk_sp<GrSurface>, GrSurfaceOrigin, const GrSwizzle& textureSwizzle,
+ SkBackingFit);
virtual ~GrSurfaceProxy();
@@ -478,6 +483,8 @@
int fWidth;
int fHeight;
GrSurfaceOrigin fOrigin;
+ GrSwizzle fTextureSwizzle;
+
SkBackingFit fFit; // always kApprox for lazy-callback resources
// always kExact for wrapped resources
mutable SkBudgeted fBudgeted; // always kYes for lazy-callback resources
diff --git a/src/gpu/GrSwizzle.cpp b/src/gpu/GrSwizzle.cpp
index ae07d3d..707b272 100644
--- a/src/gpu/GrSwizzle.cpp
+++ b/src/gpu/GrSwizzle.cpp
@@ -5,9 +5,10 @@
* found in the LICENSE file.
*/
-#include "src/core/SkRasterPipeline.h"
#include "src/gpu/GrSwizzle.h"
+#include "src/core/SkRasterPipeline.h"
+
void GrSwizzle::apply(SkRasterPipeline* pipeline) const {
SkASSERT(pipeline);
switch (fKey) {
diff --git a/src/gpu/GrTextureProxy.cpp b/src/gpu/GrTextureProxy.cpp
index 73578bf..cbfbc25 100644
--- a/src/gpu/GrTextureProxy.cpp
+++ b/src/gpu/GrTextureProxy.cpp
@@ -15,24 +15,12 @@
#include "src/gpu/GrSurfacePriv.h"
#include "src/gpu/GrTexturePriv.h"
-// Deferred version - with data
-GrTextureProxy::GrTextureProxy(const GrBackendFormat& format, const GrSurfaceDesc& srcDesc,
- GrMipMapped mipMapped, SkBackingFit fit, SkBudgeted budgeted,
- const void* srcData, size_t /*rowBytes*/,
- GrInternalSurfaceFlags surfaceFlags)
- : INHERITED(format, srcDesc, kTopLeft_GrSurfaceOrigin, fit, budgeted, surfaceFlags)
- , fMipMapped(mipMapped)
- , fProxyProvider(nullptr)
- , fDeferredUploader(nullptr) {
- SkASSERT(!srcData); // currently handled in Make()
-}
-
// Deferred version - no data
GrTextureProxy::GrTextureProxy(const GrBackendFormat& format, const GrSurfaceDesc& srcDesc,
GrSurfaceOrigin origin, GrMipMapped mipMapped,
- SkBackingFit fit, SkBudgeted budgeted,
- GrInternalSurfaceFlags surfaceFlags)
- : INHERITED(format, srcDesc, origin, fit, budgeted, surfaceFlags)
+ const GrSwizzle& textureSwizzle, SkBackingFit fit,
+ SkBudgeted budgeted, GrInternalSurfaceFlags surfaceFlags)
+ : INHERITED(format, srcDesc, origin, textureSwizzle, fit, budgeted, surfaceFlags)
, fMipMapped(mipMapped)
, fProxyProvider(nullptr)
, fDeferredUploader(nullptr) {}
@@ -40,17 +28,19 @@
// Lazy-callback version
GrTextureProxy::GrTextureProxy(LazyInstantiateCallback&& callback, LazyInstantiationType lazyType,
const GrBackendFormat& format, const GrSurfaceDesc& desc,
- GrSurfaceOrigin origin, GrMipMapped mipMapped, SkBackingFit fit,
- SkBudgeted budgeted, GrInternalSurfaceFlags surfaceFlags)
- : INHERITED(std::move(callback), lazyType, format, desc, origin, fit, budgeted,
+ GrSurfaceOrigin origin, GrMipMapped mipMapped,
+ const GrSwizzle& texSwizzle, SkBackingFit fit, SkBudgeted budgeted,
+ GrInternalSurfaceFlags surfaceFlags)
+ : INHERITED(std::move(callback), lazyType, format, desc, origin, texSwizzle, fit, budgeted,
surfaceFlags)
, fMipMapped(mipMapped)
, fProxyProvider(nullptr)
, fDeferredUploader(nullptr) {}
// Wrapped version
-GrTextureProxy::GrTextureProxy(sk_sp<GrSurface> surf, GrSurfaceOrigin origin)
- : INHERITED(std::move(surf), origin, SkBackingFit::kExact)
+GrTextureProxy::GrTextureProxy(sk_sp<GrSurface> surf, GrSurfaceOrigin origin,
+ const GrSwizzle& textureSwizzle)
+ : INHERITED(std::move(surf), origin, textureSwizzle, SkBackingFit::kExact)
, fMipMapped(fTarget->asTexture()->texturePriv().mipMapped())
, fProxyProvider(nullptr)
, fDeferredUploader(nullptr) {
diff --git a/src/gpu/GrTextureProxy.h b/src/gpu/GrTextureProxy.h
index 098168f..a1e926b 100644
--- a/src/gpu/GrTextureProxy.h
+++ b/src/gpu/GrTextureProxy.h
@@ -88,13 +88,10 @@
friend class GrTextureProxyPriv;
friend class GrSurfaceProxyPriv; // ability to change key sync state after lazy instantiation.
- // Deferred version - when constructed with data the origin is always kTopLeft.
- GrTextureProxy(const GrBackendFormat&, const GrSurfaceDesc& srcDesc, GrMipMapped, SkBackingFit,
- SkBudgeted, const void* srcData, size_t srcRowBytes, GrInternalSurfaceFlags);
-
// Deferred version - no data.
GrTextureProxy(const GrBackendFormat&, const GrSurfaceDesc& srcDesc, GrSurfaceOrigin,
- GrMipMapped, SkBackingFit, SkBudgeted, GrInternalSurfaceFlags);
+ GrMipMapped, const GrSwizzle& textureSwizzle, SkBackingFit, SkBudgeted,
+ GrInternalSurfaceFlags);
// Lazy-callback version
// There are two main use cases for lazily-instantiated proxies:
@@ -107,11 +104,11 @@
// The minimal knowledge version is used for CCPR where we are generating an atlas but we do not
// know the final size until flush time.
GrTextureProxy(LazyInstantiateCallback&&, LazyInstantiationType, const GrBackendFormat&,
- const GrSurfaceDesc& desc, GrSurfaceOrigin, GrMipMapped, SkBackingFit,
- SkBudgeted, GrInternalSurfaceFlags);
+ const GrSurfaceDesc& desc, GrSurfaceOrigin, GrMipMapped, const GrSwizzle&,
+ SkBackingFit, SkBudgeted, GrInternalSurfaceFlags);
// Wrapped version
- GrTextureProxy(sk_sp<GrSurface>, GrSurfaceOrigin);
+ GrTextureProxy(sk_sp<GrSurface>, GrSurfaceOrigin, const GrSwizzle&);
~GrTextureProxy() override;
diff --git a/src/gpu/GrTextureRenderTargetProxy.cpp b/src/gpu/GrTextureRenderTargetProxy.cpp
index 7bf9002..8366e75 100644
--- a/src/gpu/GrTextureRenderTargetProxy.cpp
+++ b/src/gpu/GrTextureRenderTargetProxy.cpp
@@ -23,13 +23,17 @@
const GrSurfaceDesc& desc,
GrSurfaceOrigin origin,
GrMipMapped mipMapped,
+ const GrSwizzle& texSwizzle,
+ const GrSwizzle& outSwizzle,
SkBackingFit fit,
SkBudgeted budgeted,
GrInternalSurfaceFlags surfaceFlags)
- : GrSurfaceProxy(format, desc, origin, fit, budgeted, surfaceFlags)
+ : GrSurfaceProxy(format, desc, origin, texSwizzle, fit, budgeted, surfaceFlags)
// for now textures w/ data are always wrapped
- , GrRenderTargetProxy(caps, format, desc, origin, fit, budgeted, surfaceFlags)
- , GrTextureProxy(format, desc, origin, mipMapped, fit, budgeted, surfaceFlags) {}
+ , GrRenderTargetProxy(caps, format, desc, origin, texSwizzle, outSwizzle, fit, budgeted,
+ surfaceFlags)
+ , GrTextureProxy(format, desc, origin, mipMapped, texSwizzle, fit, budgeted, surfaceFlags) {
+}
// Lazy-callback version
GrTextureRenderTargetProxy::GrTextureRenderTargetProxy(LazyInstantiateCallback&& callback,
@@ -38,26 +42,30 @@
const GrSurfaceDesc& desc,
GrSurfaceOrigin origin,
GrMipMapped mipMapped,
+ const GrSwizzle& texSwizzle,
+ const GrSwizzle& outSwizzle,
SkBackingFit fit,
SkBudgeted budgeted,
GrInternalSurfaceFlags surfaceFlags)
- : GrSurfaceProxy(std::move(callback), lazyType, format, desc, origin, fit, budgeted,
- surfaceFlags)
+ : GrSurfaceProxy(std::move(callback), lazyType, format, desc, origin, texSwizzle, fit,
+ budgeted, surfaceFlags)
// Since we have virtual inheritance, we initialize GrSurfaceProxy directly. Send null
// callbacks to the texture and RT proxies simply to route to the appropriate constructors.
- , GrRenderTargetProxy(LazyInstantiateCallback(), lazyType, format, desc, origin, fit,
- budgeted, surfaceFlags, WrapsVkSecondaryCB::kNo)
+ , GrRenderTargetProxy(LazyInstantiateCallback(), lazyType, format, desc, origin, texSwizzle,
+ outSwizzle, fit, budgeted, surfaceFlags, WrapsVkSecondaryCB::kNo)
, GrTextureProxy(LazyInstantiateCallback(), lazyType, format, desc, origin, mipMapped,
- fit, budgeted, surfaceFlags) {}
+ texSwizzle, fit, budgeted, surfaceFlags) {}
// Wrapped version
// This class is virtually derived from GrSurfaceProxy (via both GrTextureProxy and
// GrRenderTargetProxy) so its constructor must be explicitly called.
GrTextureRenderTargetProxy::GrTextureRenderTargetProxy(sk_sp<GrSurface> surf,
- GrSurfaceOrigin origin)
- : GrSurfaceProxy(surf, origin, SkBackingFit::kExact)
- , GrRenderTargetProxy(surf, origin)
- , GrTextureProxy(surf, origin) {
+ GrSurfaceOrigin origin,
+ const GrSwizzle& texSwizzle,
+ const GrSwizzle& outSwizzle)
+ : GrSurfaceProxy(surf, origin, texSwizzle, SkBackingFit::kExact)
+ , GrRenderTargetProxy(surf, origin, texSwizzle, outSwizzle)
+ , GrTextureProxy(surf, origin, texSwizzle) {
SkASSERT(surf->asTexture());
SkASSERT(surf->asRenderTarget());
}
diff --git a/src/gpu/GrTextureRenderTargetProxy.h b/src/gpu/GrTextureRenderTargetProxy.h
index 57b4150..995a3e9 100644
--- a/src/gpu/GrTextureRenderTargetProxy.h
+++ b/src/gpu/GrTextureRenderTargetProxy.h
@@ -29,16 +29,20 @@
// Deferred version
GrTextureRenderTargetProxy(const GrCaps&, const GrBackendFormat&, const GrSurfaceDesc&,
- GrSurfaceOrigin, GrMipMapped, SkBackingFit, SkBudgeted,
+ GrSurfaceOrigin, GrMipMapped, const GrSwizzle& textureSwizzle,
+ const GrSwizzle& outputSwizzle, SkBackingFit, SkBudgeted,
GrInternalSurfaceFlags);
// Lazy-callback version
GrTextureRenderTargetProxy(LazyInstantiateCallback&&, LazyInstantiationType,
const GrBackendFormat&, const GrSurfaceDesc& desc, GrSurfaceOrigin,
- GrMipMapped, SkBackingFit, SkBudgeted, GrInternalSurfaceFlags);
+ GrMipMapped, const GrSwizzle& textureSwizzle,
+ const GrSwizzle& outputSwizzle, SkBackingFit, SkBudgeted,
+ GrInternalSurfaceFlags);
// Wrapped version
- GrTextureRenderTargetProxy(sk_sp<GrSurface>, GrSurfaceOrigin);
+ GrTextureRenderTargetProxy(sk_sp<GrSurface>, GrSurfaceOrigin, const GrSwizzle& textureSwizzle,
+ const GrSwizzle& outputSwizzle);
bool instantiate(GrResourceProvider*) override;
sk_sp<GrSurface> createSurface(GrResourceProvider*) const override;
diff --git a/src/gpu/glsl/GrGLSLShaderBuilder.cpp b/src/gpu/glsl/GrGLSLShaderBuilder.cpp
index bd30080..1345399 100644
--- a/src/gpu/glsl/GrGLSLShaderBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLShaderBuilder.cpp
@@ -5,12 +5,13 @@
* found in the LICENSE file.
*/
+#include "src/gpu/glsl/GrGLSLShaderBuilder.h"
+
#include "src/gpu/GrShaderCaps.h"
#include "src/gpu/GrShaderVar.h"
#include "src/gpu/GrSwizzle.h"
#include "src/gpu/glsl/GrGLSLColorSpaceXformHelper.h"
#include "src/gpu/glsl/GrGLSLProgramBuilder.h"
-#include "src/gpu/glsl/GrGLSLShaderBuilder.h"
GrGLSLShaderBuilder::GrGLSLShaderBuilder(GrGLSLProgramBuilder* program)
: fProgramBuilder(program)
diff --git a/src/gpu/mtl/GrMtlCaps.mm b/src/gpu/mtl/GrMtlCaps.mm
index 52c9494..ea1b697 100644
--- a/src/gpu/mtl/GrMtlCaps.mm
+++ b/src/gpu/mtl/GrMtlCaps.mm
@@ -657,7 +657,7 @@
static GrSwizzle get_swizzle(const GrBackendFormat& format, GrColorType colorType,
bool forOutput) {
SkASSERT(format.getMtlFormat());
- MTLPixelFormat mtlFormat = static_cast<MTLPixelFormat>(*format.getVkFormat());
+ MTLPixelFormat mtlFormat = static_cast<MTLPixelFormat>(*format.getMtlFormat());
SkASSERT(format_color_type_valid_pair(mtlFormat, colorType));
diff --git a/src/gpu/vk/GrVkCaps.cpp b/src/gpu/vk/GrVkCaps.cpp
index 50f7d7c..ed4cdb5 100644
--- a/src/gpu/vk/GrVkCaps.cpp
+++ b/src/gpu/vk/GrVkCaps.cpp
@@ -682,7 +682,7 @@
}
}
-// These are all the valid VkFormats that we support in Skia. They are roughly order from most
+// These are all the valid VkFormats that we support in Skia. They are roughly ordered from most
// frequently used to least to improve look up times in arrays.
static constexpr VkFormat kVkFormats[] = {
VK_FORMAT_R8G8B8A8_UNORM,