Renames of processor analysis-related classes and method.
GrProcesserSet::FragmentProcessorAnalysis->GrProcessorSet::Analysis
GrPipelineAnalysisColor->GrProcessorAnalysisColor
GrPipelineAnalysisCoverage->GrProcessorAnalysisCoverage
GrMeshDrawOp::getFragmentProcessorAnalysisInputs->GrMeshDrawOp::getProcessorAnalysisInputs
Change-Id: I28ad19dfab5f4ac1788c4eacdec5e1af2a701dd0
Reviewed-on: https://skia-review.googlesource.com/10747
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
diff --git a/src/gpu/GrFragmentProcessor.cpp b/src/gpu/GrFragmentProcessor.cpp
index fdec93b..601cb3c 100644
--- a/src/gpu/GrFragmentProcessor.cpp
+++ b/src/gpu/GrFragmentProcessor.cpp
@@ -8,7 +8,7 @@
#include "GrFragmentProcessor.h"
#include "GrCoordTransform.h"
#include "GrPipeline.h"
-#include "GrPipelineAnalysis.h"
+#include "GrProcessorAnalysis.h"
#include "effects/GrConstColorProcessor.h"
#include "effects/GrXfermodeFragmentProcessor.h"
#include "glsl/GrGLSLFragmentProcessor.h"
diff --git a/src/gpu/GrPipeline.h b/src/gpu/GrPipeline.h
index 3802faa..75d82d6 100644
--- a/src/gpu/GrPipeline.h
+++ b/src/gpu/GrPipeline.h
@@ -57,10 +57,10 @@
uint32_t fFlags = 0;
GrDrawFace fDrawFace = GrDrawFace::kBoth;
const GrProcessorSet* fProcessors = nullptr;
- GrPipelineAnalysisColor fInputColor;
- GrPipelineAnalysisCoverage fInputCoverage = GrPipelineAnalysisCoverage::kNone;
+ GrProcessorAnalysisColor fInputColor;
+ GrProcessorAnalysisCoverage fInputCoverage = GrProcessorAnalysisCoverage::kNone;
// This is only used for GrMeshDrawOp's legacy pipeline creation system.
- const GrProcessorSet::FragmentProcessorAnalysis* fAnalysis = nullptr;
+ const GrProcessorSet::Analysis* fAnalysis = nullptr;
const GrUserStencilSettings* fUserStencil = &GrUserStencilSettings::kUnused;
const GrAppliedClip* fAppliedClip = nullptr;
GrRenderTarget* fRenderTarget = nullptr;
diff --git a/src/gpu/GrPrimitiveProcessor.h b/src/gpu/GrPrimitiveProcessor.h
index 17e49c7..ddccd99 100644
--- a/src/gpu/GrPrimitiveProcessor.h
+++ b/src/gpu/GrPrimitiveProcessor.h
@@ -24,7 +24,7 @@
* GrPrimitiveProcessor. These loops run on the CPU and to determine known properties of the final
* color and coverage inputs to the GrXferProcessor in order to perform optimizations that preserve
* correctness. The GrDrawOp seeds these loops with initial color and coverage, in its
- * getFragmentProcessorAnalysisInputs implementation. These seed values are processed by the
+ * getProcessorAnalysisInputs implementation. These seed values are processed by the
* subsequent
* stages of the rendering pipeline and the output is then fed back into the GrDrawOp in
* the applyPipelineOptimizations call, where the op can use the information to inform decisions
diff --git a/src/gpu/GrPipelineAnalysis.cpp b/src/gpu/GrProcessorAnalysis.cpp
similarity index 97%
rename from src/gpu/GrPipelineAnalysis.cpp
rename to src/gpu/GrProcessorAnalysis.cpp
index 3512c94..317246d 100644
--- a/src/gpu/GrPipelineAnalysis.cpp
+++ b/src/gpu/GrProcessorAnalysis.cpp
@@ -5,7 +5,7 @@
* found in the LICENSE file.
*/
-#include "GrPipelineAnalysis.h"
+#include "GrProcessorAnalysis.h"
#include "GrGeometryProcessor.h"
#include "ops/GrDrawOp.h"
diff --git a/src/gpu/GrPipelineAnalysis.h b/src/gpu/GrProcessorAnalysis.h
similarity index 82%
rename from src/gpu/GrPipelineAnalysis.h
rename to src/gpu/GrProcessorAnalysis.h
index caf41b8..ad56ab4 100644
--- a/src/gpu/GrPipelineAnalysis.h
+++ b/src/gpu/GrProcessorAnalysis.h
@@ -5,8 +5,8 @@
* found in the LICENSE file.
*/
-#ifndef GrPipelineAnalysis_DEFINED
-#define GrPipelineAnalysis_DEFINED
+#ifndef GrProcessorAnalysis_DEFINED
+#define GrProcessorAnalysis_DEFINED
#include "GrColor.h"
@@ -14,17 +14,17 @@
class GrFragmentProcessor;
class GrPrimitiveProcessor;
-class GrPipelineAnalysisColor {
+class GrProcessorAnalysisColor {
public:
enum class Opaque {
kNo,
kYes,
};
- GrPipelineAnalysisColor(Opaque opaque = Opaque::kNo)
+ GrProcessorAnalysisColor(Opaque opaque = Opaque::kNo)
: fFlags(opaque == Opaque::kYes ? kIsOpaque_Flag : 0) {}
- GrPipelineAnalysisColor(GrColor color) { this->setToConstant(color); }
+ GrProcessorAnalysisColor(GrColor color) { this->setToConstant(color); }
void setToConstant(GrColor color) {
fColor = color;
@@ -51,7 +51,7 @@
return false;
}
- bool operator==(const GrPipelineAnalysisColor& that) const {
+ bool operator==(const GrProcessorAnalysisColor& that) const {
if (fFlags != that.fFlags) {
return false;
}
@@ -59,9 +59,9 @@
}
/** The returned value reflects the common properties of the two inputs. */
- static GrPipelineAnalysisColor Combine(const GrPipelineAnalysisColor& a,
- const GrPipelineAnalysisColor& b) {
- GrPipelineAnalysisColor result;
+ static GrProcessorAnalysisColor Combine(const GrProcessorAnalysisColor& a,
+ const GrProcessorAnalysisColor& b) {
+ GrProcessorAnalysisColor result;
uint32_t commonFlags = a.fFlags & b.fFlags;
if ((kColorIsKnown_Flag & commonFlags) && a.fColor == b.fColor) {
result.fColor = a.fColor;
@@ -81,7 +81,7 @@
GrColor fColor;
};
-enum class GrPipelineAnalysisCoverage { kNone, kSingleChannel, kLCD };
+enum class GrProcessorAnalysisCoverage { kNone, kSingleChannel, kLCD };
/**
* GrColorFragmentProcessorAnalysis gathers invariant data from a set of color fragment processor.
@@ -92,7 +92,7 @@
public:
GrColorFragmentProcessorAnalysis() = default;
- GrColorFragmentProcessorAnalysis(const GrPipelineAnalysisColor& input)
+ GrColorFragmentProcessorAnalysis(const GrProcessorAnalysisColor& input)
: GrColorFragmentProcessorAnalysis() {
fAllProcessorsCompatibleWithCoverageAsAlpha = true;
fIsOpaque = input.isOpaque();
@@ -103,7 +103,7 @@
}
}
- void reset(const GrPipelineAnalysisColor& input) {
+ void reset(const GrProcessorAnalysisColor& input) {
*this = GrColorFragmentProcessorAnalysis(input);
}
@@ -151,12 +151,12 @@
return SkTMax(0, fProcessorsVisitedWithKnownOutput);
}
- GrPipelineAnalysisColor outputColor() const {
+ GrProcessorAnalysisColor outputColor() const {
if (fProcessorsVisitedWithKnownOutput != fTotalProcessorsVisited) {
- return GrPipelineAnalysisColor(fIsOpaque ? GrPipelineAnalysisColor::Opaque::kYes
- : GrPipelineAnalysisColor::Opaque::kNo);
+ return GrProcessorAnalysisColor(fIsOpaque ? GrProcessorAnalysisColor::Opaque::kYes
+ : GrProcessorAnalysisColor::Opaque::kNo);
}
- return GrPipelineAnalysisColor(fLastKnownOutputColor.toGrColor());
+ return GrProcessorAnalysisColor(fLastKnownOutputColor.toGrColor());
}
private:
diff --git a/src/gpu/GrProcessorSet.cpp b/src/gpu/GrProcessorSet.cpp
index b47a026..21b20c7 100644
--- a/src/gpu/GrProcessorSet.cpp
+++ b/src/gpu/GrProcessorSet.cpp
@@ -8,7 +8,6 @@
#include "GrProcessorSet.h"
#include "GrAppliedClip.h"
#include "GrCaps.h"
-#include "GrPipelineAnalysis.h"
#include "GrXferProcessor.h"
GrProcessorSet::GrProcessorSet(GrPaint&& paint) {
@@ -81,14 +80,13 @@
//////////////////////////////////////////////////////////////////////////////
-void GrProcessorSet::FragmentProcessorAnalysis::internalInit(
- const GrPipelineAnalysisColor& colorInput,
- const GrPipelineAnalysisCoverage coverageInput,
- const GrProcessorSet& processors,
- const GrFragmentProcessor* clipFP,
- const GrCaps& caps) {
+void GrProcessorSet::Analysis::internalInit(const GrProcessorAnalysisColor& colorInput,
+ const GrProcessorAnalysisCoverage coverageInput,
+ const GrProcessorSet& processors,
+ const GrFragmentProcessor* clipFP,
+ const GrCaps& caps) {
GrColorFragmentProcessorAnalysis colorInfo(colorInput);
- fCompatibleWithCoverageAsAlpha = GrPipelineAnalysisCoverage::kLCD != coverageInput;
+ fCompatibleWithCoverageAsAlpha = GrProcessorAnalysisCoverage::kLCD != coverageInput;
fValidInputColor = colorInput.isConstant(&fInputColor);
const GrFragmentProcessor* const* fps =
@@ -117,7 +115,7 @@
fInitialColorProcessorsToEliminate = colorInfo.initialProcessorsToEliminate(&fInputColor);
fValidInputColor |= SkToBool(fInitialColorProcessorsToEliminate);
- GrPipelineAnalysisColor outputColor = colorInfo.outputColor();
+ GrProcessorAnalysisColor outputColor = colorInfo.outputColor();
if (outputColor.isConstant(&fKnownOutputColor)) {
fOutputColorType = static_cast<unsigned>(ColorType::kConstant);
} else if (outputColor.isOpaque()) {
@@ -126,20 +124,20 @@
fOutputColorType = static_cast<unsigned>(ColorType::kUnknown);
}
- GrPipelineAnalysisCoverage outputCoverage;
- if (GrPipelineAnalysisCoverage::kLCD == coverageInput) {
- outputCoverage = GrPipelineAnalysisCoverage::kLCD;
- } else if (hasCoverageFP || GrPipelineAnalysisCoverage::kSingleChannel == coverageInput) {
- outputCoverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ GrProcessorAnalysisCoverage outputCoverage;
+ if (GrProcessorAnalysisCoverage::kLCD == coverageInput) {
+ outputCoverage = GrProcessorAnalysisCoverage::kLCD;
+ } else if (hasCoverageFP || GrProcessorAnalysisCoverage::kSingleChannel == coverageInput) {
+ outputCoverage = GrProcessorAnalysisCoverage::kSingleChannel;
} else {
- outputCoverage = GrPipelineAnalysisCoverage::kNone;
+ outputCoverage = GrProcessorAnalysisCoverage::kNone;
}
fOutputCoverageType = static_cast<unsigned>(outputCoverage);
GrXPFactory::AnalysisProperties props = GrXPFactory::GetAnalysisProperties(
processors.fXPFactory, colorInfo.outputColor(), outputCoverage, caps);
if (!processors.numCoverageFragmentProcessors() &&
- GrPipelineAnalysisCoverage::kNone == coverageInput) {
+ GrProcessorAnalysisCoverage::kNone == coverageInput) {
fCanCombineOverlappedStencilAndCover = SkToBool(
props & GrXPFactory::AnalysisProperties::kCanCombineOverlappedStencilAndCover);
} else {
@@ -167,32 +165,31 @@
}
}
-void GrProcessorSet::FragmentProcessorAnalysis::init(const GrPipelineAnalysisColor& colorInput,
- const GrPipelineAnalysisCoverage coverageInput,
- const GrProcessorSet& processors,
- const GrAppliedClip* appliedClip,
- const GrCaps& caps) {
+void GrProcessorSet::Analysis::init(const GrProcessorAnalysisColor& colorInput,
+ const GrProcessorAnalysisCoverage coverageInput,
+ const GrProcessorSet& processors,
+ const GrAppliedClip* appliedClip,
+ const GrCaps& caps) {
const GrFragmentProcessor* clipFP =
appliedClip ? appliedClip->clipCoverageFragmentProcessor() : nullptr;
this->internalInit(colorInput, coverageInput, processors, clipFP, caps);
fIsInitializedWithProcessorSet = true;
}
-GrProcessorSet::FragmentProcessorAnalysis::FragmentProcessorAnalysis(
- const GrPipelineAnalysisColor& colorInput,
- const GrPipelineAnalysisCoverage coverageInput,
- const GrXPFactory* factory,
- const GrCaps& caps)
- : FragmentProcessorAnalysis() {
+GrProcessorSet::Analysis::Analysis(const GrProcessorAnalysisColor& colorInput,
+ const GrProcessorAnalysisCoverage coverageInput,
+ const GrXPFactory* factory,
+ const GrCaps& caps)
+ : Analysis() {
GrPaint paint;
paint.setXPFactory(factory);
this->internalInit(colorInput, coverageInput, GrProcessorSet(std::move(paint)), nullptr, caps);
}
void GrProcessorSet::analyzeAndEliminateFragmentProcessors(
- FragmentProcessorAnalysis* analysis,
- const GrPipelineAnalysisColor& colorInput,
- const GrPipelineAnalysisCoverage coverageInput,
+ Analysis* analysis,
+ const GrProcessorAnalysisColor& colorInput,
+ const GrProcessorAnalysisCoverage coverageInput,
const GrAppliedClip* clip,
const GrCaps& caps) {
analysis->init(colorInput, coverageInput, *this, clip, caps);
diff --git a/src/gpu/GrProcessorSet.h b/src/gpu/GrProcessorSet.h
index 4f9a1c3..f63369c 100644
--- a/src/gpu/GrProcessorSet.h
+++ b/src/gpu/GrProcessorSet.h
@@ -10,7 +10,7 @@
#include "GrFragmentProcessor.h"
#include "GrPaint.h"
-#include "GrPipelineAnalysis.h"
+#include "GrProcessorAnalysis.h"
#include "SkTemplates.h"
class GrAppliedClip;
@@ -58,40 +58,40 @@
bool operator!=(const GrProcessorSet& that) const { return !(*this == that); }
/**
- * This is used to track analysis of color and coverage values through the fragment processors.
+ * This is used to track analysis of color and coverage values through the processors.
*/
- class FragmentProcessorAnalysis {
+ class Analysis {
public:
/**
- * This constructor allows an op to record its initial color in a FragmentProcessorAnalysis
- * member and then run analysis later when the analysis inputs are available. If the
- * analysis produces color fragment processor elimination then the input color is replaced
- * by the expected input to the first non-eliminated processor. Otherwise, the original
- * input color is preserved. The only reason to use this is to save space on the op by not
- * separately storing the initial color.
+ * This constructor allows an op to record its initial color in an Analysis member and then
+ * then run analysis later when the analysis inputs are available. If the analysis produces
+ * color fragment processor elimination then the input color is replaced by the expected
+ * input to the first non-eliminated processor. Otherwise, the original input color is
+ * preserved. The only reason to use this is to save space on the op by not separately
+ * storing the initial color.
*/
- explicit FragmentProcessorAnalysis(GrColor initialColor) : FragmentProcessorAnalysis() {
+ explicit Analysis(GrColor initialColor) : Analysis() {
fInputColor = initialColor;
fValidInputColor = true;
}
- FragmentProcessorAnalysis()
+ Analysis()
: fIsInitializedWithProcessorSet(false)
, fCompatibleWithCoverageAsAlpha(true)
, fValidInputColor(false)
, fRequiresDstTexture(false)
, fCanCombineOverlappedStencilAndCover(true)
, fIgnoresInputColor(false)
- , fOutputCoverageType(static_cast<unsigned>(GrPipelineAnalysisCoverage::kNone))
+ , fOutputCoverageType(static_cast<unsigned>(GrProcessorAnalysisCoverage::kNone))
, fOutputColorType(static_cast<unsigned>(ColorType::kUnknown))
, fInitialColorProcessorsToEliminate(0) {}
// This version is used by a unit test that assumes no clip and no fragment processors.
- FragmentProcessorAnalysis(const GrPipelineAnalysisColor&, GrPipelineAnalysisCoverage,
- const GrXPFactory*, const GrCaps&);
+ Analysis(const GrProcessorAnalysisColor&, GrProcessorAnalysisCoverage, const GrXPFactory*,
+ const GrCaps&);
- void init(const GrPipelineAnalysisColor&, GrPipelineAnalysisCoverage, const GrProcessorSet&,
- const GrAppliedClip*, const GrCaps&);
+ void init(const GrProcessorAnalysisColor&, GrProcessorAnalysisCoverage,
+ const GrProcessorSet&, const GrAppliedClip*, const GrCaps&);
bool isInitializedWithProcessorSet() const { return fIsInitializedWithProcessorSet; }
@@ -128,20 +128,20 @@
}
bool isCompatibleWithCoverageAsAlpha() const { return fCompatibleWithCoverageAsAlpha; }
bool isInputColorIgnored() const { return fIgnoresInputColor; }
- GrPipelineAnalysisCoverage outputCoverage() const {
- return static_cast<GrPipelineAnalysisCoverage>(fOutputCoverageType);
+ GrProcessorAnalysisCoverage outputCoverage() const {
+ return static_cast<GrProcessorAnalysisCoverage>(fOutputCoverageType);
}
- GrPipelineAnalysisColor outputColor() const {
+ GrProcessorAnalysisColor outputColor() const {
switch (this->outputColorType()) {
case ColorType::kConstant:
return fKnownOutputColor;
case ColorType::kOpaque:
- return GrPipelineAnalysisColor::Opaque::kYes;
+ return GrProcessorAnalysisColor::Opaque::kYes;
case ColorType::kUnknown:
- return GrPipelineAnalysisColor::Opaque::kNo;
+ return GrProcessorAnalysisColor::Opaque::kNo;
}
SkFAIL("Unexpected color type");
- return GrPipelineAnalysisColor::Opaque::kNo;
+ return GrProcessorAnalysisColor::Opaque::kNo;
}
private:
@@ -149,7 +149,7 @@
ColorType outputColorType() const { return static_cast<ColorType>(fOutputColorType); }
- void internalInit(const GrPipelineAnalysisColor&, const GrPipelineAnalysisCoverage,
+ void internalInit(const GrProcessorAnalysisColor&, const GrProcessorAnalysisCoverage,
const GrProcessorSet&, const GrFragmentProcessor* clipFP, const GrCaps&);
// MSVS 2015 won't pack a bool with an unsigned.
@@ -174,15 +174,15 @@
friend class GrProcessorSet;
};
- GR_STATIC_ASSERT(sizeof(FragmentProcessorAnalysis) == 2 * sizeof(GrColor) + sizeof(uint32_t));
+ GR_STATIC_ASSERT(sizeof(Analysis) == 2 * sizeof(GrColor) + sizeof(uint32_t));
- void analyzeAndEliminateFragmentProcessors(FragmentProcessorAnalysis*,
- const GrPipelineAnalysisColor& colorInput,
- const GrPipelineAnalysisCoverage coverageInput,
+ void analyzeAndEliminateFragmentProcessors(Analysis*,
+ const GrProcessorAnalysisColor& colorInput,
+ const GrProcessorAnalysisCoverage coverageInput,
const GrAppliedClip*, const GrCaps&);
private:
- // This absurdly large limit allows FragmentProcessorAnalysis and this to pack fields together.
+ // This absurdly large limit allows Analysis and this to pack fields together.
static constexpr int kMaxColorProcessors = UINT8_MAX;
enum Flags : uint16_t {
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 1341328..352cac9 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -1724,7 +1724,7 @@
}
}
- GrProcessorSet::FragmentProcessorAnalysis analysis;
+ GrProcessorSet::Analysis analysis;
op->analyzeProcessors(&analysis, pipelineBuilder.processors(), &appliedClip, *this->caps());
GrPipeline::InitArgs args;
diff --git a/src/gpu/GrXferProcessor.cpp b/src/gpu/GrXferProcessor.cpp
index fb90051..1ce258c 100644
--- a/src/gpu/GrXferProcessor.cpp
+++ b/src/gpu/GrXferProcessor.cpp
@@ -172,8 +172,8 @@
GrXPFactory::AnalysisProperties GrXPFactory::GetAnalysisProperties(
const GrXPFactory* factory,
- const GrPipelineAnalysisColor& color,
- const GrPipelineAnalysisCoverage& coverage,
+ const GrProcessorAnalysisColor& color,
+ const GrProcessorAnalysisCoverage& coverage,
const GrCaps& caps) {
AnalysisProperties result;
if (factory) {
@@ -189,8 +189,8 @@
return result;
}
-GrXferProcessor* GrXPFactory::createXferProcessor(const GrPipelineAnalysisColor& color,
- GrPipelineAnalysisCoverage coverage,
+GrXferProcessor* GrXPFactory::createXferProcessor(const GrProcessorAnalysisColor& color,
+ GrProcessorAnalysisCoverage coverage,
bool hasMixedSamples,
const DstTexture* dstTexture,
const GrCaps& caps) const {
diff --git a/src/gpu/GrXferProcessor.h b/src/gpu/GrXferProcessor.h
index 2033aea..622f760 100644
--- a/src/gpu/GrXferProcessor.h
+++ b/src/gpu/GrXferProcessor.h
@@ -48,8 +48,6 @@
*/
class GrXferProcessor : public GrProcessor {
public:
- using FragmentProcessorAnalysis = GrProcessorSet::FragmentProcessorAnalysis;
-
/**
* A texture that contains the dst pixel values and an integer coord offset from device space
* to the space of the texture. Depending on GPU capabilities a DstTexture may be used by a
@@ -264,12 +262,10 @@
#endif
class GrXPFactory {
public:
- using FragmentProcessorAnalysis = GrProcessorSet::FragmentProcessorAnalysis;
-
typedef GrXferProcessor::DstTexture DstTexture;
- GrXferProcessor* createXferProcessor(const GrPipelineAnalysisColor&,
- GrPipelineAnalysisCoverage,
+ GrXferProcessor* createXferProcessor(const GrProcessorAnalysisColor&,
+ GrProcessorAnalysisCoverage,
bool hasMixedSamples,
const DstTexture*,
const GrCaps& caps) const;
@@ -285,8 +281,8 @@
GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(AnalysisProperties);
static AnalysisProperties GetAnalysisProperties(const GrXPFactory*,
- const GrPipelineAnalysisColor&,
- const GrPipelineAnalysisCoverage&,
+ const GrProcessorAnalysisColor&,
+ const GrProcessorAnalysisCoverage&,
const GrCaps&);
protected:
@@ -294,8 +290,8 @@
private:
virtual GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
- const GrPipelineAnalysisColor&,
- GrPipelineAnalysisCoverage,
+ const GrProcessorAnalysisColor&,
+ GrProcessorAnalysisCoverage,
bool hasMixedSamples,
const DstTexture*) const = 0;
@@ -303,8 +299,8 @@
* Subclass analysis implementation. This should not return kNeedsDstInTexture as that will be
* inferred by the base class based on kReadsDstInShader and the caps.
*/
- virtual AnalysisProperties analysisProperties(const GrPipelineAnalysisColor&,
- const GrPipelineAnalysisCoverage&,
+ virtual AnalysisProperties analysisProperties(const GrProcessorAnalysisColor&,
+ const GrProcessorAnalysisCoverage&,
const GrCaps&) const = 0;
};
#if defined(__GNUC__) || defined(__clang)
diff --git a/src/gpu/effects/GrCoverageSetOpXP.cpp b/src/gpu/effects/GrCoverageSetOpXP.cpp
index 4d514fb..1319c1f 100644
--- a/src/gpu/effects/GrCoverageSetOpXP.cpp
+++ b/src/gpu/effects/GrCoverageSetOpXP.cpp
@@ -219,8 +219,8 @@
}
GrXferProcessor* GrCoverageSetOpXPFactory::onCreateXferProcessor(const GrCaps& caps,
- const GrPipelineAnalysisColor&,
- GrPipelineAnalysisCoverage,
+ const GrProcessorAnalysisColor&,
+ GrProcessorAnalysisCoverage,
bool hasMixedSamples,
const DstTexture*) const {
// We don't support inverting coverage with mixed samples. We don't expect to ever want this in
diff --git a/src/gpu/effects/GrCoverageSetOpXP.h b/src/gpu/effects/GrCoverageSetOpXP.h
index 16ccf20..2e1feed 100644
--- a/src/gpu/effects/GrCoverageSetOpXP.h
+++ b/src/gpu/effects/GrCoverageSetOpXP.h
@@ -30,12 +30,12 @@
private:
constexpr GrCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCoverage);
- GrXferProcessor* onCreateXferProcessor(const GrCaps&, const GrPipelineAnalysisColor&,
- GrPipelineAnalysisCoverage, bool hasMixedSamples,
+ GrXferProcessor* onCreateXferProcessor(const GrCaps&, const GrProcessorAnalysisColor&,
+ GrProcessorAnalysisCoverage, bool hasMixedSamples,
const DstTexture*) const override;
- AnalysisProperties analysisProperties(const GrPipelineAnalysisColor&,
- const GrPipelineAnalysisCoverage&,
+ AnalysisProperties analysisProperties(const GrProcessorAnalysisColor&,
+ const GrProcessorAnalysisCoverage&,
const GrCaps&) const override {
return AnalysisProperties::kIgnoresInputColor;
}
diff --git a/src/gpu/effects/GrCustomXfermode.cpp b/src/gpu/effects/GrCustomXfermode.cpp
index 04718d4..5ac31d8 100644
--- a/src/gpu/effects/GrCustomXfermode.cpp
+++ b/src/gpu/effects/GrCustomXfermode.cpp
@@ -52,12 +52,12 @@
#undef EQ_OFFSET
}
-static bool can_use_hw_blend_equation(GrBlendEquation equation, GrPipelineAnalysisCoverage coverage,
- const GrCaps& caps) {
+static bool can_use_hw_blend_equation(GrBlendEquation equation,
+ GrProcessorAnalysisCoverage coverage, const GrCaps& caps) {
if (!caps.advancedBlendEquationSupport()) {
return false;
}
- if (GrPipelineAnalysisCoverage::kLCD == coverage) {
+ if (GrProcessorAnalysisCoverage::kLCD == coverage) {
return false; // LCD coverage must be applied after the blend equation.
}
if (caps.canUseAdvancedBlendEquation(equation)) {
@@ -213,12 +213,12 @@
: fMode(mode), fHWBlendEquation(hw_blend_equation(mode)) {}
private:
- GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrPipelineAnalysisColor&,
- GrPipelineAnalysisCoverage, bool hasMixedSamples,
+ GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrProcessorAnalysisColor&,
+ GrProcessorAnalysisCoverage, bool hasMixedSamples,
const DstTexture*) const override;
- AnalysisProperties analysisProperties(const GrPipelineAnalysisColor&,
- const GrPipelineAnalysisCoverage&,
+ AnalysisProperties analysisProperties(const GrProcessorAnalysisColor&,
+ const GrProcessorAnalysisCoverage&,
const GrCaps&) const override;
GR_DECLARE_XP_FACTORY_TEST;
@@ -233,8 +233,8 @@
#endif
GrXferProcessor* CustomXPFactory::onCreateXferProcessor(const GrCaps& caps,
- const GrPipelineAnalysisColor&,
- GrPipelineAnalysisCoverage coverage,
+ const GrProcessorAnalysisColor&,
+ GrProcessorAnalysisCoverage coverage,
bool hasMixedSamples,
const DstTexture* dstTexture) const {
SkASSERT(GrCustomXfermode::IsSupportedMode(fMode));
@@ -246,7 +246,7 @@
}
GrXPFactory::AnalysisProperties CustomXPFactory::analysisProperties(
- const GrPipelineAnalysisColor&, const GrPipelineAnalysisCoverage& coverage,
+ const GrProcessorAnalysisColor&, const GrProcessorAnalysisCoverage& coverage,
const GrCaps& caps) const {
/*
The general SVG blend equation is defined in the spec as follows:
diff --git a/src/gpu/effects/GrDisableColorXP.cpp b/src/gpu/effects/GrDisableColorXP.cpp
index 71a50eb..4780b28 100644
--- a/src/gpu/effects/GrDisableColorXP.cpp
+++ b/src/gpu/effects/GrDisableColorXP.cpp
@@ -82,8 +82,8 @@
///////////////////////////////////////////////////////////////////////////////
GrXferProcessor* GrDisableColorXPFactory::onCreateXferProcessor(const GrCaps& caps,
- const GrPipelineAnalysisColor&,
- GrPipelineAnalysisCoverage,
+ const GrProcessorAnalysisColor&,
+ GrProcessorAnalysisCoverage,
bool hasMixedSamples,
const DstTexture* dst) const {
return DisableColorXP::Create();
diff --git a/src/gpu/effects/GrDisableColorXP.h b/src/gpu/effects/GrDisableColorXP.h
index 85ddb61..ccd85c7 100644
--- a/src/gpu/effects/GrDisableColorXP.h
+++ b/src/gpu/effects/GrDisableColorXP.h
@@ -24,15 +24,15 @@
private:
constexpr GrDisableColorXPFactory() {}
- AnalysisProperties analysisProperties(const GrPipelineAnalysisColor&,
- const GrPipelineAnalysisCoverage&,
+ AnalysisProperties analysisProperties(const GrProcessorAnalysisColor&,
+ const GrProcessorAnalysisCoverage&,
const GrCaps&) const override {
return AnalysisProperties::kCompatibleWithAlphaAsCoverage |
AnalysisProperties::kIgnoresInputColor;
}
- GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrPipelineAnalysisColor&,
- GrPipelineAnalysisCoverage, bool hasMixedSamples,
+ GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrProcessorAnalysisColor&,
+ GrProcessorAnalysisCoverage, bool hasMixedSamples,
const DstTexture* dstTexture) const override;
GR_DECLARE_XP_FACTORY_TEST;
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
index f2b3d7c..646f942 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
@@ -10,8 +10,8 @@
#include "GrBlend.h"
#include "GrCaps.h"
#include "GrPipeline.h"
-#include "GrPipelineAnalysis.h"
#include "GrProcessor.h"
+#include "GrProcessorAnalysis.h"
#include "GrTypes.h"
#include "GrXferProcessor.h"
#include "glsl/GrGLSLBlend.h"
@@ -521,7 +521,8 @@
class PDLCDXferProcessor : public GrXferProcessor {
public:
- static GrXferProcessor* Create(SkBlendMode xfermode, const GrPipelineAnalysisColor& inputColor);
+ static GrXferProcessor* Create(SkBlendMode xfermode,
+ const GrProcessorAnalysisColor& inputColor);
~PDLCDXferProcessor() override;
@@ -603,7 +604,7 @@
}
GrXferProcessor* PDLCDXferProcessor::Create(SkBlendMode xfermode,
- const GrPipelineAnalysisColor& color) {
+ const GrProcessorAnalysisColor& color) {
if (SkBlendMode::kSrcOver != xfermode) {
return nullptr;
}
@@ -699,12 +700,12 @@
}
GrXferProcessor* GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps,
- const GrPipelineAnalysisColor& color,
- GrPipelineAnalysisCoverage coverage,
+ const GrProcessorAnalysisColor& color,
+ GrProcessorAnalysisCoverage coverage,
bool hasMixedSamples,
const DstTexture* dstTexture) const {
BlendFormula blendFormula;
- if (coverage == GrPipelineAnalysisCoverage::kLCD) {
+ if (coverage == GrProcessorAnalysisCoverage::kLCD) {
if (SkBlendMode::kSrcOver == fBlendMode && color.isConstant() &&
!caps.shaderCaps()->dualSourceBlendingSupport() &&
!caps.shaderCaps()->dstReadInShaderSupport()) {
@@ -716,7 +717,7 @@
blendFormula = get_lcd_blend_formula(fBlendMode);
} else {
blendFormula =
- get_blend_formula(color.isOpaque(), GrPipelineAnalysisCoverage::kNone != coverage,
+ get_blend_formula(color.isOpaque(), GrProcessorAnalysisCoverage::kNone != coverage,
hasMixedSamples, fBlendMode);
}
@@ -729,11 +730,11 @@
}
static inline GrXPFactory::AnalysisProperties analysis_properties(
- const GrPipelineAnalysisColor& color, const GrPipelineAnalysisCoverage& coverage,
+ const GrProcessorAnalysisColor& color, const GrProcessorAnalysisCoverage& coverage,
const GrCaps& caps, SkBlendMode mode) {
using AnalysisProperties = GrXPFactory::AnalysisProperties;
AnalysisProperties props = AnalysisProperties::kNone;
- bool hasCoverage = GrPipelineAnalysisCoverage::kNone != coverage;
+ bool hasCoverage = GrProcessorAnalysisCoverage::kNone != coverage;
auto formula = gBlendTable[color.isOpaque()][hasCoverage][(int)mode];
if (formula.canTweakAlphaForCoverage()) {
props |= AnalysisProperties::kCompatibleWithAlphaAsCoverage;
@@ -744,7 +745,7 @@
// affect the formula used. However, we don't expect to have mixed samples without dual
// source blending.
SkASSERT(!caps.usesMixedSamples());
- if (GrPipelineAnalysisCoverage::kLCD == coverage) {
+ if (GrProcessorAnalysisCoverage::kLCD == coverage) {
// Check for special case of srcover with a known color which can be done using the
// blend constant.
if (SkBlendMode::kSrcOver == mode && color.isConstant()) {
@@ -771,8 +772,8 @@
}
GrXPFactory::AnalysisProperties GrPorterDuffXPFactory::analysisProperties(
- const GrPipelineAnalysisColor& color,
- const GrPipelineAnalysisCoverage& coverage,
+ const GrProcessorAnalysisColor& color,
+ const GrProcessorAnalysisCoverage& coverage,
const GrCaps& caps) const {
return analysis_properties(color, coverage, caps, fBlendMode);
}
@@ -810,15 +811,15 @@
GrXferProcessor* GrPorterDuffXPFactory::CreateSrcOverXferProcessor(
const GrCaps& caps,
- const GrPipelineAnalysisColor& color,
- GrPipelineAnalysisCoverage coverage,
+ const GrProcessorAnalysisColor& color,
+ GrProcessorAnalysisCoverage coverage,
bool hasMixedSamples,
const GrXferProcessor::DstTexture* dstTexture) {
// We want to not make an xfer processor if possible. Thus for the simple case where we are not
// doing lcd blending we will just use our global SimpleSrcOverXP. This slightly differs from
// the general case where we convert a src-over blend that has solid coverage and an opaque
// color to src-mode, which allows disabling of blending.
- if (coverage != GrPipelineAnalysisCoverage::kLCD) {
+ if (coverage != GrProcessorAnalysisCoverage::kLCD) {
// We return nullptr here, which our caller interprets as meaning "use SimpleSrcOverXP".
// We don't simply return the address of that XP here because our caller would have to unref
// it and since it is a global object and GrProgramElement's ref-cnting system is not thread
@@ -851,8 +852,8 @@
}
GrXPFactory::AnalysisProperties GrPorterDuffXPFactory::SrcOverAnalysisProperties(
- const GrPipelineAnalysisColor& color,
- const GrPipelineAnalysisCoverage& coverage,
+ const GrProcessorAnalysisColor& color,
+ const GrProcessorAnalysisCoverage& coverage,
const GrCaps& caps) {
return analysis_properties(color, coverage, caps, SkBlendMode::kSrcOver);
}
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.h b/src/gpu/effects/GrPorterDuffXferProcessor.h
index 0d671a3..d42146a 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.h
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.h
@@ -24,8 +24,8 @@
/** Because src-over is so common we special case it for performance reasons. If this returns
null then the SimpleSrcOverXP() below should be used. */
static GrXferProcessor* CreateSrcOverXferProcessor(const GrCaps& caps,
- const GrPipelineAnalysisColor& color,
- GrPipelineAnalysisCoverage coverage,
+ const GrProcessorAnalysisColor& color,
+ GrProcessorAnalysisCoverage coverage,
bool hasMixedSamples,
const GrXferProcessor::DstTexture*);
@@ -36,19 +36,19 @@
by reference because it is global and its ref-cnting methods are not thread safe. */
static const GrXferProcessor& SimpleSrcOverXP();
- static AnalysisProperties SrcOverAnalysisProperties(const GrPipelineAnalysisColor&,
- const GrPipelineAnalysisCoverage&,
+ static AnalysisProperties SrcOverAnalysisProperties(const GrProcessorAnalysisColor&,
+ const GrProcessorAnalysisCoverage&,
const GrCaps&);
private:
constexpr GrPorterDuffXPFactory(SkBlendMode);
- GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrPipelineAnalysisColor&,
- GrPipelineAnalysisCoverage, bool hasMixedSamples,
+ GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, const GrProcessorAnalysisColor&,
+ GrProcessorAnalysisCoverage, bool hasMixedSamples,
const DstTexture*) const override;
- AnalysisProperties analysisProperties(const GrPipelineAnalysisColor&,
- const GrPipelineAnalysisCoverage&,
+ AnalysisProperties analysisProperties(const GrProcessorAnalysisColor&,
+ const GrProcessorAnalysisCoverage&,
const GrCaps&) const override;
GR_DECLARE_XP_FACTORY_TEST;
diff --git a/src/gpu/instanced/InstancedRendering.cpp b/src/gpu/instanced/InstancedRendering.cpp
index f6ea628..ad61eb6 100644
--- a/src/gpu/instanced/InstancedRendering.cpp
+++ b/src/gpu/instanced/InstancedRendering.cpp
@@ -331,13 +331,13 @@
}
bool InstancedRendering::Op::xpRequiresDstTexture(const GrCaps& caps, const GrAppliedClip* clip) {
- GrProcessorSet::FragmentProcessorAnalysis analysis;
- GrPipelineAnalysisCoverage coverageInput;
+ GrProcessorSet::Analysis analysis;
+ GrProcessorAnalysisCoverage coverageInput;
if (GrAAType::kCoverage == fInfo.aaType() ||
(GrAAType::kNone == fInfo.aaType() && !fInfo.isSimpleRects() && fInfo.fCannotDiscard)) {
- coverageInput = GrPipelineAnalysisCoverage::kSingleChannel;
+ coverageInput = GrProcessorAnalysisCoverage::kSingleChannel;
} else {
- coverageInput = GrPipelineAnalysisCoverage::kNone;
+ coverageInput = GrProcessorAnalysisCoverage::kNone;
}
fProcessors.analyzeAndEliminateFragmentProcessors(&analysis, this->getSingleInstance().fColor,
coverageInput, clip, caps);
@@ -407,7 +407,7 @@
this->joinBounds(*that);
fInfo = combinedInfo;
fPixelLoad += that->fPixelLoad;
- fAnalysisColor = GrPipelineAnalysisColor::Combine(fAnalysisColor, that->fAnalysisColor);
+ fAnalysisColor = GrProcessorAnalysisColor::Combine(fAnalysisColor, that->fAnalysisColor);
// Adopt the other op's draws.
fNumDraws += that->fNumDraws;
fNumChangesInGeometry += that->fNumChangesInGeometry;
@@ -465,13 +465,13 @@
state->gpu()->handleDirtyContext();
const GrAppliedClip* clip = state->drawOpArgs().fAppliedClip;
- GrPipelineAnalysisCoverage coverage;
+ GrProcessorAnalysisCoverage coverage;
if (GrAAType::kCoverage == fInfo.aaType() ||
(clip && clip->clipCoverageFragmentProcessor()) ||
(GrAAType::kNone == fInfo.aaType() && !fInfo.isSimpleRects() && fInfo.fCannotDiscard)) {
- coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ coverage = GrProcessorAnalysisCoverage::kSingleChannel;
} else {
- coverage = GrPipelineAnalysisCoverage::kNone;
+ coverage = GrProcessorAnalysisCoverage::kNone;
}
GrPipeline pipeline;
diff --git a/src/gpu/instanced/InstancedRendering.h b/src/gpu/instanced/InstancedRendering.h
index 2fa433f..caff08f 100644
--- a/src/gpu/instanced/InstancedRendering.h
+++ b/src/gpu/instanced/InstancedRendering.h
@@ -151,7 +151,7 @@
OpInfo fInfo;
SkScalar fPixelLoad;
GrProcessorSet fProcessors;
- GrPipelineAnalysisColor fAnalysisColor;
+ GrProcessorAnalysisColor fAnalysisColor;
SkSTArray<5, ParamsTexel, true> fParams;
bool fIsTracked;
int fNumDraws;
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 09d8267..3b0fd69 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -747,10 +747,10 @@
this->setTransformedBounds(path.getBounds(), viewMatrix, HasAABloat::kYes, IsZeroArea::kNo);
}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrAAFillRectOp.cpp b/src/gpu/ops/GrAAFillRectOp.cpp
index 9919129..b48ec0e 100644
--- a/src/gpu/ops/GrAAFillRectOp.cpp
+++ b/src/gpu/ops/GrAAFillRectOp.cpp
@@ -203,10 +203,10 @@
}
private:
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(this->first()->color());
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void onPrepareDraws(Target* target) const override {
diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
index a243228..9e1ac83c 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -710,10 +710,10 @@
IsZeroArea::kYes);
}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
index a62a41c..b1f1f98 100644
--- a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
@@ -172,10 +172,10 @@
this->setTransformedBounds(bounds, viewMatrix, HasAABloat::kYes, IsZeroArea::kNo);
}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fPaths[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrAAStrokeRectOp.cpp b/src/gpu/ops/GrAAStrokeRectOp.cpp
index 5866b0d..ce0cef6 100644
--- a/src/gpu/ops/GrAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrAAStrokeRectOp.cpp
@@ -174,10 +174,10 @@
private:
AAStrokeRectOp() : INHERITED(ClassID()) {}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fRects[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations&) override;
void onPrepareDraws(Target*) const override;
diff --git a/src/gpu/ops/GrAnalyticRectOp.cpp b/src/gpu/ops/GrAnalyticRectOp.cpp
index 6184144..85da29c 100644
--- a/src/gpu/ops/GrAnalyticRectOp.cpp
+++ b/src/gpu/ops/GrAnalyticRectOp.cpp
@@ -269,10 +269,10 @@
}
private:
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fGeoData[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrAtlasTextOp.cpp b/src/gpu/ops/GrAtlasTextOp.cpp
index 903382a..bf2745b 100644
--- a/src/gpu/ops/GrAtlasTextOp.cpp
+++ b/src/gpu/ops/GrAtlasTextOp.cpp
@@ -46,8 +46,8 @@
return str;
}
-void GrAtlasTextOp::getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const {
+void GrAtlasTextOp::getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const {
if (kColorBitmapMask_MaskType == fMaskType) {
color->setToUnknown();
} else {
@@ -56,14 +56,14 @@
switch (fMaskType) {
case kGrayscaleDistanceField_MaskType:
case kGrayscaleCoverageMask_MaskType:
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
break;
case kLCDCoverageMask_MaskType:
case kLCDDistanceField_MaskType:
- *coverage = GrPipelineAnalysisCoverage::kLCD;
+ *coverage = GrProcessorAnalysisCoverage::kLCD;
break;
case kColorBitmapMask_MaskType:
- *coverage = GrPipelineAnalysisCoverage::kNone;
+ *coverage = GrProcessorAnalysisCoverage::kNone;
break;
}
}
diff --git a/src/gpu/ops/GrAtlasTextOp.h b/src/gpu/ops/GrAtlasTextOp.h
index 9dc5631..452cfbd 100644
--- a/src/gpu/ops/GrAtlasTextOp.h
+++ b/src/gpu/ops/GrAtlasTextOp.h
@@ -99,8 +99,8 @@
SkString dumpInfo() const override;
private:
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor*,
- GrPipelineAnalysisCoverage*) const override;
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor*,
+ GrProcessorAnalysisCoverage*) const override;
void applyPipelineOptimizations(const PipelineOptimizations&) override;
struct FlushInfo {
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index e623007..3e8c07e 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -296,10 +296,10 @@
this->setTransformedBounds(bounds, combinedMatrix, aaBloat, zeroArea);
}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrDefaultPathRenderer.cpp b/src/gpu/ops/GrDefaultPathRenderer.cpp
index 79ad484..f33fc66 100644
--- a/src/gpu/ops/GrDefaultPathRenderer.cpp
+++ b/src/gpu/ops/GrDefaultPathRenderer.cpp
@@ -132,11 +132,11 @@
isHairline ? IsZeroArea::kYes : IsZeroArea::kNo);
}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fColor);
- *coverage = this->coverage() == 0xff ? GrPipelineAnalysisCoverage::kNone
- : GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = this->coverage() == 0xff ? GrProcessorAnalysisCoverage::kNone
+ : GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrDrawAtlasOp.h b/src/gpu/ops/GrDrawAtlasOp.h
index 1094db0..7d60974 100644
--- a/src/gpu/ops/GrDrawAtlasOp.h
+++ b/src/gpu/ops/GrDrawAtlasOp.h
@@ -39,14 +39,14 @@
GrDrawAtlasOp(GrColor color, const SkMatrix& viewMatrix, int spriteCount,
const SkRSXform* xforms, const SkRect* rects, const SkColor* colors);
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
if (this->hasColors()) {
color->setToUnknown();
} else {
color->setToConstant(fGeoData[0].fColor);
}
- *coverage = GrPipelineAnalysisCoverage::kNone;
+ *coverage = GrProcessorAnalysisCoverage::kNone;
}
void onPrepareDraws(Target*) const override;
diff --git a/src/gpu/ops/GrDrawPathOp.cpp b/src/gpu/ops/GrDrawPathOp.cpp
index 8bc1f83..81a2de0 100644
--- a/src/gpu/ops/GrDrawPathOp.cpp
+++ b/src/gpu/ops/GrDrawPathOp.cpp
@@ -38,7 +38,7 @@
0xffff>()
};
GrPipeline::InitArgs args;
- auto analysis = this->fragmentProcessorAnalysis();
+ auto analysis = this->processorAnalysis();
args.fProcessors = &this->processors();
args.fFlags = GrAA::kYes == fAA ? GrPipeline::kHWAntialias_Flag : 0;
args.fUserStencil = &kCoverPass;
@@ -146,7 +146,7 @@
GrPathRendering::kWinding_FillType != that->fillType()) {
return false;
}
- if (!this->fragmentProcessorAnalysis().canCombineOverlappedStencilAndCover()) {
+ if (!this->processorAnalysis().canCombineOverlappedStencilAndCover()) {
return false;
}
fTotalPathCount += that->fTotalPathCount;
diff --git a/src/gpu/ops/GrDrawPathOp.h b/src/gpu/ops/GrDrawPathOp.h
index 78ed035..0631adc 100644
--- a/src/gpu/ops/GrDrawPathOp.h
+++ b/src/gpu/ops/GrDrawPathOp.h
@@ -29,7 +29,7 @@
return FixedFunctionFlags::kUsesHWAA | FixedFunctionFlags::kUsesStencil;
}
bool xpRequiresDstTexture(const GrCaps& caps, const GrAppliedClip* clip) override {
- return this->doFragmentProcessorAnalysis(caps, clip).requiresDstTexture();
+ return this->doProcessorAnalysis(caps, clip).requiresDstTexture();
}
void wasRecorded() override { fProcessorSet.makePendingExecution(); }
@@ -40,13 +40,13 @@
GrPathRendering::FillType fillType() const { return fFillType; }
const GrProcessorSet& processors() const { return fProcessorSet; }
void initPipeline(const GrOpFlushState&, GrPipeline*);
- const GrProcessorSet::FragmentProcessorAnalysis& doFragmentProcessorAnalysis(
- const GrCaps& caps, const GrAppliedClip* clip) {
+ const GrProcessorSet::Analysis& doProcessorAnalysis(const GrCaps& caps,
+ const GrAppliedClip* clip) {
fProcessorSet.analyzeAndEliminateFragmentProcessors(
- &fAnalysis, fAnalysis.inputColor(), GrPipelineAnalysisCoverage::kNone, clip, caps);
+ &fAnalysis, fAnalysis.inputColor(), GrProcessorAnalysisCoverage::kNone, clip, caps);
return fAnalysis;
}
- const GrProcessorSet::FragmentProcessorAnalysis& fragmentProcessorAnalysis() const {
+ const GrProcessorSet::Analysis& processorAnalysis() const {
SkASSERT(fAnalysis.isInitializedWithProcessorSet());
return fAnalysis;
}
@@ -56,7 +56,7 @@
SkMatrix fViewMatrix;
GrProcessorSet fProcessorSet;
- GrProcessorSet::FragmentProcessorAnalysis fAnalysis;
+ GrProcessorSet::Analysis fAnalysis;
GrPathRendering::FillType fFillType;
GrAA fAA;
diff --git a/src/gpu/ops/GrDrawVerticesOp.cpp b/src/gpu/ops/GrDrawVerticesOp.cpp
index 6751009..1af49d2 100644
--- a/src/gpu/ops/GrDrawVerticesOp.cpp
+++ b/src/gpu/ops/GrDrawVerticesOp.cpp
@@ -74,14 +74,14 @@
this->setTransformedBounds(mesh.fVertices->bounds(), viewMatrix, HasAABloat::kNo, zeroArea);
}
-void GrDrawVerticesOp::getFragmentProcessorAnalysisInputs(
- GrPipelineAnalysisColor* color, GrPipelineAnalysisCoverage* coverage) const {
+void GrDrawVerticesOp::getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const {
if (this->requiresPerVertexColors()) {
color->setToUnknown();
} else {
color->setToConstant(fMeshes[0].fColor);
}
- *coverage = GrPipelineAnalysisCoverage::kNone;
+ *coverage = GrProcessorAnalysisCoverage::kNone;
}
void GrDrawVerticesOp::applyPipelineOptimizations(const PipelineOptimizations& optimizations) {
diff --git a/src/gpu/ops/GrDrawVerticesOp.h b/src/gpu/ops/GrDrawVerticesOp.h
index 17e54b7..2c4d1c9 100644
--- a/src/gpu/ops/GrDrawVerticesOp.h
+++ b/src/gpu/ops/GrDrawVerticesOp.h
@@ -70,8 +70,8 @@
GrRenderTargetContext::ColorArrayType, const SkMatrix& viewMatrix,
uint32_t flags = 0);
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override;
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override;
void applyPipelineOptimizations(const PipelineOptimizations&) override;
void onPrepareDraws(Target*) const override;
diff --git a/src/gpu/ops/GrLatticeOp.cpp b/src/gpu/ops/GrLatticeOp.cpp
index 85ddd9d..6dce60e 100644
--- a/src/gpu/ops/GrLatticeOp.cpp
+++ b/src/gpu/ops/GrLatticeOp.cpp
@@ -61,10 +61,10 @@
}
private:
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToUnknown();
- *coverage = GrPipelineAnalysisCoverage::kNone;
+ *coverage = GrProcessorAnalysisCoverage::kNone;
}
void applyPipelineOptimizations(const PipelineOptimizations& analysioptimizations) override {
diff --git a/src/gpu/ops/GrMSAAPathRenderer.cpp b/src/gpu/ops/GrMSAAPathRenderer.cpp
index 9f20808..8cbe2a3 100644
--- a/src/gpu/ops/GrMSAAPathRenderer.cpp
+++ b/src/gpu/ops/GrMSAAPathRenderer.cpp
@@ -259,10 +259,10 @@
this->setBounds(devBounds, HasAABloat::kNo, IsZeroArea::kNo);
}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fPaths[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kNone;
+ *coverage = GrProcessorAnalysisCoverage::kNone;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrMeshDrawOp.h b/src/gpu/ops/GrMeshDrawOp.h
index 2632feb..a8da29a 100644
--- a/src/gpu/ops/GrMeshDrawOp.h
+++ b/src/gpu/ops/GrMeshDrawOp.h
@@ -29,13 +29,13 @@
* Performs analysis of the fragment processors in GrProcessorSet and GrAppliedClip using the
* initial color and coverage from this op's geometry processor.
*/
- void analyzeProcessors(GrProcessorSet::FragmentProcessorAnalysis* analysis,
+ void analyzeProcessors(GrProcessorSet::Analysis* analysis,
const GrProcessorSet& processors,
const GrAppliedClip* appliedClip,
const GrCaps& caps) const {
- GrPipelineAnalysisColor inputColor;
- GrPipelineAnalysisCoverage inputCoverage;
- this->getFragmentProcessorAnalysisInputs(&inputColor, &inputCoverage);
+ GrProcessorAnalysisColor inputColor;
+ GrProcessorAnalysisCoverage inputCoverage;
+ this->getProcessorAnalysisInputs(&inputColor, &inputCoverage);
analysis->init(inputColor, inputCoverage, processors, appliedClip, caps);
}
@@ -61,11 +61,11 @@
GrMeshDrawOp(uint32_t classID);
/**
* This is a legacy class only used by GrMeshDrawOp and will be removed. It presents some
- * aspects of GrProcessorSet::FragmentProcessorAnalysis to GrMeshDrawOp subclasses.
+ * aspects of GrProcessorSet::Analysis to GrMeshDrawOp subclasses.
*/
class PipelineOptimizations {
public:
- PipelineOptimizations(const GrProcessorSet::FragmentProcessorAnalysis& analysis) {
+ PipelineOptimizations(const GrProcessorSet::Analysis& analysis) {
fFlags = 0;
if (analysis.getInputColorOverrideAndColorProcessorEliminationCount(&fOverrideColor) >=
0) {
@@ -161,11 +161,11 @@
* Provides information about the GrPrimitiveProccesor color and coverage outputs which become
* inputs to the first color and coverage fragment processors.
*/
- virtual void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor*,
- GrPipelineAnalysisCoverage*) const = 0;
+ virtual void getProcessorAnalysisInputs(GrProcessorAnalysisColor*,
+ GrProcessorAnalysisCoverage*) const = 0;
/**
- * After GrPipeline analysis is complete this is called so that the op can use the analysis
+ * After processor analysis is complete this is called so that the op can use the analysis
* results when constructing its GrPrimitiveProcessor.
*/
virtual void applyPipelineOptimizations(const PipelineOptimizations&) = 0;
diff --git a/src/gpu/ops/GrNonAAFillRectOp.cpp b/src/gpu/ops/GrNonAAFillRectOp.cpp
index 66a8515..c522794 100644
--- a/src/gpu/ops/GrNonAAFillRectOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectOp.cpp
@@ -110,10 +110,10 @@
private:
NonAAFillRectOp() : INHERITED(ClassID()) {}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fRects[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kNone;
+ *coverage = GrProcessorAnalysisCoverage::kNone;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp b/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
index 9ccc743..a7c445c 100644
--- a/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
@@ -130,10 +130,10 @@
private:
NonAAFillRectPerspectiveOp() : INHERITED(ClassID()) {}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fRects[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kNone;
+ *coverage = GrProcessorAnalysisCoverage::kNone;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrNonAAStrokeRectOp.cpp b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
index 940afee..ffabad1 100644
--- a/src/gpu/ops/GrNonAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
@@ -102,10 +102,10 @@
private:
NonAAStrokeRectOp() : INHERITED(ClassID()) {}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fColor);
- *coverage = GrPipelineAnalysisCoverage::kNone;
+ *coverage = GrProcessorAnalysisCoverage::kNone;
}
void onPrepareDraws(Target* target) const override {
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index de4e4ea..5ede5e1 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -805,10 +805,10 @@
private:
CircleOp() : INHERITED(ClassID()) {}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fGeoData[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
@@ -1257,10 +1257,10 @@
private:
EllipseOp() : INHERITED(ClassID()) {}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fGeoData[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
@@ -1472,10 +1472,10 @@
private:
DIEllipseOp() : INHERITED(ClassID()) {}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fGeoData[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
@@ -1788,10 +1788,10 @@
}
private:
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fGeoData[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
@@ -2152,10 +2152,10 @@
private:
EllipticalRRectOp() : INHERITED(ClassID()) {}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fGeoData[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrRegionOp.cpp b/src/gpu/ops/GrRegionOp.cpp
index 88f96bf..ba153a6 100644
--- a/src/gpu/ops/GrRegionOp.cpp
+++ b/src/gpu/ops/GrRegionOp.cpp
@@ -77,10 +77,10 @@
}
private:
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fRegions[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kNone;
+ *coverage = GrProcessorAnalysisCoverage::kNone;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrShadowRRectOp.cpp b/src/gpu/ops/GrShadowRRectOp.cpp
index 56855a1..9b2bc82 100644
--- a/src/gpu/ops/GrShadowRRectOp.cpp
+++ b/src/gpu/ops/GrShadowRRectOp.cpp
@@ -142,10 +142,10 @@
private:
ShadowCircleOp() : INHERITED(ClassID()) {}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fCircles[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
@@ -563,10 +563,10 @@
}
private:
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fGeoData[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrSmallPathRenderer.cpp b/src/gpu/ops/GrSmallPathRenderer.cpp
index 408bcfe..ced9b4e 100644
--- a/src/gpu/ops/GrSmallPathRenderer.cpp
+++ b/src/gpu/ops/GrSmallPathRenderer.cpp
@@ -199,10 +199,10 @@
}
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fShapes[0].fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrTessellatingPathRenderer.cpp b/src/gpu/ops/GrTessellatingPathRenderer.cpp
index 96fe8ab..9f3b1d6e 100644
--- a/src/gpu/ops/GrTessellatingPathRenderer.cpp
+++ b/src/gpu/ops/GrTessellatingPathRenderer.cpp
@@ -180,10 +180,10 @@
}
private:
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {
diff --git a/src/gpu/ops/GrTestMeshDrawOp.h b/src/gpu/ops/GrTestMeshDrawOp.h
index 8273aba..5ca4af7 100644
--- a/src/gpu/ops/GrTestMeshDrawOp.h
+++ b/src/gpu/ops/GrTestMeshDrawOp.h
@@ -33,10 +33,10 @@
bool usesLocalCoords() const { return fUsesLocalCoords; }
private:
- void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color,
- GrPipelineAnalysisCoverage* coverage) const override {
+ void getProcessorAnalysisInputs(GrProcessorAnalysisColor* color,
+ GrProcessorAnalysisCoverage* coverage) const override {
color->setToConstant(fColor);
- *coverage = GrPipelineAnalysisCoverage::kSingleChannel;
+ *coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
void applyPipelineOptimizations(const PipelineOptimizations& optimizations) override {