Pass origin into GrCoordTransform.

This allows us to not need to read the origin from the stored proxy

Bug: skia:9556
Change-Id: I1c09805201518db2aac2279d02e20b20fc2c0084
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/270374
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>

Author: egdaniel

src/effects/imagefilters/SkDisplacementMapEffect.cpp

@@ -486,9 +486,10 @@ GrDisplacementMapEffect::GrDisplacementMapEffect(
         , fDisplacementTransform(
                 SkMatrix::Concat(SkMatrix::MakeTrans(displSubset.x(), displSubset.y()),
                                  offsetMatrix),
-                displacement.proxy())
+                displacement.proxy(), displacement.origin())
         , fDisplacementSampler(std::move(displacement))
-        , fColorTransform(SkMatrix::MakeTrans(colorSubset.x(), colorSubset.y()), color.proxy())
+        , fColorTransform(SkMatrix::MakeTrans(colorSubset.x(), colorSubset.y()), color.proxy(),
+                          color.origin())
         , fDomain(color.proxy(),
                   GrTextureDomain::MakeTexelDomain(colorSubset,
                                                    GrTextureDomain::kDecal_Mode),

src/effects/imagefilters/SkLightingImageFilter.cpp

@@ -1615,7 +1615,7 @@ GrLightingEffect::GrLightingEffect(ClassID classID,
                                    const SkIRect* srcBounds)
         // Perhaps this could advertise the opaque or coverage-as-alpha optimizations?
         : INHERITED(classID, kNone_OptimizationFlags)
-        , fCoordTransform(view.proxy())
+        , fCoordTransform(view.proxy(), view.origin())
         , fDomain(create_domain(view.proxy(), srcBounds, GrTextureDomain::kDecal_Mode))
         , fTextureSampler(std::move(view))
         , fLight(std::move(light))

src/effects/imagefilters/SkMorphologyImageFilter.cpp

@@ -400,7 +400,7 @@ GrMorphologyEffect::GrMorphologyEffect(GrSurfaceProxyView view,
                                        MorphType type,
                                        const float range[2])
         : INHERITED(kGrMorphologyEffect_ClassID, ModulateForClampedSamplerOptFlags(srcAlphaType))
-        , fCoordTransform(view.proxy())
+        , fCoordTransform(view.proxy(), view.origin())
         , fTextureSampler(std::move(view))
         , fDirection(direction)
         , fRadius(radius)

src/gpu/GrCoordTransform.h

@@ -29,13 +29,15 @@ class GrCoordTransform {
      * Create a transformation that maps [0, proxy->width()] x [0, proxy->height()] to a proxy's
      * extent.
      */
-    GrCoordTransform(GrSurfaceProxy* proxy) : fProxy(proxy) {}
+    GrCoordTransform(GrSurfaceProxy* proxy, GrSurfaceOrigin origin)
+            : fProxy(proxy), fOrigin(origin) {}
 
     /**
-     * Create a transformation from a matrix. The proxy origin also implies whether a y-reversal
-     * should be performed.
+     * Create a transformation from a matrix. The origin implies whether a y-reversal should be
+     * performed.
      */
-    GrCoordTransform(const SkMatrix& m, GrSurfaceProxy* proxy) : fProxy(proxy), fMatrix(m) {
+    GrCoordTransform(const SkMatrix& m, GrSurfaceProxy* proxy, GrSurfaceOrigin origin)
+            : fProxy(proxy), fOrigin(origin), fMatrix(m) {
         SkASSERT(proxy);
     }
 
@@ -75,7 +77,7 @@ class GrCoordTransform {
     bool normalize() const {
         return fProxy && fProxy->backendFormat().textureType() != GrTextureType::kRectangle;
     }
-    bool reverseY() const { return fProxy && fProxy->origin() == kBottomLeft_GrSurfaceOrigin; }
+    bool reverseY() const { return fProxy && fOrigin == kBottomLeft_GrSurfaceOrigin; }
     bool isNoOp() const { return fMatrix.isIdentity() && !this->normalize() && !this->reverseY(); }
 
     // This should only ever be called at flush time after the backing texture has been
@@ -84,6 +86,7 @@ class GrCoordTransform {
 
 private:
     const GrSurfaceProxy* fProxy = nullptr;
+    GrSurfaceOrigin fOrigin = kTopLeft_GrSurfaceOrigin;
     SkMatrix fMatrix = SkMatrix::I();
 };
 

src/gpu/effects/GrBicubicEffect.cpp

@@ -169,7 +169,7 @@ GrBicubicEffect::GrBicubicEffect(GrSurfaceProxyView view, const SkMatrix& matrix
         : INHERITED{kGrBicubicEffect_ClassID,
                     ModulateForSamplerOptFlags(
                             alphaType, GrTextureDomain::IsDecalSampled(wrapModes, modeX, modeY))}
-        , fCoordTransform(matrix, view.proxy())
+        , fCoordTransform(matrix, view.proxy(), view.origin())
         , fDomain(view.proxy(), domain, modeX, modeY)
         , fTextureSampler(std::move(view),
                           GrSamplerState(wrapModes, GrSamplerState::Filter::kNearest))

src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp

@@ -224,7 +224,7 @@ GrGaussianConvolutionFragmentProcessor::GrGaussianConvolutionFragmentProcessor(
         int bounds[2])
         : INHERITED(kGrGaussianConvolutionFragmentProcessor_ClassID,
                     ModulateForSamplerOptFlags(alphaType, mode == GrTextureDomain::kDecal_Mode))
-        , fCoordTransform(view.proxy())
+        , fCoordTransform(view.proxy(), view.origin())
         , fTextureSampler(std::move(view))
         , fRadius(radius)
         , fDirection(direction)

src/gpu/effects/GrMatrixConvolutionEffect.cpp

@@ -155,7 +155,7 @@ GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(GrSurfaceProxyView srcView,
         // To advertise either the modulation or opaqueness optimizations we'd have to examine the
         // parameters.
         : INHERITED(kGrMatrixConvolutionEffect_ClassID, kNone_OptimizationFlags)
-        , fCoordTransform(srcView.proxy())
+        , fCoordTransform(srcView.proxy(), srcView.origin())
         , fDomain(srcView.proxy(), GrTextureDomain::MakeTexelDomain(srcBounds, tileMode),
                   tileMode, tileMode)
         , fTextureSampler(std::move(srcView))

src/gpu/effects/GrTextureEffect.cpp

@@ -414,7 +414,7 @@ GrTextureEffect::GrTextureEffect(GrSurfaceProxyView view, SkAlphaType alphaType,
                                  const SkMatrix& matrix, const Sampling& sampling)
         : GrFragmentProcessor(kGrTextureEffect_ClassID,
                               ModulateForSamplerOptFlags(alphaType, sampling.usesDecal()))
-        , fCoordTransform(matrix, view.proxy())
+        , fCoordTransform(matrix, view.proxy(), view.origin())
         , fSampler(std::move(view), sampling.fHWSampler)
         , fSubset(sampling.fShaderSubset)
         , fShaderModes{sampling.fShaderModes[0], sampling.fShaderModes[1]} {

src/gpu/effects/generated/GrAlphaThresholdFragmentProcessor.h

@@ -40,7 +40,7 @@ class GrAlphaThresholdFragmentProcessor : public GrFragmentProcessor {
             : INHERITED(kGrAlphaThresholdFragmentProcessor_ClassID, kNone_OptimizationFlags)
             , maskCoordTransform(
                       SkMatrix::MakeTrans(SkIntToScalar(-bounds.x()), SkIntToScalar(-bounds.y())),
-                      mask.proxy())
+                      mask.proxy(), mask.origin())
             , mask(std::move(mask))
             , innerThreshold(innerThreshold)
             , outerThreshold(outerThreshold) {

src/gpu/effects/generated/GrMagnifierEffect.h

@@ -39,7 +39,7 @@ class GrMagnifierEffect : public GrFragmentProcessor {
     GrMagnifierEffect(GrSurfaceProxyView src, SkIRect bounds, SkRect srcRect, float xInvZoom,
                       float yInvZoom, float xInvInset, float yInvInset)
             : INHERITED(kGrMagnifierEffect_ClassID, kNone_OptimizationFlags)
-            , srcCoordTransform(SkMatrix::I(), src.proxy())
+            , srcCoordTransform(SkMatrix::I(), src.proxy(), src.origin())
             , src(std::move(src))
             , bounds(bounds)
             , srcRect(srcRect)