Changes to GrCoordTransform and local coords
*Don't track vertex-shader status per-coord transform, just at FP level
*Remove outdated "in processor" checks
*Adjust "uses local coords" on FP to consider whether coord transforms
actually transform local coords or custom coords
*Remove unused accessMatrix() method
*Don't track normalization and y-flipping separately from proxy
*Rename some things for clarity
*Simplify FPCoordTransformHandler
Change-Id: Ic493afc82bd949bbab177d33111a1942e33f88a9
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/256101
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
diff --git a/src/gpu/GrCoordTransform.h b/src/gpu/GrCoordTransform.h
index db32671..6201ce1 100644
--- a/src/gpu/GrCoordTransform.h
+++ b/src/gpu/GrCoordTransform.h
@@ -20,121 +20,69 @@
*/
class GrCoordTransform {
public:
- GrCoordTransform()
- : fProxy(nullptr)
- , fNormalize(false)
- , fReverseY(false)
- , fComputeInVertexShader(true) {
- SkDEBUGCODE(fInProcessor = false);
- }
+ GrCoordTransform() = default;
GrCoordTransform(const GrCoordTransform&) = default;
/**
- * Create a transformation that maps [0, 1] to a proxy's boundaries. The proxy origin also
- * implies whether a y-reversal should be performed.
+ * Create a transformation that maps [0, proxy->width()] x [0, proxy->height()] to a proxy's
+ * extent.
*/
- GrCoordTransform(GrSurfaceProxy* proxy) {
- SkASSERT(proxy);
- SkDEBUGCODE(fInProcessor = false);
- this->reset(SkMatrix::I(), proxy);
- }
+ GrCoordTransform(GrSurfaceProxy* proxy) : fProxy(proxy) {}
/**
* Create a transformation from a matrix. The proxy origin also implies whether a y-reversal
* should be performed.
*/
- GrCoordTransform(const SkMatrix& m, GrSurfaceProxy* proxy) {
+ GrCoordTransform(const SkMatrix& m, GrSurfaceProxy* proxy) : fProxy(proxy), fMatrix(m) {
SkASSERT(proxy);
- SkDEBUGCODE(fInProcessor = false);
- this->reset(m, proxy);
}
/**
* Create a transformation that applies the matrix to a coord set.
*/
- GrCoordTransform(const SkMatrix& m) {
- SkDEBUGCODE(fInProcessor = false);
- this->reset(m);
- }
+ GrCoordTransform(const SkMatrix& m) : fMatrix(m) {}
- GrCoordTransform& operator= (const GrCoordTransform& that) {
- SkASSERT(!fInProcessor);
- fMatrix = that.fMatrix;
- fProxy = that.fProxy;
- fNormalize = that.fNormalize;
- fReverseY = that.fReverseY;
- return *this;
- }
+ GrCoordTransform& operator=(const GrCoordTransform& that) = default;
- /**
- * Access the matrix for editing. Note, this must be done before adding the transform to an
- * effect, since effects are immutable.
- */
- SkMatrix* accessMatrix() {
- SkASSERT(!fInProcessor);
- return &fMatrix;
- }
+ // The textures' effect is to optionally normalize the final matrix, so a blind equality check
+ // could be misleading.
+ bool operator==(const GrCoordTransform& that) const = delete;
+ bool operator!=(const GrCoordTransform& that) const = delete;
- bool hasSameEffectAs(const GrCoordTransform& that) const {
- if (fNormalize != that.fNormalize ||
- fReverseY != that.fReverseY ||
- !fMatrix.cheapEqualTo(that.fMatrix)) {
+ bool hasSameEffectiveMatrix(const GrCoordTransform& that) const {
+ // This is slightly more conservative than computing each transforms effective matrix and
+ // then comparing them.
+ if (!fMatrix.cheapEqualTo(that.fMatrix)) {
return false;
}
-
- if (fNormalize) {
- if (fProxy->backingStoreDimensions() != that.fProxy->backingStoreDimensions()) {
- return false;
- }
+ if (SkToBool(fProxy) != SkToBool(that.fProxy)) {
+ return false;
}
-
+ if (this->normalize() != that.normalize() || this->reverseY() != that.reverseY()) {
+ return false;
+ }
+ if (this->normalize() &&
+ fProxy->backingStoreDimensions() != that.fProxy->backingStoreDimensions()) {
+ return false;
+ }
return true;
}
- const SkMatrix& getMatrix() const { return fMatrix; }
+ const SkMatrix& matrix() const { return fMatrix; }
const GrSurfaceProxy* proxy() const { return fProxy; }
- bool normalize() const { return fNormalize; }
- bool reverseY() const { return fReverseY; }
+ bool normalize() const {
+ return fProxy && fProxy->backendFormat().textureType() != GrTextureType::kRectangle;
+ }
+ bool reverseY() const { return fProxy && fProxy->origin() == kBottomLeft_GrSurfaceOrigin; }
// This should only ever be called at flush time after the backing texture has been
// successfully instantiated
GrTexture* peekTexture() const { return fProxy->peekTexture(); }
- bool computeInVertexShader() const { return fComputeInVertexShader; }
-
- void setComputeInVertexShader(bool computeInVertexShader) {
- fComputeInVertexShader = computeInVertexShader;
- }
-
private:
- void reset(const SkMatrix& m, GrSurfaceProxy* proxy = nullptr) {
- SkASSERT(!fInProcessor);
-
- fMatrix = m;
- fProxy = proxy;
- fNormalize = proxy && proxy->backendFormat().textureType() != GrTextureType::kRectangle;
- fReverseY = proxy && kBottomLeft_GrSurfaceOrigin == proxy->origin();
- fComputeInVertexShader = true;
- }
-
- // The textures' effect is to optionally normalize the final matrix, so a blind
- // equality check could be misleading
- bool operator==(const GrCoordTransform& that) const;
- bool operator!=(const GrCoordTransform& that) const;
-
- SkMatrix fMatrix;
- const GrSurfaceProxy* fProxy;
- bool fNormalize;
- bool fReverseY;
- bool fComputeInVertexShader;
-
-#ifdef SK_DEBUG
-public:
- void setInProcessor() const { fInProcessor = true; }
-private:
- mutable bool fInProcessor;
-#endif
+ const GrSurfaceProxy* fProxy = nullptr;
+ SkMatrix fMatrix = SkMatrix::I();
};
#endif
diff --git a/src/gpu/GrFragmentProcessor.cpp b/src/gpu/GrFragmentProcessor.cpp
index 88acf1e..23836f8 100644
--- a/src/gpu/GrFragmentProcessor.cpp
+++ b/src/gpu/GrFragmentProcessor.cpp
@@ -69,10 +69,8 @@
}
void GrFragmentProcessor::addCoordTransform(GrCoordTransform* transform) {
- transform->setComputeInVertexShader(this->computeLocalCoordsInVertexShader());
fCoordTransforms.push_back(transform);
- fFlags |= kUsesLocalCoords_Flag;
- SkDEBUGCODE(transform->setInProcessor();)
+ fFlags |= kHasCoordTranforms_Flag;
}
#ifdef SK_DEBUG
@@ -94,8 +92,8 @@
#endif
int GrFragmentProcessor::registerChildProcessor(std::unique_ptr<GrFragmentProcessor> child) {
- if (child->usesLocalCoords()) {
- fFlags |= kUsesLocalCoords_Flag;
+ if (child->fFlags & kHasCoordTranforms_Flag) {
+ fFlags |= kHasCoordTranforms_Flag;
}
fRequestedFeatures |= child->fRequestedFeatures;
@@ -111,7 +109,7 @@
}
int count = this->numCoordTransforms();
for (int i = 0; i < count; ++i) {
- if (!this->coordTransform(i).hasSameEffectAs(that.coordTransform(i))) {
+ if (!this->coordTransform(i).hasSameEffectiveMatrix(that.coordTransform(i))) {
return false;
}
}
diff --git a/src/gpu/GrFragmentProcessor.h b/src/gpu/GrFragmentProcessor.h
index c5e7b96..b65db7a 100644
--- a/src/gpu/GrFragmentProcessor.h
+++ b/src/gpu/GrFragmentProcessor.h
@@ -124,24 +124,26 @@
SkDEBUGCODE(bool isInstantiated() const;)
- /** Do any of the coordtransforms for this processor require local coords? */
- bool usesLocalCoords() const { return SkToBool(fFlags & kUsesLocalCoords_Flag); }
-
- bool computeLocalCoordsInVertexShader() const {
- return SkToBool(fFlags & kComputeLocalCoordsInVertexShader_Flag);
+ /** Do any of the coord transforms for this processor require local coords? */
+ bool usesLocalCoords() const {
+ // If the processor is sampled with explicit coords then we do not need to apply the
+ // coord transforms in the vertex shader to the local coords.
+ return SkToBool(fFlags & kHasCoordTranforms_Flag) &&
+ SkToBool(fFlags & kCoordTransformsApplyToLocalCoords_Flag);
}
- void setComputeLocalCoordsInVertexShader(bool value) const {
+ bool coordTransformsApplyToLocalCoords() const {
+ return SkToBool(fFlags & kCoordTransformsApplyToLocalCoords_Flag);
+ }
+
+ void setSampledWithExplicitCoords(bool value) {
if (value) {
- fFlags |= kComputeLocalCoordsInVertexShader_Flag;
+ fFlags &= ~kCoordTransformsApplyToLocalCoords_Flag;
} else {
- fFlags &= ~kComputeLocalCoordsInVertexShader_Flag;
+ fFlags |= kCoordTransformsApplyToLocalCoords_Flag;
}
- for (GrCoordTransform* transform : fCoordTransforms) {
- transform->setComputeInVertexShader(value);
- }
- for (const auto& child : fChildProcessors) {
- child->setComputeLocalCoordsInVertexShader(value);
+ for (auto& child : fChildProcessors) {
+ child->setSampledWithExplicitCoords(value);
}
}
@@ -318,7 +320,7 @@
GrFragmentProcessor(ClassID classID, OptimizationFlags optimizationFlags)
: INHERITED(classID)
- , fFlags(optimizationFlags | kComputeLocalCoordsInVertexShader_Flag) {
+ , fFlags(optimizationFlags | kCoordTransformsApplyToLocalCoords_Flag) {
SkASSERT((optimizationFlags & ~kAll_OptimizationFlags) == 0);
}
@@ -415,11 +417,11 @@
enum PrivateFlags {
kFirstPrivateFlag = kAll_OptimizationFlags + 1,
- kUsesLocalCoords_Flag = kFirstPrivateFlag,
- kComputeLocalCoordsInVertexShader_Flag = kFirstPrivateFlag << 1,
+ kHasCoordTranforms_Flag = kFirstPrivateFlag,
+ kCoordTransformsApplyToLocalCoords_Flag = kFirstPrivateFlag << 1,
};
- mutable uint32_t fFlags = kComputeLocalCoordsInVertexShader_Flag;
+ uint32_t fFlags = kCoordTransformsApplyToLocalCoords_Flag;
int fTextureSamplerCnt = 0;
diff --git a/src/gpu/GrPathProcessor.cpp b/src/gpu/GrPathProcessor.cpp
index 571ad1c..667a80f 100644
--- a/src/gpu/GrPathProcessor.cpp
+++ b/src/gpu/GrPathProcessor.cpp
@@ -58,11 +58,10 @@
void emitTransforms(GrGLSLVaryingHandler* varyingHandler,
FPCoordTransformHandler* transformHandler) {
- int i = 0;
- while (const GrCoordTransform* coordTransform = transformHandler->nextCoordTransform()) {
+ for (int i = 0; *transformHandler; ++*transformHandler, ++i) {
+ auto [coordTransform, fp] = transformHandler->get();
GrSLType varyingType =
- coordTransform->getMatrix().hasPerspective() ? kHalf3_GrSLType
- : kHalf2_GrSLType;
+ coordTransform.matrix().hasPerspective() ? kHalf3_GrSLType : kHalf2_GrSLType;
SkString strVaryingName;
strVaryingName.printf("TransformedCoord_%d", i);
@@ -75,10 +74,9 @@
fInstalledTransforms.back().fType = varyingType;
transformHandler->specifyCoordsForCurrCoordTransform(
- matrix_to_sksl(coordTransform->getMatrix()),
- UniformHandle(),
- GrShaderVar(SkString(v.fsIn()),
- varyingType));
+ matrix_to_sksl(coordTransform.matrix()),
+ UniformHandle(),
+ GrShaderVar(SkString(v.fsIn()), varyingType));
++i;
}
}
diff --git a/src/gpu/GrPrimitiveProcessor.cpp b/src/gpu/GrPrimitiveProcessor.cpp
index 87b6f3f..cf7b56b 100644
--- a/src/gpu/GrPrimitiveProcessor.cpp
+++ b/src/gpu/GrPrimitiveProcessor.cpp
@@ -31,7 +31,7 @@
for (int t = 0; t < numCoords; ++t) {
uint32_t key = 0;
const GrCoordTransform* coordTransform = coords[t];
- if (coordTransform->getMatrix().hasPerspective()) {
+ if (coordTransform->matrix().hasPerspective()) {
key |= kGeneral_MatrixType;
} else {
key |= kNoPersp_MatrixType;
diff --git a/src/gpu/ccpr/GrGSCoverageProcessor.cpp b/src/gpu/ccpr/GrGSCoverageProcessor.cpp
index 320cd0c..09941fd 100644
--- a/src/gpu/ccpr/GrGSCoverageProcessor.cpp
+++ b/src/gpu/ccpr/GrGSCoverageProcessor.cpp
@@ -40,7 +40,7 @@
this->emitGeometryShader(proc, varyingHandler, args.fGeomBuilder, args.fRTAdjustName);
varyingHandler->emitAttributes(proc);
varyingHandler->setNoPerspective();
- SkASSERT(!args.fFPCoordTransformHandler->nextCoordTransform());
+ SkASSERT(!*args.fFPCoordTransformHandler);
// Fragment shader.
GrGLSLFPFragmentBuilder* f = args.fFragBuilder;
diff --git a/src/gpu/ccpr/GrSampleMaskProcessor.cpp b/src/gpu/ccpr/GrSampleMaskProcessor.cpp
index 7c8e9a9..d40fd77 100644
--- a/src/gpu/ccpr/GrSampleMaskProcessor.cpp
+++ b/src/gpu/ccpr/GrSampleMaskProcessor.cpp
@@ -31,7 +31,7 @@
int inputWidth = (4 == numInputPoints || proc.hasInputWeight()) ? 4 : 3;
varyingHandler->emitAttributes(proc);
- SkASSERT(!args.fFPCoordTransformHandler->nextCoordTransform());
+ SkASSERT(!*args.fFPCoordTransformHandler);
if (PrimitiveType::kTriangles == proc.fPrimitiveType) {
SkASSERT(!proc.hasInstanceAttributes()); // Triangles are drawn with vertex arrays.
diff --git a/src/gpu/ccpr/GrVSCoverageProcessor.cpp b/src/gpu/ccpr/GrVSCoverageProcessor.cpp
index 231c046..05819f3 100644
--- a/src/gpu/ccpr/GrVSCoverageProcessor.cpp
+++ b/src/gpu/ccpr/GrVSCoverageProcessor.cpp
@@ -442,7 +442,7 @@
"vertexpos", "coverage", "corner_coverage", "wind");
varyingHandler->emitAttributes(proc);
- SkASSERT(!args.fFPCoordTransformHandler->nextCoordTransform());
+ SkASSERT(!*args.fFPCoordTransformHandler);
// Fragment shader.
GrGLSLFPFragmentBuilder* f = args.fFragBuilder;
diff --git a/src/gpu/glsl/GrGLSLFragmentProcessor.cpp b/src/gpu/glsl/GrGLSLFragmentProcessor.cpp
index 706e892..8d6c94d 100644
--- a/src/gpu/glsl/GrGLSLFragmentProcessor.cpp
+++ b/src/gpu/glsl/GrGLSLFragmentProcessor.cpp
@@ -35,7 +35,7 @@
}
// if the fragment processor is invoked with overridden coordinates, it must *always* be invoked
// with overridden coords
- SkASSERT(args.fFp.computeLocalCoordsInVertexShader() == (skslCoords.length() == 0));
+ SkASSERT(args.fFp.coordTransformsApplyToLocalCoords() == (skslCoords.length() == 0));
fragBuilder->codeAppendf("%s = %s(%s", outputColor, fFunctionNames[childIndex].c_str(),
inputColor ? inputColor : "half4(1)");
if (skslCoords.length()) {
@@ -54,7 +54,7 @@
while (childIndex >= (int) fFunctionNames.size()) {
fFunctionNames.emplace_back();
}
- if (!args.fFp.computeLocalCoordsInVertexShader() && skslCoords.length() == 0) {
+ if (!args.fFp.coordTransformsApplyToLocalCoords() && skslCoords.length() == 0) {
skslCoords = "_coords";
}
if (fFunctionNames[childIndex].size() == 0) {
diff --git a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
index bae50e9..5347ab3 100644
--- a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
@@ -163,7 +163,7 @@
GrGLSLFragmentProcessor::EmitArgs& args) {
this->onBeforeChildProcEmitCode();
this->nextStage();
- if (!args.fFp.computeLocalCoordsInVertexShader() && args.fTransformedCoords.count() > 0) {
+ if (!args.fFp.coordTransformsApplyToLocalCoords() && args.fTransformedCoords.count() > 0) {
// we currently only support overriding a single coordinate pair
SkASSERT(args.fTransformedCoords.count() == 1);
const GrGLSLProgramDataManager::UniformHandle& mat =
@@ -182,7 +182,7 @@
SkString result;
this->emitFunction(kHalf4_GrSLType,
"stage",
- args.fFp.computeLocalCoordsInVertexShader() ? 1 : 2,
+ args.fFp.coordTransformsApplyToLocalCoords() ? 1 : 2,
params,
this->code().c_str(),
&result);
diff --git a/src/gpu/glsl/GrGLSLGeometryProcessor.cpp b/src/gpu/glsl/GrGLSLGeometryProcessor.cpp
index adb20fa..feaa162 100644
--- a/src/gpu/glsl/GrGLSLGeometryProcessor.cpp
+++ b/src/gpu/glsl/GrGLSLGeometryProcessor.cpp
@@ -67,8 +67,8 @@
} else {
localCoords.printf("float3(%s, 1)", localCoordsVar.c_str());
}
- int i = 0;
- while (const GrCoordTransform* coordTransform = handler->nextCoordTransform()) {
+ for (int i = 0; *handler; ++*handler, ++i) {
+ auto [coordTransform, fp] = handler->get();
SkString strUniName;
strUniName.printf("CoordTransformMatrix_%d", i);
const char* uniName;
@@ -77,14 +77,14 @@
strUniName.c_str(),
&uniName).toIndex();
GrSLType varyingType = kFloat2_GrSLType;
- if (localMatrix.hasPerspective() || coordTransform->getMatrix().hasPerspective()
- || threeComponentLocalCoords) {
+ if (localMatrix.hasPerspective() || coordTransform.matrix().hasPerspective() ||
+ threeComponentLocalCoords) {
varyingType = kFloat3_GrSLType;
}
SkString strVaryingName;
strVaryingName.printf("TransformedCoords_%d", i);
GrGLSLVarying v(varyingType);
- if (coordTransform->computeInVertexShader()) {
+ if (fp.coordTransformsApplyToLocalCoords()) {
varyingHandler->addVarying(strVaryingName.c_str(), &v);
if (kFloat2_GrSLType == varyingType) {
@@ -96,7 +96,6 @@
handler->specifyCoordsForCurrCoordTransform(SkString(uniName),
fInstalledTransforms.back().fHandle,
GrShaderVar(SkString(v.fsIn()), varyingType));
- ++i;
}
}
diff --git a/src/gpu/glsl/GrGLSLPrimitiveProcessor.cpp b/src/gpu/glsl/GrGLSLPrimitiveProcessor.cpp
index cccbeed..983e11e 100644
--- a/src/gpu/glsl/GrGLSLPrimitiveProcessor.cpp
+++ b/src/gpu/glsl/GrGLSLPrimitiveProcessor.cpp
@@ -17,7 +17,7 @@
SkMatrix GrGLSLPrimitiveProcessor::GetTransformMatrix(const SkMatrix& localMatrix,
const GrCoordTransform& coordTransform) {
SkMatrix combined;
- combined.setConcat(coordTransform.getMatrix(), localMatrix);
+ combined.setConcat(coordTransform.matrix(), localMatrix);
if (coordTransform.normalize()) {
combined.postIDiv(coordTransform.peekTexture()->width(),
coordTransform.peekTexture()->height());
@@ -66,16 +66,19 @@
//////////////////////////////////////////////////////////////////////////////
-const GrCoordTransform* GrGLSLPrimitiveProcessor::FPCoordTransformHandler::nextCoordTransform() {
- SkASSERT(nullptr == fCurr || fAddedCoord);
- if (!fIter) {
- return nullptr;
- }
- auto [transform, fp] = *fIter;
+GrGLSLPrimitiveProcessor::FPCoordTransformHandler::FPCoordTransformHandler(
+ const GrPipeline& pipeline, SkTArray<TransformVar>* transformedCoordVars)
+ : fIter(pipeline), fTransformedCoordVars(transformedCoordVars) {}
+
+std::pair<const GrCoordTransform&, const GrFragmentProcessor&>
+GrGLSLPrimitiveProcessor::FPCoordTransformHandler::get() const {
+ return *fIter;
+}
+
+GrGLSLPrimitiveProcessor::FPCoordTransformHandler&
+GrGLSLPrimitiveProcessor::FPCoordTransformHandler::operator++() {
+ SkASSERT(fAddedCoord);
++fIter;
-#ifdef SK_DEBUG
- fAddedCoord = false;
- fCurr = &transform;
-#endif
- return &transform;
+ SkDEBUGCODE(fAddedCoord = false;)
+ return *this;
}
diff --git a/src/gpu/glsl/GrGLSLPrimitiveProcessor.h b/src/gpu/glsl/GrGLSLPrimitiveProcessor.h
index 9327d15..1aae153 100644
--- a/src/gpu/glsl/GrGLSLPrimitiveProcessor.h
+++ b/src/gpu/glsl/GrGLSLPrimitiveProcessor.h
@@ -56,14 +56,15 @@
*/
class FPCoordTransformHandler : public SkNoncopyable {
public:
- FPCoordTransformHandler(const GrPipeline& pipeline,
- SkTArray<TransformVar>* transformedCoordVars)
- : fIter(pipeline)
- , fTransformedCoordVars(transformedCoordVars) {}
+ FPCoordTransformHandler(const GrPipeline&, SkTArray<TransformVar>*);
+ ~FPCoordTransformHandler() { SkASSERT(!fIter); }
- ~FPCoordTransformHandler() { SkASSERT(!this->nextCoordTransform());}
+ operator bool() const { return (bool)fIter; }
- const GrCoordTransform* nextCoordTransform();
+ // Gets the current coord transform and its owning GrFragmentProcessor.
+ std::pair<const GrCoordTransform&, const GrFragmentProcessor&> get() const;
+
+ FPCoordTransformHandler& operator++();
// 'args' are constructor params to GrShaderVar.
template<typename... Args>
@@ -76,7 +77,6 @@
private:
GrFragmentProcessor::CoordTransformIter fIter;
SkDEBUGCODE(bool fAddedCoord = false;)
- SkDEBUGCODE(const GrCoordTransform* fCurr = nullptr;)
SkTArray<TransformVar>* fTransformedCoordVars;
};
diff --git a/src/shaders/SkPerlinNoiseShader.cpp b/src/shaders/SkPerlinNoiseShader.cpp
index 812dc16..46cf30c 100644
--- a/src/shaders/SkPerlinNoiseShader.cpp
+++ b/src/shaders/SkPerlinNoiseShader.cpp
@@ -738,7 +738,7 @@
bool stitchTiles() const { return fStitchTiles; }
const SkVector& baseFrequency() const { return fPaintingData->fBaseFrequency; }
int numOctaves() const { return fNumOctaves; }
- const SkMatrix& matrix() const { return fCoordTransform.getMatrix(); }
+ const SkMatrix& matrix() const { return fCoordTransform.matrix(); }
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
@@ -1166,7 +1166,7 @@
const SkVector& baseFrequency() const { return fPaintingData->fBaseFrequency; }
SkScalar z() const { return fZ; }
int octaves() const { return fOctaves; }
- const SkMatrix& matrix() const { return fCoordTransform.getMatrix(); }
+ const SkMatrix& matrix() const { return fCoordTransform.matrix(); }
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
diff --git a/src/sksl/SkSLHCodeGenerator.cpp b/src/sksl/SkSLHCodeGenerator.cpp
index 6c41e74..0790a1e 100644
--- a/src/sksl/SkSLHCodeGenerator.cpp
+++ b/src/sksl/SkSLHCodeGenerator.cpp
@@ -282,7 +282,7 @@
this->writef(" %s_index = this->numChildProcessors();",
FieldName(String(param->fName).c_str()).c_str());
if (fSectionAndParameterHelper.hasCoordOverrides(*param)) {
- this->writef(" %s->setComputeLocalCoordsInVertexShader(false);",
+ this->writef(" %s->setSampledWithExplicitCoords(true);",
String(param->fName).c_str());
}
this->writef(" this->registerChildProcessor(std::move(%s));",