Create GrXferProcessor while doing GrProcessorSet analysis.
Bug: skia:
Change-Id: I62a628f9c0536ffb05c8f9d0c9ded5657f93b48e
Reviewed-on: https://skia-review.googlesource.com/11482
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
diff --git a/src/gpu/GrPipeline.cpp b/src/gpu/GrPipeline.cpp
index 759f97c..d1f5931 100644
--- a/src/gpu/GrPipeline.cpp
+++ b/src/gpu/GrPipeline.cpp
@@ -20,6 +20,8 @@
void GrPipeline::init(const InitArgs& args) {
SkASSERT(args.fRenderTarget);
+ SkASSERT(args.fProcessors);
+ SkASSERT(args.fProcessors->isFinalized());
fRenderTarget.reset(args.fRenderTarget);
@@ -48,17 +50,8 @@
fDrawFace = static_cast<int16_t>(args.fDrawFace);
- bool isHWAA = kHWAntialias_Flag & args.fFlags;
+ fXferProcessor.reset(args.fProcessors->xferProcessor());
- // Create XferProcessor from DS's XPFactory
- {
- bool hasMixedSamples =
- args.fRenderTarget->isMixedSampled() && (isHWAA || this->isStencilEnabled());
- sk_sp<GrXferProcessor> xferProcessor =
- GrXPFactory::MakeXferProcessor(args.fProcessors->xpFactory(), args.fXPInputColor,
- args.fXPInputCoverage, hasMixedSamples, *args.fCaps);
- fXferProcessor.reset(xferProcessor.get());
- }
if (args.fDstTexture.texture()) {
fDstTexture.reset(args.fDstTexture.texture());
fDstTextureOffset = args.fDstTexture.offset();
diff --git a/src/gpu/GrPipeline.h b/src/gpu/GrPipeline.h
index 02a14af..a2a332f 100644
--- a/src/gpu/GrPipeline.h
+++ b/src/gpu/GrPipeline.h
@@ -56,9 +56,7 @@
struct InitArgs {
uint32_t fFlags = 0;
GrDrawFace fDrawFace = GrDrawFace::kBoth;
- const GrProcessorSet* fProcessors = nullptr;
- GrProcessorAnalysisColor fXPInputColor;
- GrProcessorAnalysisCoverage fXPInputCoverage = GrProcessorAnalysisCoverage::kNone;
+ const GrProcessorSet* fProcessors = nullptr; // Must be finalized
const GrUserStencilSettings* fUserStencil = &GrUserStencilSettings::kUnused;
const GrAppliedClip* fAppliedClip = nullptr;
GrRenderTarget* fRenderTarget = nullptr;
diff --git a/src/gpu/GrPipelineBuilder.h b/src/gpu/GrPipelineBuilder.h
index 94e07e6..78aead0 100644
--- a/src/gpu/GrPipelineBuilder.h
+++ b/src/gpu/GrPipelineBuilder.h
@@ -63,12 +63,12 @@
const GrProcessorSet& processors() const { return fProcessors; }
- void analyzeAndEliminateFragmentProcessors(GrProcessorSet::Analysis* analysis,
- const GrProcessorAnalysisColor& colorInput,
- const GrProcessorAnalysisCoverage coverageInput,
- const GrAppliedClip* clip, const GrCaps& caps) {
- fProcessors.analyzeAndEliminateFragmentProcessors(analysis, colorInput, coverageInput, clip,
- caps);
+ GrProcessorSet::Analysis finalizeProcessors(const GrProcessorAnalysisColor& colorInput,
+ const GrProcessorAnalysisCoverage coverageInput,
+ const GrAppliedClip* clip, bool isMixedSamples,
+ const GrCaps& caps, GrColor* overrideColor) {
+ return fProcessors.finalize(colorInput, coverageInput, clip, isMixedSamples, caps,
+ overrideColor);
}
/// @}
diff --git a/src/gpu/GrProcessorSet.cpp b/src/gpu/GrProcessorSet.cpp
index 8bdf6b6..9361764 100644
--- a/src/gpu/GrProcessorSet.cpp
+++ b/src/gpu/GrProcessorSet.cpp
@@ -9,9 +9,9 @@
#include "GrAppliedClip.h"
#include "GrCaps.h"
#include "GrXferProcessor.h"
+#include "effects/GrPorterDuffXferProcessor.h"
-GrProcessorSet::GrProcessorSet(GrPaint&& paint) {
- fXPFactory = paint.fXPFactory;
+GrProcessorSet::GrProcessorSet(GrPaint&& paint) : fXP(paint.getXPFactory()) {
fFlags = 0;
if (paint.numColorFragmentProcessors() <= kMaxColorProcessors) {
fColorFragmentProcessorCnt = paint.numColorFragmentProcessors();
@@ -40,27 +40,22 @@
GrProcessorSet::~GrProcessorSet() {
for (int i = fFragmentProcessorOffset; i < fFragmentProcessors.count(); ++i) {
- if (this->isPendingExecution()) {
+ if (this->isFinalized()) {
fFragmentProcessors[i]->completedExecution();
} else {
fFragmentProcessors[i]->unref();
}
}
-}
-
-void GrProcessorSet::makePendingExecution() {
- SkASSERT(!(kPendingExecution_Flag & fFlags));
- fFlags |= kPendingExecution_Flag;
- for (int i = fFragmentProcessorOffset; i < fFragmentProcessors.count(); ++i) {
- fFragmentProcessors[i]->addPendingExecution();
- fFragmentProcessors[i]->unref();
+ if (this->isFinalized() && this->xferProcessor()) {
+ this->xferProcessor()->completedExecution();
}
}
bool GrProcessorSet::operator==(const GrProcessorSet& that) const {
+ SkASSERT(this->isFinalized());
+ SkASSERT(that.isFinalized());
int fpCount = this->numFragmentProcessors();
- if (((fFlags ^ that.fFlags) & ~kPendingExecution_Flag) ||
- fpCount != that.numFragmentProcessors() ||
+ if (((fFlags ^ that.fFlags) & ~kFinalized_Flag) || fpCount != that.numFragmentProcessors() ||
fColorFragmentProcessorCnt != that.fColorFragmentProcessorCnt) {
return false;
}
@@ -72,34 +67,43 @@
return false;
}
}
- if (fXPFactory != that.fXPFactory) {
- return false;
+ // Most of the time both of these are null
+ if (!this->xferProcessor() && !that.xferProcessor()) {
+ return true;
}
- return true;
+ const GrXferProcessor& thisXP = this->xferProcessor()
+ ? *this->xferProcessor()
+ : GrPorterDuffXPFactory::SimpleSrcOverXP();
+ const GrXferProcessor& thatXP = that.xferProcessor()
+ ? *that.xferProcessor()
+ : GrPorterDuffXPFactory::SimpleSrcOverXP();
+ return thisXP.isEqual(thatXP);
}
-//////////////////////////////////////////////////////////////////////////////
+GrProcessorSet::Analysis GrProcessorSet::finalize(const GrProcessorAnalysisColor& colorInput,
+ const GrProcessorAnalysisCoverage coverageInput,
+ const GrAppliedClip* clip, bool isMixedSamples,
+ const GrCaps& caps, GrColor* overrideInputColor) {
+ SkASSERT(!this->isFinalized());
+ SkASSERT(!fFragmentProcessorOffset);
-void GrProcessorSet::Analysis::internalInit(const GrProcessorAnalysisColor& colorInput,
- const GrProcessorAnalysisCoverage coverageInput,
- const GrProcessorSet& processors,
- const GrFragmentProcessor* clipFP,
- const GrCaps& caps) {
- GrColorFragmentProcessorAnalysis colorInfo(colorInput);
- fCompatibleWithCoverageAsAlpha = GrProcessorAnalysisCoverage::kLCD != coverageInput;
- fValidInputColor = colorInput.isConstant(&fInputColor);
+ GrProcessorSet::Analysis analysis;
- const GrFragmentProcessor* const* fps =
- processors.fFragmentProcessors.get() + processors.fFragmentProcessorOffset;
- colorInfo.analyzeProcessors(fps, processors.fColorFragmentProcessorCnt);
- fCompatibleWithCoverageAsAlpha &= colorInfo.allProcessorsCompatibleWithCoverageAsAlpha();
- fps += processors.fColorFragmentProcessorCnt;
- int n = processors.numCoverageFragmentProcessors();
+ const GrFragmentProcessor* clipFP = clip ? clip->clipCoverageFragmentProcessor() : nullptr;
+ GrColorFragmentProcessorAnalysis colorAnalysis(colorInput);
+ analysis.fCompatibleWithCoverageAsAlpha = GrProcessorAnalysisCoverage::kLCD != coverageInput;
+
+ const GrFragmentProcessor* const* fps = fFragmentProcessors.get() + fFragmentProcessorOffset;
+ colorAnalysis.analyzeProcessors(fps, fColorFragmentProcessorCnt);
+ analysis.fCompatibleWithCoverageAsAlpha &=
+ colorAnalysis.allProcessorsCompatibleWithCoverageAsAlpha();
+ fps += fColorFragmentProcessorCnt;
+ int n = this->numCoverageFragmentProcessors();
bool hasCoverageFP = n > 0;
bool coverageUsesLocalCoords = false;
for (int i = 0; i < n; ++i) {
if (!fps[i]->compatibleWithCoverageAsAlpha()) {
- fCompatibleWithCoverageAsAlpha = false;
+ analysis.fCompatibleWithCoverageAsAlpha = false;
// Other than tests that exercise atypical behavior we expect all coverage FPs to be
// compatible with the coverage-as-alpha optimization.
GrCapsDebugf(&caps, "Coverage FP is not compatible with coverage as alpha.\n");
@@ -108,21 +112,14 @@
}
if (clipFP) {
- fCompatibleWithCoverageAsAlpha &= clipFP->compatibleWithCoverageAsAlpha();
+ analysis.fCompatibleWithCoverageAsAlpha &= clipFP->compatibleWithCoverageAsAlpha();
coverageUsesLocalCoords |= clipFP->usesLocalCoords();
hasCoverageFP = true;
}
- fInitialColorProcessorsToEliminate = colorInfo.initialProcessorsToEliminate(&fInputColor);
- fValidInputColor |= SkToBool(fInitialColorProcessorsToEliminate);
-
- GrProcessorAnalysisColor outputColor = colorInfo.outputColor();
- if (outputColor.isConstant(&fKnownOutputColor)) {
- fOutputColorType = static_cast<unsigned>(ColorType::kConstant);
- } else if (outputColor.isOpaque()) {
- fOutputColorType = static_cast<unsigned>(ColorType::kOpaque);
- } else {
- fOutputColorType = static_cast<unsigned>(ColorType::kUnknown);
- }
+ int colorFPsToEliminate = colorAnalysis.initialProcessorsToEliminate(overrideInputColor);
+ analysis.fInputColorType = static_cast<Analysis::PackedInputColorType>(
+ colorFPsToEliminate ? Analysis::kOverridden_InputColorType
+ : Analysis::kOriginal_InputColorType);
GrProcessorAnalysisCoverage outputCoverage;
if (GrProcessorAnalysisCoverage::kLCD == coverageInput) {
@@ -132,82 +129,51 @@
} else {
outputCoverage = GrProcessorAnalysisCoverage::kNone;
}
- fOutputCoverageType = static_cast<unsigned>(outputCoverage);
GrXPFactory::AnalysisProperties props = GrXPFactory::GetAnalysisProperties(
- processors.fXPFactory, colorInfo.outputColor(), outputCoverage, caps);
- if (!processors.numCoverageFragmentProcessors() &&
+ this->xpFactory(), colorAnalysis.outputColor(), outputCoverage, caps);
+ if (!this->numCoverageFragmentProcessors() &&
GrProcessorAnalysisCoverage::kNone == coverageInput) {
- fCanCombineOverlappedStencilAndCover = SkToBool(
+ analysis.fCanCombineOverlappedStencilAndCover = SkToBool(
props & GrXPFactory::AnalysisProperties::kCanCombineOverlappedStencilAndCover);
} else {
// If we have non-clipping coverage processors we don't try to merge stencil steps as its
// unclear whether it will be correct. We don't expect this to happen in practice.
- fCanCombineOverlappedStencilAndCover = false;
+ analysis.fCanCombineOverlappedStencilAndCover = false;
}
- fRequiresDstTexture = SkToBool(props & GrXPFactory::AnalysisProperties::kRequiresDstTexture);
- fIgnoresInputColor = SkToBool(props & GrXPFactory::AnalysisProperties::kIgnoresInputColor);
- fCompatibleWithCoverageAsAlpha &=
+ analysis.fRequiresDstTexture =
+ SkToBool(props & GrXPFactory::AnalysisProperties::kRequiresDstTexture);
+ analysis.fCompatibleWithCoverageAsAlpha &=
SkToBool(props & GrXPFactory::AnalysisProperties::kCompatibleWithAlphaAsCoverage);
- fRequiresBarrierBetweenOverlappingDraws = SkToBool(
+ analysis.fRequiresBarrierBetweenOverlappingDraws = SkToBool(
props & GrXPFactory::AnalysisProperties::kRequiresBarrierBetweenOverlappingDraws);
if (props & GrXPFactory::AnalysisProperties::kIgnoresInputColor) {
- fInitialColorProcessorsToEliminate = processors.numColorFragmentProcessors();
- // If the output of the last color stage is known then the kIgnoresInputColor optimization
- // may depend upon it being the input to the xp.
- if (!outputColor.isConstant(&fInputColor)) {
- // Otherwise, the only property the XP factory could have relied upon to compute
- // kIgnoresInputColor is opaqueness.
- fInputColor = GrColor_WHITE;
- }
- fValidInputColor = true;
- fUsesLocalCoords = coverageUsesLocalCoords;
+ colorFPsToEliminate = this->numColorFragmentProcessors();
+ analysis.fInputColorType =
+ static_cast<Analysis::PackedInputColorType>(Analysis::kIgnored_InputColorType);
+ analysis.fUsesLocalCoords = coverageUsesLocalCoords;
} else {
- fUsesLocalCoords = coverageUsesLocalCoords | colorInfo.usesLocalCoords();
+ analysis.fUsesLocalCoords = coverageUsesLocalCoords | colorAnalysis.usesLocalCoords();
}
-}
-
-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::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(
- Analysis* analysis,
- const GrProcessorAnalysisColor& colorInput,
- const GrProcessorAnalysisCoverage coverageInput,
- const GrAppliedClip* clip,
- const GrCaps& caps) {
- analysis->init(colorInput, coverageInput, *this, clip, caps);
- if (analysis->fInitialColorProcessorsToEliminate > 0) {
- for (unsigned i = 0; i < analysis->fInitialColorProcessorsToEliminate; ++i) {
- if (this->isPendingExecution()) {
- fFragmentProcessors[i + fFragmentProcessorOffset]->completedExecution();
- } else {
- fFragmentProcessors[i + fFragmentProcessorOffset]->unref();
- }
- fFragmentProcessors[i + fFragmentProcessorOffset] = nullptr;
- }
- fFragmentProcessorOffset += analysis->fInitialColorProcessorsToEliminate;
- fColorFragmentProcessorCnt -= analysis->fInitialColorProcessorsToEliminate;
- SkASSERT(fFragmentProcessorOffset + fColorFragmentProcessorCnt <=
- fFragmentProcessors.count());
- analysis->fInitialColorProcessorsToEliminate = 0;
+ for (int i = 0; i < colorFPsToEliminate; ++i) {
+ fFragmentProcessors[i]->unref();
+ fFragmentProcessors[i] = nullptr;
}
+ for (int i = colorFPsToEliminate; i < fFragmentProcessors.count(); ++i) {
+ fFragmentProcessors[i]->addPendingExecution();
+ fFragmentProcessors[i]->unref();
+ }
+ fFragmentProcessorOffset = colorFPsToEliminate;
+ fColorFragmentProcessorCnt -= colorFPsToEliminate;
+
+ auto xp = GrXPFactory::MakeXferProcessor(this->xpFactory(), colorAnalysis.outputColor(),
+ outputCoverage, isMixedSamples, caps);
+ fXP.fProcessor = xp.get();
+ if (fXP.fProcessor) {
+ fXP.fProcessor->addPendingExecution();
+ }
+ fFlags |= kFinalized_Flag;
+
+ analysis.fIsInitialized = true;
+ return analysis;
}
diff --git a/src/gpu/GrProcessorSet.h b/src/gpu/GrProcessorSet.h
index 39ba013..289ca1b 100644
--- a/src/gpu/GrProcessorSet.h
+++ b/src/gpu/GrProcessorSet.h
@@ -14,6 +14,7 @@
#include "SkTemplates.h"
class GrAppliedClip;
+class GrXferProcessor;
class GrXPFactory;
class GrProcessorSet : private SkNoncopyable {
@@ -22,14 +23,6 @@
~GrProcessorSet();
- /**
- * If an op is recorded with this processor set then this must be called to ensure pending
- * reads and writes are propagated to resources referred to by the processors. Otherwise,
- * data hazards may occur.
- */
- void makePendingExecution();
- bool isPendingExecution() const { return SkToBool(kPendingExecution_Flag & fFlags); }
-
int numColorFragmentProcessors() const { return fColorFragmentProcessorCnt; }
int numCoverageFragmentProcessors() const {
return this->numFragmentProcessors() - fColorFragmentProcessorCnt;
@@ -46,7 +39,10 @@
return fFragmentProcessors[idx + fColorFragmentProcessorCnt + fFragmentProcessorOffset];
}
- const GrXPFactory* xpFactory() const { return fXPFactory; }
+ const GrXferProcessor* xferProcessor() const {
+ SkASSERT(this->isFinalized());
+ return fXP.fProcessor;
+ }
bool usesDistanceVectorField() const { return SkToBool(fFlags & kUseDistanceVectorField_Flag); }
bool disableOutputConversionToSRGB() const {
@@ -54,74 +50,20 @@
}
bool allowSRGBInputs() const { return SkToBool(fFlags & kAllowSRGBInputs_Flag); }
+ /** Comparisons are only legal on finalized processor sets. */
bool operator==(const GrProcessorSet& that) const;
bool operator!=(const GrProcessorSet& that) const { return !(*this == that); }
/**
- * This is used to track analysis of color and coverage values through the processors.
+ * This is used to report results of processor analysis when a processor set is finalized (see
+ * below).
*/
class Analysis {
public:
- /**
- * 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 Analysis(GrColor initialColor) : Analysis() {
- fInputColor = initialColor;
- fValidInputColor = true;
- }
+ Analysis(const Analysis&) = default;
+ Analysis() { *reinterpret_cast<uint32_t*>(this) = 0; }
- Analysis()
- : fIsInitializedWithProcessorSet(false)
- , fCompatibleWithCoverageAsAlpha(true)
- , fValidInputColor(false)
- , fRequiresDstTexture(false)
- , fCanCombineOverlappedStencilAndCover(true)
- , fIgnoresInputColor(false)
- , fRequiresBarrierBetweenOverlappingDraws(false)
- , 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.
- Analysis(const GrProcessorAnalysisColor&, GrProcessorAnalysisCoverage, const GrXPFactory*,
- const GrCaps&);
-
- void init(const GrProcessorAnalysisColor&, GrProcessorAnalysisCoverage,
- const GrProcessorSet&, const GrAppliedClip*, const GrCaps&);
-
- bool isInitializedWithProcessorSet() const { return fIsInitializedWithProcessorSet; }
-
- /**
- * If the return is greater than or equal to zero then 'newInputColor' should be used as the
- * input color to the GrPipeline derived from this processor set, replacing the GrDrawOp's
- * initial color. If the return is less than zero then newInputColor has not been
- * modified and no modification need be made to the pipeline's input color by the op.
- */
- int getInputColorOverrideAndColorProcessorEliminationCount(GrColor* newInputColor) const {
- if (fValidInputColor) {
- *newInputColor = fInputColor;
- return fInitialColorProcessorsToEliminate;
- }
- SkASSERT(!fInitialColorProcessorsToEliminate);
- return -1;
- }
-
- /**
- * Valid if initialProcessorsToEliminate returns true or this analysis was initialized with
- * a known color via constructor or init(). If color fragment processors are eliminated then
- * this returns the expected input to the first non-eliminated processors. Otherwise it is
- * the color passed to the constructor or init().
- */
- GrColor inputColor() const {
- SkASSERT(fValidInputColor);
- return fInputColor;
- }
-
+ bool isInitialized() const { return fIsInitialized; }
bool usesLocalCoords() const { return fUsesLocalCoords; }
bool requiresDstTexture() const { return fRequiresDstTexture; }
bool canCombineOverlappedStencilAndCover() const {
@@ -131,60 +73,54 @@
return fRequiresBarrierBetweenOverlappingDraws;
}
bool isCompatibleWithCoverageAsAlpha() const { return fCompatibleWithCoverageAsAlpha; }
- bool isInputColorIgnored() const { return fIgnoresInputColor; }
- GrProcessorAnalysisCoverage outputCoverage() const {
- return static_cast<GrProcessorAnalysisCoverage>(fOutputCoverageType);
- }
- GrProcessorAnalysisColor outputColor() const {
- switch (this->outputColorType()) {
- case ColorType::kConstant:
- return fKnownOutputColor;
- case ColorType::kOpaque:
- return GrProcessorAnalysisColor::Opaque::kYes;
- case ColorType::kUnknown:
- return GrProcessorAnalysisColor::Opaque::kNo;
- }
- SkFAIL("Unexpected color type");
- return GrProcessorAnalysisColor::Opaque::kNo;
+
+ bool inputColorIsIgnored() const { return fInputColorType == kIgnored_InputColorType; }
+ bool inputColorIsOverridden() const {
+ return fInputColorType == kOverridden_InputColorType;
}
private:
- enum class ColorType : unsigned { kUnknown, kConstant, kOpaque };
+ enum InputColorType : uint32_t {
+ kOriginal_InputColorType,
+ kOverridden_InputColorType,
+ kIgnored_InputColorType
+ };
- ColorType outputColorType() const { return static_cast<ColorType>(fOutputColorType); }
+ // MSVS 2015 won't pack different underlying types
+ using PackedBool = uint32_t;
+ using PackedInputColorType = uint32_t;
- void internalInit(const GrProcessorAnalysisColor&, const GrProcessorAnalysisCoverage,
- const GrProcessorSet&, const GrFragmentProcessor* clipFP, const GrCaps&);
-
- // MSVS 2015 won't pack a bool with an unsigned.
- using PackedBool = unsigned;
-
- PackedBool fIsInitializedWithProcessorSet : 1;
PackedBool fUsesLocalCoords : 1;
PackedBool fCompatibleWithCoverageAsAlpha : 1;
- PackedBool fValidInputColor : 1;
PackedBool fRequiresDstTexture : 1;
PackedBool fCanCombineOverlappedStencilAndCover : 1;
- // These could be removed if we created the XP from the XPFactory when doing analysis.
- PackedBool fIgnoresInputColor : 1;
PackedBool fRequiresBarrierBetweenOverlappingDraws : 1;
- unsigned fOutputCoverageType : 2;
- unsigned fOutputColorType : 2;
-
- unsigned fInitialColorProcessorsToEliminate : 32 - 12;
-
- GrColor fInputColor;
- // This could be removed if we created the XP from the XPFactory when doing analysis.
- GrColor fKnownOutputColor;
+ PackedBool fIsInitialized : 1;
+ PackedInputColorType fInputColorType : 2;
friend class GrProcessorSet;
};
- GR_STATIC_ASSERT(sizeof(Analysis) == 2 * sizeof(GrColor) + sizeof(uint32_t));
+ GR_STATIC_ASSERT(sizeof(Analysis) == sizeof(uint32_t));
- void analyzeAndEliminateFragmentProcessors(Analysis*,
- const GrProcessorAnalysisColor& colorInput,
- const GrProcessorAnalysisCoverage coverageInput,
- const GrAppliedClip*, const GrCaps&);
+ /**
+ * This analyzes the processors given an op's input color and coverage as well as a clip. The
+ * state of the processor set may change to an equivalent but more optimal set of processors.
+ * This new state requires that the caller respect the returned 'inputColorOverride'. This is
+ * indicated by the returned Analysis's inputColorIsOverriden(). 'inputColorOverride' will not
+ * be written if the analysis does not override the input color.
+ *
+ * This must be called before the processor set is used to construct a GrPipeline and may only
+ * be called once.
+ *
+ * This also puts the processors in "pending execution" state and must be called when an op
+ * that owns a processor set is recorded to ensure pending and writes are propagated to
+ * resources referred to by the processors. Otherwise, data hazards may occur.
+ */
+ Analysis finalize(const GrProcessorAnalysisColor& colorInput,
+ const GrProcessorAnalysisCoverage coverageInput, const GrAppliedClip*,
+ bool isMixedSamples, const GrCaps&, GrColor* inputColorOverride);
+
+ bool isFinalized() const { return SkToBool(kFinalized_Flag & fFlags); }
private:
// This absurdly large limit allows Analysis and this to pack fields together.
@@ -194,11 +130,22 @@
kUseDistanceVectorField_Flag = 0x1,
kDisableOutputConversionToSRGB_Flag = 0x2,
kAllowSRGBInputs_Flag = 0x4,
- kPendingExecution_Flag = 0x8
+ kFinalized_Flag = 0x8
};
- const GrXPFactory* fXPFactory = nullptr;
+ union XP {
+ XP(const GrXPFactory* factory) : fFactory(factory) {}
+ const GrXPFactory* fFactory;
+ const GrXferProcessor* fProcessor;
+ };
+
+ const GrXPFactory* xpFactory() const {
+ SkASSERT(!this->isFinalized());
+ return fXP.fFactory;
+ }
+
SkAutoSTArray<4, const GrFragmentProcessor*> fFragmentProcessors;
+ XP fXP;
uint8_t fColorFragmentProcessorCnt;
uint8_t fFragmentProcessorOffset = 0;
uint8_t fFlags;
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index a4b7731..b0a1b6d 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -1688,30 +1688,33 @@
}
GrResourceProvider* resourceProvider = fContext->resourceProvider();
- if (pipelineBuilder.hasUserStencilSettings() || appliedClip.hasStencilClip()) {
+ bool usesStencil = pipelineBuilder.hasUserStencilSettings() || appliedClip.hasStencilClip();
+ if (usesStencil) {
if (!resourceProvider->attachStencilAttachment(this->accessRenderTarget())) {
SkDebugf("ERROR creating stencil attachment. Draw skipped.\n");
return SK_InvalidUniqueID;
}
}
- GrProcessorSet::Analysis analysis;
- op->analyzeProcessors(&analysis, &pipelineBuilder, &appliedClip, *this->caps());
+ bool isMixedSamples = fRenderTargetProxy->isMixedSampled() &&
+ (pipelineBuilder.isHWAntialias() || usesStencil);
+
+ GrColor overrideColor;
+ GrProcessorSet::Analysis analysis = op->analyzeUpdateAndRecordProcessors(
+ &pipelineBuilder, &appliedClip, isMixedSamples, *this->caps(), &overrideColor);
GrPipeline::InitArgs args;
pipelineBuilder.getPipelineInitArgs(&args);
args.fAppliedClip = &appliedClip;
args.fRenderTarget = rt;
args.fCaps = this->caps();
- args.fXPInputColor = analysis.outputColor();
- args.fXPInputCoverage = analysis.outputCoverage();
if (analysis.requiresDstTexture()) {
if (!this->setupDstTexture(fRenderTargetProxy.get(), clip, bounds, &args.fDstTexture)) {
return SK_InvalidUniqueID;
}
}
- op->initPipeline(args, analysis);
+ op->initPipeline(args, analysis, overrideColor);
// TODO: We need to add pipeline dependencies on textures, etc before recording this op.
op->setClippedBounds(bounds);
return this->getOpList()->addOp(std::move(op), this);
diff --git a/src/gpu/instanced/InstancedRendering.cpp b/src/gpu/instanced/InstancedRendering.cpp
index 9b6e576..9d17a82 100644
--- a/src/gpu/instanced/InstancedRendering.cpp
+++ b/src/gpu/instanced/InstancedRendering.cpp
@@ -332,17 +332,19 @@
}
bool InstancedRendering::Op::xpRequiresDstTexture(const GrCaps& caps, const GrAppliedClip* clip) {
- GrProcessorSet::Analysis analysis;
+ SkASSERT(State::kRecordingDraws == fInstancedRendering->fState);
GrProcessorAnalysisCoverage coverageInput;
+ bool isMixedSamples = false;
if (GrAAType::kCoverage == fInfo.aaType() ||
(GrAAType::kNone == fInfo.aaType() && !fInfo.isSimpleRects() && fInfo.fCannotDiscard)) {
coverageInput = GrProcessorAnalysisCoverage::kSingleChannel;
} else {
coverageInput = GrProcessorAnalysisCoverage::kNone;
+ isMixedSamples = GrAAType::kMixedSamples == fInfo.aaType();
}
- fProcessors.analyzeAndEliminateFragmentProcessors(&analysis, this->getSingleInstance().fColor,
- coverageInput, clip, caps);
- fAnalysisColor = analysis.outputColor();
+ GrProcessorSet::Analysis analysis =
+ fProcessors.finalize(this->getSingleInstance().fColor, coverageInput, clip,
+ isMixedSamples, caps, &this->getSingleDraw().fInstance.fColor);
Draw& draw = this->getSingleDraw(); // This will assert if we have > 1 command.
SkASSERT(draw.fGeometry.isEmpty());
@@ -363,11 +365,6 @@
fInstancedRendering->fParams.push_back_n(fParams.count(), fParams.begin());
}
- GrColor overrideColor;
- if (analysis.getInputColorOverrideAndColorProcessorEliminationCount(&overrideColor) >= 0) {
- SkASSERT(State::kRecordingDraws == fInstancedRendering->fState);
- this->getSingleDraw().fInstance.fColor = overrideColor;
- }
fInfo.fCannotTweakAlphaForCoverage = !analysis.isCompatibleWithCoverageAsAlpha();
fInfo.fUsesLocalCoords = analysis.usesLocalCoords();
@@ -378,7 +375,6 @@
void InstancedRendering::Op::wasRecorded() {
SkASSERT(!fIsTracked);
fInstancedRendering->fTrackedOps.addToTail(this);
- fProcessors.makePendingExecution();
fIsTracked = true;
}
@@ -413,7 +409,6 @@
this->joinBounds(*that);
fInfo = combinedInfo;
fPixelLoad += that->fPixelLoad;
- fAnalysisColor = GrProcessorAnalysisColor::Combine(fAnalysisColor, that->fAnalysisColor);
// Adopt the other op's draws.
fNumDraws += that->fNumDraws;
fNumChangesInGeometry += that->fNumChangesInGeometry;
@@ -470,21 +465,9 @@
state->gpu()->handleDirtyContext();
- const GrAppliedClip* clip = state->drawOpArgs().fAppliedClip;
- GrProcessorAnalysisCoverage coverage;
- if (GrAAType::kCoverage == fInfo.aaType() ||
- (clip && clip->clipCoverageFragmentProcessor()) ||
- (GrAAType::kNone == fInfo.aaType() && !fInfo.isSimpleRects() && fInfo.fCannotDiscard)) {
- coverage = GrProcessorAnalysisCoverage::kSingleChannel;
- } else {
- coverage = GrProcessorAnalysisCoverage::kNone;
- }
-
GrPipeline pipeline;
GrPipeline::InitArgs args;
- args.fXPInputColor = fAnalysisColor;
- args.fXPInputCoverage = coverage;
- args.fAppliedClip = clip;
+ args.fAppliedClip = state->drawOpArgs().fAppliedClip;
args.fCaps = &state->caps();
args.fProcessors = &fProcessors;
args.fFlags = GrAATypeIsHW(fInfo.aaType()) ? GrPipeline::kHWAntialias_Flag : 0;
diff --git a/src/gpu/instanced/InstancedRendering.h b/src/gpu/instanced/InstancedRendering.h
index 3ec8214..a8b9530 100644
--- a/src/gpu/instanced/InstancedRendering.h
+++ b/src/gpu/instanced/InstancedRendering.h
@@ -151,7 +151,6 @@
OpInfo fInfo;
SkScalar fPixelLoad;
GrProcessorSet fProcessors;
- GrProcessorAnalysisColor fAnalysisColor;
SkSTArray<5, ParamsTexel, true> fParams;
bool fIsTracked : 1;
bool fRequiresBarrierOnOverlap : 1;
diff --git a/src/gpu/ops/GrDrawOp.h b/src/gpu/ops/GrDrawOp.h
index 0458370..dbdd9d8 100644
--- a/src/gpu/ops/GrDrawOp.h
+++ b/src/gpu/ops/GrDrawOp.h
@@ -76,7 +76,8 @@
* This is called after the GrAppliedClip has been computed and just prior to recording the op
* or combining it with a previously recorded op. It is used to determine whether a copy of the
* destination (or destination texture itself) needs to be provided to the xp when this op
- * executes.
+ * executes. This is guaranteed to be called before an op is recorded. However, this is also
+ * called on ops that are not recorded because they combine with a previously recorded op.
*/
virtual bool xpRequiresDstTexture(const GrCaps&, const GrAppliedClip*) = 0;
diff --git a/src/gpu/ops/GrDrawPathOp.cpp b/src/gpu/ops/GrDrawPathOp.cpp
index 1c68fdf..3632787 100644
--- a/src/gpu/ops/GrDrawPathOp.cpp
+++ b/src/gpu/ops/GrDrawPathOp.cpp
@@ -12,13 +12,15 @@
#include "SkTemplates.h"
GrDrawPathOpBase::GrDrawPathOpBase(uint32_t classID, const SkMatrix& viewMatrix, GrPaint&& paint,
- GrPathRendering::FillType fill, GrAA aa)
+ GrPathRendering::FillType fill, GrAAType aaType)
: INHERITED(classID)
, fViewMatrix(viewMatrix)
+ , fInputColor(paint.getColor())
, fProcessorSet(std::move(paint))
- , fAnalysis(paint.getColor())
, fFillType(fill)
- , fAA(aa) {}
+ , fAAType(aaType) {
+ SkASSERT(fAAType != GrAAType::kCoverage);
+}
SkString GrDrawPathOp::dumpInfo() const {
SkString string;
@@ -38,16 +40,13 @@
0xffff>()
};
GrPipeline::InitArgs args;
- auto analysis = this->processorAnalysis();
args.fProcessors = &this->processors();
- args.fFlags = GrAA::kYes == fAA ? GrPipeline::kHWAntialias_Flag : 0;
+ args.fFlags = GrAATypeIsHW(fAAType) ? GrPipeline::kHWAntialias_Flag : 0;
args.fUserStencil = &kCoverPass;
args.fAppliedClip = state.drawOpArgs().fAppliedClip;
args.fRenderTarget = state.drawOpArgs().fRenderTarget;
args.fCaps = &state.caps();
args.fDstTexture = state.drawOpArgs().fDstTexture;
- args.fXPInputColor = analysis.outputColor();
- args.fXPInputCoverage = analysis.outputCoverage();
return pipeline->init(args);
}
@@ -90,9 +89,9 @@
GrDrawPathRangeOp::GrDrawPathRangeOp(const SkMatrix& viewMatrix, SkScalar scale, SkScalar x,
SkScalar y, GrPaint&& paint, GrPathRendering::FillType fill,
- GrAA aa, GrPathRange* range, const InstanceData* instanceData,
- const SkRect& bounds)
- : INHERITED(ClassID(), viewMatrix, std::move(paint), fill, aa)
+ GrAAType aaType, GrPathRange* range,
+ const InstanceData* instanceData, const SkRect& bounds)
+ : INHERITED(ClassID(), viewMatrix, std::move(paint), fill, aaType)
, fPathRange(range)
, fTotalPathCount(instanceData->count())
, fScale(scale) {
diff --git a/src/gpu/ops/GrDrawPathOp.h b/src/gpu/ops/GrDrawPathOp.h
index 0631adc..8995de4 100644
--- a/src/gpu/ops/GrDrawPathOp.h
+++ b/src/gpu/ops/GrDrawPathOp.h
@@ -23,31 +23,33 @@
class GrDrawPathOpBase : public GrDrawOp {
protected:
- GrDrawPathOpBase(uint32_t classID, const SkMatrix& viewMatrix, GrPaint&& paint,
- GrPathRendering::FillType fill, GrAA aa);
+ GrDrawPathOpBase(uint32_t classID, const SkMatrix& viewMatrix, GrPaint&&,
+ GrPathRendering::FillType, GrAAType);
FixedFunctionFlags fixedFunctionFlags() const override {
- return FixedFunctionFlags::kUsesHWAA | FixedFunctionFlags::kUsesStencil;
+ if (GrAATypeIsHW(fAAType)) {
+ return FixedFunctionFlags::kUsesHWAA | FixedFunctionFlags::kUsesStencil;
+ }
+ return FixedFunctionFlags::kUsesStencil;
}
bool xpRequiresDstTexture(const GrCaps& caps, const GrAppliedClip* clip) override {
return this->doProcessorAnalysis(caps, clip).requiresDstTexture();
}
- void wasRecorded() override { fProcessorSet.makePendingExecution(); }
-
protected:
const SkMatrix& viewMatrix() const { return fViewMatrix; }
- GrColor color() const { return fAnalysis.inputColor(); }
+ GrColor color() const { return fInputColor; }
GrPathRendering::FillType fillType() const { return fFillType; }
const GrProcessorSet& processors() const { return fProcessorSet; }
void initPipeline(const GrOpFlushState&, GrPipeline*);
const GrProcessorSet::Analysis& doProcessorAnalysis(const GrCaps& caps,
const GrAppliedClip* clip) {
- fProcessorSet.analyzeAndEliminateFragmentProcessors(
- &fAnalysis, fAnalysis.inputColor(), GrProcessorAnalysisCoverage::kNone, clip, caps);
+ bool isMixedSamples = GrAAType::kMixedSamples == fAAType;
+ fAnalysis = fProcessorSet.finalize(fInputColor, GrProcessorAnalysisCoverage::kNone, clip,
+ isMixedSamples, caps, &fInputColor);
return fAnalysis;
}
const GrProcessorSet::Analysis& processorAnalysis() const {
- SkASSERT(fAnalysis.isInitializedWithProcessorSet());
+ SkASSERT(fAnalysis.isInitialized());
return fAnalysis;
}
@@ -55,10 +57,11 @@
void onPrepare(GrOpFlushState*) final {}
SkMatrix fViewMatrix;
+ GrColor fInputColor;
GrProcessorSet fProcessorSet;
GrProcessorSet::Analysis fAnalysis;
GrPathRendering::FillType fFillType;
- GrAA fAA;
+ GrAAType fAAType;
typedef GrDrawOp INHERITED;
};
@@ -67,9 +70,10 @@
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(const SkMatrix& viewMatrix, GrPaint&& paint, GrAA aa,
- GrPath* path) {
- return std::unique_ptr<GrDrawOp>(new GrDrawPathOp(viewMatrix, std::move(paint), aa, path));
+ static std::unique_ptr<GrDrawOp> Make(const SkMatrix& viewMatrix, GrPaint&& paint,
+ GrAAType aaType, GrPath* path) {
+ return std::unique_ptr<GrDrawOp>(
+ new GrDrawPathOp(viewMatrix, std::move(paint), aaType, path));
}
const char* name() const override { return "DrawPath"; }
@@ -77,8 +81,8 @@
SkString dumpInfo() const override;
private:
- GrDrawPathOp(const SkMatrix& viewMatrix, GrPaint&& paint, GrAA aa, const GrPath* path)
- : GrDrawPathOpBase(ClassID(), viewMatrix, std::move(paint), path->getFillType(), aa)
+ GrDrawPathOp(const SkMatrix& viewMatrix, GrPaint&& paint, GrAAType aaType, const GrPath* path)
+ : GrDrawPathOpBase(ClassID(), viewMatrix, std::move(paint), path->getFillType(), aaType)
, fPath(path) {
this->setTransformedBounds(path->getBounds(), viewMatrix, HasAABloat::kNo, IsZeroArea::kNo);
}
@@ -160,11 +164,12 @@
static std::unique_ptr<GrDrawOp> Make(const SkMatrix& viewMatrix, SkScalar scale, SkScalar x,
SkScalar y, GrPaint&& paint,
- GrPathRendering::FillType fill, GrAA aa,
+ GrPathRendering::FillType fill, GrAAType aaType,
GrPathRange* range, const InstanceData* instanceData,
const SkRect& bounds) {
- return std::unique_ptr<GrDrawOp>(new GrDrawPathRangeOp(
- viewMatrix, scale, x, y, std::move(paint), fill, aa, range, instanceData, bounds));
+ return std::unique_ptr<GrDrawOp>(new GrDrawPathRangeOp(viewMatrix, scale, x, y,
+ std::move(paint), fill, aaType,
+ range, instanceData, bounds));
}
const char* name() const override { return "DrawPathRange"; }
@@ -173,8 +178,8 @@
private:
GrDrawPathRangeOp(const SkMatrix& viewMatrix, SkScalar scale, SkScalar x, SkScalar y,
- GrPaint&& paint, GrPathRendering::FillType fill, GrAA aa, GrPathRange* range,
- const InstanceData* instanceData, const SkRect& bounds);
+ GrPaint&& paint, GrPathRendering::FillType fill, GrAAType aaType,
+ GrPathRange* range, const InstanceData* instanceData, const SkRect& bounds);
TransformType transformType() const { return fDraws.head()->fInstanceData->transformType(); }
diff --git a/src/gpu/ops/GrMeshDrawOp.h b/src/gpu/ops/GrMeshDrawOp.h
index 41d3848..8fbd30d 100644
--- a/src/gpu/ops/GrMeshDrawOp.h
+++ b/src/gpu/ops/GrMeshDrawOp.h
@@ -101,20 +101,22 @@
* 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::Analysis* analysis,
- GrPipelineBuilder* pipelineBuilder,
- const GrAppliedClip* appliedClip,
- const GrCaps& caps) const {
+ GrProcessorSet::Analysis analyzeUpdateAndRecordProcessors(GrPipelineBuilder* pipelineBuilder,
+ const GrAppliedClip* appliedClip,
+ bool isMixedSamples,
+ const GrCaps& caps,
+ GrColor* overrideColor) const {
GrProcessorAnalysisColor inputColor;
GrProcessorAnalysisCoverage inputCoverage;
this->getProcessorAnalysisInputs(&inputColor, &inputCoverage);
- pipelineBuilder->analyzeAndEliminateFragmentProcessors(analysis, inputColor, inputCoverage,
- appliedClip, caps);
+ return pipelineBuilder->finalizeProcessors(inputColor, inputCoverage, appliedClip,
+ isMixedSamples, caps, overrideColor);
}
- void initPipeline(const GrPipeline::InitArgs& args, const GrProcessorSet::Analysis& analysis) {
+ void initPipeline(const GrPipeline::InitArgs& args, const GrProcessorSet::Analysis& analysis,
+ GrColor overrideColor) {
fPipeline.init(args);
- this->applyPipelineOptimizations(PipelineOptimizations(analysis));
+ this->applyPipelineOptimizations(PipelineOptimizations(analysis, overrideColor));
}
/**
@@ -138,11 +140,11 @@
*/
class PipelineOptimizations {
public:
- PipelineOptimizations(const GrProcessorSet::Analysis& analysis) {
+ PipelineOptimizations(const GrProcessorSet::Analysis& analysis, GrColor overrideColor) {
fFlags = 0;
- if (analysis.getInputColorOverrideAndColorProcessorEliminationCount(&fOverrideColor) >=
- 0) {
+ if (analysis.inputColorIsOverridden()) {
fFlags |= kUseOverrideColor_Flag;
+ fOverrideColor = overrideColor;
}
if (analysis.usesLocalCoords()) {
fFlags |= kReadsLocalCoords_Flag;
diff --git a/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp b/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
index a4e32ac..bd5c297 100644
--- a/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
+++ b/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
@@ -145,9 +145,8 @@
std::move(coverOp));
}
} else {
- GrAA aa = GrBoolToAA(GrAATypeIsHW(args.fAAType));
std::unique_ptr<GrDrawOp> op =
- GrDrawPathOp::Make(viewMatrix, std::move(args.fPaint), aa, path.get());
+ GrDrawPathOp::Make(viewMatrix, std::move(args.fPaint), args.fAAType, path.get());
args.fRenderTargetContext->addDrawOp(*args.fClip, std::move(op));
}
diff --git a/src/gpu/text/GrStencilAndCoverTextContext.cpp b/src/gpu/text/GrStencilAndCoverTextContext.cpp
index e572e5d..0ae4023 100644
--- a/src/gpu/text/GrStencilAndCoverTextContext.cpp
+++ b/src/gpu/text/GrStencilAndCoverTextContext.cpp
@@ -570,9 +570,7 @@
SkScalar y, const SkIRect& clipBounds,
GrAtlasTextContext* fallbackTextContext,
const SkPaint& originalSkPaint) const {
- GrAA runAA = this->isAntiAlias();
SkASSERT(fInstanceData);
- SkASSERT(renderTargetContext->isStencilBufferMultisampled() || GrAA::kNo == runAA);
if (fInstanceData->count()) {
static constexpr GrUserStencilSettings kCoverPass(
@@ -606,9 +604,18 @@
renderTargetContext->height());
// The run's "font" overrides the anti-aliasing of the passed in SkPaint!
+ GrAAType aaType;
+ if (this->aa() == GrAA::kYes) {
+ SkASSERT(renderTargetContext->isStencilBufferMultisampled());
+ aaType = renderTargetContext->isUnifiedMultisampled() ? GrAAType::kMSAA
+ : GrAAType::kMixedSamples;
+ } else {
+ aaType = GrAAType::kNone;
+ }
+
std::unique_ptr<GrDrawOp> op = GrDrawPathRangeOp::Make(
viewMatrix, fTextRatio, fTextInverseRatio * x, fTextInverseRatio * y,
- std::move(grPaint), GrPathRendering::kWinding_FillType, runAA, glyphs.get(),
+ std::move(grPaint), GrPathRendering::kWinding_FillType, aaType, glyphs.get(),
fInstanceData.get(), bounds);
renderTargetContext->addDrawOp(clip, std::move(op));
diff --git a/src/gpu/text/GrStencilAndCoverTextContext.h b/src/gpu/text/GrStencilAndCoverTextContext.h
index f06442b..54c0a9d 100644
--- a/src/gpu/text/GrStencilAndCoverTextContext.h
+++ b/src/gpu/text/GrStencilAndCoverTextContext.h
@@ -83,7 +83,7 @@
size_t computeSizeInCache() const;
- GrAA isAntiAlias() const { return fFont.isAntiAlias() ? GrAA::kYes : GrAA::kNo; }
+ GrAA aa() const { return fFont.isAntiAlias() ? GrAA::kYes : GrAA::kNo; }
private:
typedef GrDrawPathRangeOp::InstanceData InstanceData;
diff --git a/tests/GpuSampleLocationsTest.cpp b/tests/GpuSampleLocationsTest.cpp
index 75fa6fcf..26d7e70 100644
--- a/tests/GpuSampleLocationsTest.cpp
+++ b/tests/GpuSampleLocationsTest.cpp
@@ -91,17 +91,8 @@
virtual ~TestSampleLocationsInterface() {}
};
-static void construct_dummy_pipeline(GrRenderTargetContext* dc, GrPipeline* pipeline) {
- GrPipelineBuilder dummyBuilder(GrPaint(), GrAAType::kNone);
- GrScissorState dummyScissor;
- GrWindowRectsState dummyWindows;
-
- GrPipeline::InitArgs args;
- dummyBuilder.getPipelineInitArgs(&args);
- args.fRenderTarget = dc->accessRenderTarget();
- args.fCaps = dc->caps();
- args.fDstTexture = GrXferProcessor::DstTexture();
- pipeline->init(args);
+static sk_sp<GrPipeline> construct_dummy_pipeline(GrRenderTargetContext* dc) {
+ return sk_sp<GrPipeline>(new GrPipeline(dc->accessRenderTarget(), SkBlendMode::kSrcOver));
}
void assert_equal(skiatest::Reporter* reporter, const SamplePattern& pattern,
@@ -146,11 +137,10 @@
for (int i = 0; i < numTestPatterns; ++i) {
testInterface->overrideSamplePattern(kTestPatterns[i]);
for (GrRenderTargetContext* dc : {bottomUps[i].get(), topDowns[i].get()}) {
- GrPipeline dummyPipeline;
- construct_dummy_pipeline(dc, &dummyPipeline);
+ sk_sp<GrPipeline> dummyPipeline = construct_dummy_pipeline(dc);
GrRenderTarget* rt = dc->accessRenderTarget();
assert_equal(reporter, kTestPatterns[i],
- rt->renderTargetPriv().getMultisampleSpecs(dummyPipeline),
+ rt->renderTargetPriv().getMultisampleSpecs(*dummyPipeline),
kBottomLeft_GrSurfaceOrigin == rt->origin());
}
}
diff --git a/tests/GrPorterDuffTest.cpp b/tests/GrPorterDuffTest.cpp
index f2bd1e7..4066d28 100644
--- a/tests/GrPorterDuffTest.cpp
+++ b/tests/GrPorterDuffTest.cpp
@@ -55,16 +55,30 @@
kISCModulate_OutputType
};
+static GrProcessorSet::Analysis do_analysis(const GrXPFactory* xpf,
+ const GrProcessorAnalysisColor& colorInput,
+ GrProcessorAnalysisCoverage coverageInput,
+ const GrCaps& caps) {
+ GrPaint paint;
+ paint.setXPFactory(xpf);
+ GrProcessorSet procs(std::move(paint));
+ GrColor overrideColor;
+ GrProcessorSet::Analysis analysis =
+ procs.finalize(colorInput, coverageInput, nullptr, false, caps, &overrideColor);
+ return analysis;
+}
+
class GrPorterDuffTest {
public:
struct XPInfo {
XPInfo(skiatest::Reporter* reporter, SkBlendMode xfermode, const GrCaps& caps,
GrProcessorAnalysisColor inputColor, GrProcessorAnalysisCoverage inputCoverage) {
const GrXPFactory* xpf = GrPorterDuffXPFactory::Get(xfermode);
- GrProcessorSet::Analysis analysis(inputColor, inputCoverage, xpf, caps);
+
+ GrProcessorSet::Analysis analysis = do_analysis(xpf, inputColor, inputCoverage, caps);
fCompatibleWithCoverageAsAlpha = analysis.isCompatibleWithCoverageAsAlpha();
fCanCombineOverlappedStencilAndCover = analysis.canCombineOverlappedStencilAndCover();
- fIgnoresInputColor = analysis.isInputColorIgnored();
+ fIgnoresInputColor = analysis.inputColorIsIgnored();
sk_sp<GrXferProcessor> xp(
GrXPFactory::MakeXferProcessor(xpf, inputColor, inputCoverage, false, caps));
TEST_ASSERT(!analysis.requiresDstTexture());
@@ -1040,8 +1054,6 @@
for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) {
SkBlendMode xfermode = static_cast<SkBlendMode>(m);
const GrXPFactory* xpf = GrPorterDuffXPFactory::Get(xfermode);
- GrProcessorSet::Analysis analysis;
- analysis = GrProcessorSet::Analysis(colorInput, coverageType, xpf, caps);
sk_sp<GrXferProcessor> xp(
GrXPFactory::MakeXferProcessor(xpf, colorInput, coverageType, false, caps));
if (!xp) {