blob: 86b277cd92b04d35e9a4d254535f10d57a0eeed0 [file] [log] [blame]
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "src/gpu/ganesh/GrProcessorSet.h"
#include "src/core/SkBlendModePriv.h"
#include "src/gpu/ganesh/GrAppliedClip.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrUserStencilSettings.h"
#include "src/gpu/ganesh/GrXferProcessor.h"
#include "src/gpu/ganesh/effects/GrPorterDuffXferProcessor.h"
const GrProcessorSet& GrProcessorSet::EmptySet() {
static GrProcessorSet gEmpty(GrProcessorSet::Empty::kEmpty);
return gEmpty;
}
GrProcessorSet GrProcessorSet::MakeEmptySet() {
return GrProcessorSet(GrProcessorSet::Empty::kEmpty);
}
GrProcessorSet::GrProcessorSet(GrPaint&& paint) : fXP(paint.getXPFactory()) {
fColorFragmentProcessor = std::move(paint.fColorFragmentProcessor);
fCoverageFragmentProcessor = std::move(paint.fCoverageFragmentProcessor);
SkDEBUGCODE(paint.fAlive = false;)
}
GrProcessorSet::GrProcessorSet(SkBlendMode mode) : fXP(GrXPFactory::FromBlendMode(mode)) {}
GrProcessorSet::GrProcessorSet(std::unique_ptr<GrFragmentProcessor> colorFP)
: fXP((const GrXPFactory*)nullptr) {
SkASSERT(colorFP);
fColorFragmentProcessor = std::move(colorFP);
}
GrProcessorSet::GrProcessorSet(GrProcessorSet&& that)
: fColorFragmentProcessor(std::move(that.fColorFragmentProcessor))
, fCoverageFragmentProcessor(std::move(that.fCoverageFragmentProcessor))
, fXP(std::move(that.fXP))
, fFlags(that.fFlags) {}
GrProcessorSet::~GrProcessorSet() {
if (this->isFinalized() && this->xferProcessor()) {
this->xferProcessor()->unref();
}
}
#if defined(GR_TEST_UTILS)
SkString GrProcessorSet::dumpProcessors() const {
SkString result;
if (this->hasColorFragmentProcessor()) {
result.append("Color Fragment Processor:\n");
result += this->colorFragmentProcessor()->dumpTreeInfo();
} else {
result.append("No color fragment processor.\n");
}
if (this->hasCoverageFragmentProcessor()) {
result.append("Coverage Fragment Processor:\n");
result += this->coverageFragmentProcessor()->dumpTreeInfo();
} else {
result.append("No coverage fragment processors.\n");
}
if (this->isFinalized()) {
result.append("Xfer Processor: ");
if (this->xferProcessor()) {
result.appendf("%s\n", this->xferProcessor()->name());
} else {
result.append("SrcOver\n");
}
} else {
result.append("XP Factory dumping not implemented.\n");
}
return result;
}
#endif
bool GrProcessorSet::operator==(const GrProcessorSet& that) const {
SkASSERT(this->isFinalized());
SkASSERT(that.isFinalized());
if (((fFlags ^ that.fFlags) & ~kFinalized_Flag) ||
this->hasColorFragmentProcessor() != that.hasColorFragmentProcessor() ||
this->hasCoverageFragmentProcessor() != that.hasCoverageFragmentProcessor()) {
return false;
}
if (this->hasColorFragmentProcessor()) {
if (!colorFragmentProcessor()->isEqual(*that.colorFragmentProcessor())) {
return false;
}
}
if (this->hasCoverageFragmentProcessor()) {
if (!coverageFragmentProcessor()->isEqual(*that.coverageFragmentProcessor())) {
return false;
}
}
// Most of the time both of these are null
if (!this->xferProcessor() && !that.xferProcessor()) {
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, const GrUserStencilSettings* userStencil,
const GrCaps& caps, GrClampType clampType, SkPMColor4f* overrideInputColor) {
SkASSERT(!this->isFinalized());
GrProcessorSet::Analysis analysis;
analysis.fCompatibleWithCoverageAsAlpha = GrProcessorAnalysisCoverage::kLCD != coverageInput;
GrColorFragmentProcessorAnalysis colorAnalysis(colorInput, &fColorFragmentProcessor,
this->hasColorFragmentProcessor() ? 1 : 0);
bool hasCoverageFP = this->hasCoverageFragmentProcessor();
bool coverageUsesLocalCoords = false;
if (hasCoverageFP) {
if (!fCoverageFragmentProcessor->compatibleWithCoverageAsAlpha()) {
analysis.fCompatibleWithCoverageAsAlpha = false;
}
coverageUsesLocalCoords |= fCoverageFragmentProcessor->usesSampleCoords();
}
if (clip && clip->hasCoverageFragmentProcessor()) {
hasCoverageFP = true;
const GrFragmentProcessor* clipFP = clip->coverageFragmentProcessor();
analysis.fCompatibleWithCoverageAsAlpha &= clipFP->compatibleWithCoverageAsAlpha();
coverageUsesLocalCoords |= clipFP->usesSampleCoords();
}
int colorFPsToEliminate = colorAnalysis.initialProcessorsToEliminate(overrideInputColor);
analysis.fInputColorType = static_cast<Analysis::PackedInputColorType>(
colorFPsToEliminate ? Analysis::kOverridden_InputColorType
: Analysis::kOriginal_InputColorType);
GrProcessorAnalysisCoverage outputCoverage;
if (GrProcessorAnalysisCoverage::kLCD == coverageInput) {
outputCoverage = GrProcessorAnalysisCoverage::kLCD;
} else if (hasCoverageFP || GrProcessorAnalysisCoverage::kSingleChannel == coverageInput) {
outputCoverage = GrProcessorAnalysisCoverage::kSingleChannel;
} else {
outputCoverage = GrProcessorAnalysisCoverage::kNone;
}
GrXPFactory::AnalysisProperties props = GrXPFactory::GetAnalysisProperties(
this->xpFactory(), colorAnalysis.outputColor(), outputCoverage, caps, clampType);
analysis.fRequiresDstTexture = (props & GrXPFactory::AnalysisProperties::kRequiresDstTexture) ||
colorAnalysis.requiresDstTexture(caps);
analysis.fCompatibleWithCoverageAsAlpha &=
SkToBool(props & GrXPFactory::AnalysisProperties::kCompatibleWithCoverageAsAlpha);
analysis.fRequiresNonOverlappingDraws =
(props & GrXPFactory::AnalysisProperties::kRequiresNonOverlappingDraws) ||
analysis.fRequiresDstTexture;
analysis.fUsesNonCoherentHWBlending =
SkToBool(props & GrXPFactory::AnalysisProperties::kUsesNonCoherentHWBlending);
analysis.fUnaffectedByDstValue =
SkToBool(props & GrXPFactory::AnalysisProperties::kUnaffectedByDstValue);
if (props & GrXPFactory::AnalysisProperties::kIgnoresInputColor) {
colorFPsToEliminate = this->hasColorFragmentProcessor() ? 1 : 0;
analysis.fInputColorType =
static_cast<Analysis::PackedInputColorType>(Analysis::kIgnored_InputColorType);
analysis.fUsesLocalCoords = coverageUsesLocalCoords;
} else {
analysis.fCompatibleWithCoverageAsAlpha &=
colorAnalysis.allProcessorsCompatibleWithCoverageAsAlpha();
analysis.fUsesLocalCoords = coverageUsesLocalCoords || colorAnalysis.usesLocalCoords();
}
if (colorFPsToEliminate) {
SkASSERT(colorFPsToEliminate == 1);
fColorFragmentProcessor = nullptr;
}
analysis.fHasColorFragmentProcessor = this->hasColorFragmentProcessor();
auto xp = GrXPFactory::MakeXferProcessor(this->xpFactory(), colorAnalysis.outputColor(),
outputCoverage, caps, clampType);
fXP.fProcessor = xp.release();
fFlags |= kFinalized_Flag;
analysis.fIsInitialized = true;
#ifdef SK_DEBUG
bool hasXferBarrier =
fXP.fProcessor &&
GrXferBarrierType::kNone_GrXferBarrierType != fXP.fProcessor->xferBarrierType(caps);
bool needsNonOverlappingDraws = analysis.fRequiresDstTexture || hasXferBarrier;
SkASSERT(analysis.fRequiresNonOverlappingDraws == needsNonOverlappingDraws);
#endif
return analysis;
}
void GrProcessorSet::visitProxies(const GrVisitProxyFunc& func) const {
if (this->hasColorFragmentProcessor()) {
fColorFragmentProcessor->visitProxies(func);
}
if (this->hasCoverageFragmentProcessor()) {
fCoverageFragmentProcessor->visitProxies(func);
}
}