diff options
48 files changed, 296 insertions, 323 deletions
diff --git a/gn/gpu.gni b/gn/gpu.gni index e4bdacfd80..a481cfd4ef 100644 --- a/gn/gpu.gni +++ b/gn/gpu.gni @@ -134,8 +134,9 @@ skia_gpu_sources = [ "$_src/gpu/GrPreFlushResourceProvider.h", "$_src/gpu/GrPipeline.cpp", "$_src/gpu/GrPipeline.h", + "$_src/gpu/GrPipelineAnalysis.cpp", + "$_src/gpu/GrPipelineAnalysis.h", "$_src/gpu/GrPipelineBuilder.h", - "$_src/gpu/GrPipelineInput.h", "$_src/gpu/GrPrimitiveProcessor.cpp", "$_src/gpu/GrPrimitiveProcessor.h", "$_src/gpu/GrProcessorSet.cpp", @@ -144,8 +145,6 @@ skia_gpu_sources = [ "$_src/gpu/GrProgramDesc.h", "$_src/gpu/GrProcessor.cpp", "$_src/gpu/GrProcessorUnitTest.cpp", - "$_src/gpu/GrProcOptInfo.cpp", - "$_src/gpu/GrProcOptInfo.h", "$_src/gpu/GrGpuResourceRef.cpp", "$_src/gpu/GrQuad.h", "$_src/gpu/GrRect.h", diff --git a/src/gpu/GrFragmentProcessor.cpp b/src/gpu/GrFragmentProcessor.cpp index 0d1bfadcc5..fdec93ba9a 100644 --- a/src/gpu/GrFragmentProcessor.cpp +++ b/src/gpu/GrFragmentProcessor.cpp @@ -8,13 +8,13 @@ #include "GrFragmentProcessor.h" #include "GrCoordTransform.h" #include "GrPipeline.h" -#include "GrProcOptInfo.h" +#include "GrPipelineAnalysis.h" +#include "effects/GrConstColorProcessor.h" +#include "effects/GrXfermodeFragmentProcessor.h" #include "glsl/GrGLSLFragmentProcessor.h" #include "glsl/GrGLSLFragmentShaderBuilder.h" #include "glsl/GrGLSLProgramDataManager.h" #include "glsl/GrGLSLUniformHandler.h" -#include "effects/GrConstColorProcessor.h" -#include "effects/GrXfermodeFragmentProcessor.h" GrFragmentProcessor::~GrFragmentProcessor() { // If we got here then our ref count must have reached zero, so we will have converted refs @@ -466,7 +466,7 @@ sk_sp<GrFragmentProcessor> GrFragmentProcessor::RunInSeries(sk_sp<GrFragmentProc return series[0]; } // Run the through the series, do the invariant output processing, and look for eliminations. - GrProcOptInfo info; + GrColorFragmentProcessorAnalysis info; info.analyzeProcessors(sk_sp_address_as_pointer_address(series), cnt); SkTArray<sk_sp<GrFragmentProcessor>> replacementSeries; GrColor4f knownColor; diff --git a/src/gpu/GrPaint.cpp b/src/gpu/GrPaint.cpp index 5dc998eb27..6c5a041c94 100644 --- a/src/gpu/GrPaint.cpp +++ b/src/gpu/GrPaint.cpp @@ -6,7 +6,6 @@ */ #include "GrPaint.h" -#include "GrProcOptInfo.h" #include "GrXferProcessor.h" #include "effects/GrCoverageSetOpXP.h" #include "effects/GrPorterDuffXferProcessor.h" diff --git a/src/gpu/GrPipeline.cpp b/src/gpu/GrPipeline.cpp index 00dc9848a0..adcdd0fe02 100644 --- a/src/gpu/GrPipeline.cpp +++ b/src/gpu/GrPipeline.cpp @@ -11,7 +11,6 @@ #include "GrCaps.h" #include "GrGpu.h" #include "GrPipelineBuilder.h" -#include "GrProcOptInfo.h" #include "GrRenderTargetContext.h" #include "GrRenderTargetOpList.h" #include "GrRenderTargetPriv.h" diff --git a/src/gpu/GrPipeline.h b/src/gpu/GrPipeline.h index 7f2ac79b4f..21693426f1 100644 --- a/src/gpu/GrPipeline.h +++ b/src/gpu/GrPipeline.h @@ -13,7 +13,6 @@ #include "GrNonAtomicRef.h" #include "GrPendingProgramElement.h" #include "GrPrimitiveProcessor.h" -#include "GrProcOptInfo.h" #include "GrProcessorSet.h" #include "GrProgramDesc.h" #include "GrScissorState.h" diff --git a/src/gpu/GrProcOptInfo.cpp b/src/gpu/GrPipelineAnalysis.cpp index 902a7c77e4..3512c940b0 100644 --- a/src/gpu/GrProcOptInfo.cpp +++ b/src/gpu/GrPipelineAnalysis.cpp @@ -5,11 +5,12 @@ * found in the LICENSE file. */ -#include "GrProcOptInfo.h" +#include "GrPipelineAnalysis.h" #include "GrGeometryProcessor.h" #include "ops/GrDrawOp.h" -void GrProcOptInfo::analyzeProcessors(const GrFragmentProcessor* const* processors, int cnt) { +void GrColorFragmentProcessorAnalysis::analyzeProcessors( + const GrFragmentProcessor* const* processors, int cnt) { for (int i = 0; i < cnt; ++i) { bool knowCurrentOutput = fProcessorsVisitedWithKnownOutput == fTotalProcessorsVisited; if (fUsesLocalCoords && !knowCurrentOutput && @@ -18,8 +19,8 @@ void GrProcOptInfo::analyzeProcessors(const GrFragmentProcessor* const* processo return; } const GrFragmentProcessor* fp = processors[i]; - if (knowCurrentOutput && fp->hasConstantOutputForConstantInput(fLastKnownOutputColor, - &fLastKnownOutputColor)) { + if (knowCurrentOutput && + fp->hasConstantOutputForConstantInput(fLastKnownOutputColor, &fLastKnownOutputColor)) { ++fProcessorsVisitedWithKnownOutput; fIsOpaque = fLastKnownOutputColor.isOpaque(); // We reset these since the caller is expected to not use the earlier fragment diff --git a/src/gpu/GrProcOptInfo.h b/src/gpu/GrPipelineAnalysis.h index 549fb7a60b..4f553b0ce5 100644 --- a/src/gpu/GrProcOptInfo.h +++ b/src/gpu/GrPipelineAnalysis.h @@ -5,27 +5,73 @@ * found in the LICENSE file. */ -#ifndef GrProcOptInfo_DEFINED -#define GrProcOptInfo_DEFINED +#ifndef GrPipelineAnalysis_DEFINED +#define GrPipelineAnalysis_DEFINED #include "GrColor.h" -#include "GrPipelineInput.h" class GrDrawOp; class GrFragmentProcessor; class GrPrimitiveProcessor; +class GrPipelineAnalysisColor { +public: + enum class Opaque { + kNo, + kYes, + }; + + GrPipelineAnalysisColor(Opaque opaque = Opaque::kNo) + : fFlags(opaque == Opaque::kYes ? kIsOpaque_Flag : 0) {} + + GrPipelineAnalysisColor(GrColor color) { this->setToConstant(color); } + + void setToConstant(GrColor color) { + fColor = color; + if (GrColorIsOpaque(color)) { + fFlags = kColorIsKnown_Flag | kIsOpaque_Flag; + } else { + fFlags = kColorIsKnown_Flag; + } + } + + void setToUnknown() { fFlags = 0; } + + void setToUnknownOpaque() { fFlags = kIsOpaque_Flag; } + + bool isOpaque() const { return SkToBool(kIsOpaque_Flag & fFlags); } + + bool isConstant(GrColor* color) const { + if (kColorIsKnown_Flag & fFlags) { + *color = fColor; + return true; + } + return false; + } + +private: + enum Flags { + kColorIsKnown_Flag = 0x1, + kIsOpaque_Flag = 0x2, + }; + uint32_t fFlags; + GrColor fColor; +}; + +enum class GrPipelineAnalysisCoverage { kNone, kSingleChannel, kLCD }; + /** - * GrProcOptInfo gathers invariant data from a set of processor stages.It is used to recognize - * optimizations related to eliminating stages and vertex attributes that aren't necessary for a - * draw. + * GrColorFragmentProcessorAnalysis gathers invariant data from a set of color fragment processor. + * It is used to recognize optimizations that can simplify the generated shader or make blending + * more effecient. */ -class GrProcOptInfo { +class GrColorFragmentProcessorAnalysis { public: - GrProcOptInfo() = default; + GrColorFragmentProcessorAnalysis() = default; - GrProcOptInfo(const GrPipelineInput& input) : GrProcOptInfo() { - fAllProcessorsCompatibleWithCoverageAsAlpha = !input.isLCDCoverage(); + GrColorFragmentProcessorAnalysis(const GrPipelineAnalysisColor& input) + : GrColorFragmentProcessorAnalysis() { + fAllProcessorsCompatibleWithCoverageAsAlpha = true; fIsOpaque = input.isOpaque(); GrColor color; if (input.isConstant(&color)) { @@ -34,7 +80,9 @@ public: } } - void reset(const GrPipelineInput& input) { *this = GrProcOptInfo(input); } + void reset(const GrPipelineAnalysisColor& input) { + *this = GrColorFragmentProcessorAnalysis(input); + } /** * Runs through a series of processors and updates calculated values. This can be called @@ -80,14 +128,12 @@ public: return SkTMax(0, fProcessorsVisitedWithKnownOutput); } - bool hasKnownOutputColor(GrColor* knownOutputColor = nullptr) const { + GrPipelineAnalysisColor outputColor() const { if (fProcessorsVisitedWithKnownOutput != fTotalProcessorsVisited) { - return false; - } - if (knownOutputColor) { - *knownOutputColor = fLastKnownOutputColor.toGrColor(); + return GrPipelineAnalysisColor(fIsOpaque ? GrPipelineAnalysisColor::Opaque::kYes + : GrPipelineAnalysisColor::Opaque::kNo); } - return true; + return GrPipelineAnalysisColor(fLastKnownOutputColor.toGrColor()); } private: diff --git a/src/gpu/GrPipelineInput.h b/src/gpu/GrPipelineInput.h deleted file mode 100644 index 7079f36c63..0000000000 --- a/src/gpu/GrPipelineInput.h +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright 2014 Google Inc. - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#ifndef GrPipelineInput_DEFINED -#define GrPipelineInput_DEFINED - -#include "GrColor.h" - -/** - * This describes the color or coverage input that will be seen by the first color or coverage stage - * of a GrPipeline. This is also the GrPrimitiveProcessor color or coverage *output*. - */ -struct GrPipelineInput { - enum class Opaque { - kNo, - kYes, - }; - - GrPipelineInput(Opaque opaque = Opaque::kNo) - : fFlags(opaque == Opaque::kYes ? kIsOpaque_Flag : 0) {} - - GrPipelineInput(GrColor color) : fFlags(kColorIsKnown_Flag), fColor(color) {} - - void setToConstant(GrColor color) { - fColor = color; - if (GrColorIsOpaque(color)) { - fFlags = kColorIsKnown_Flag | kIsOpaque_Flag; - } else { - fFlags = kColorIsKnown_Flag; - } - } - - void setToUnknown() { fFlags = 0; } - - void setToUnknownOpaque() { fFlags = kIsOpaque_Flag; } - - void setToSolidCoverage() { - fColor = GrColor_WHITE; - fFlags = kColorIsKnown_Flag | kIsOpaque_Flag; - } - - void setToScalar(uint8_t alpha) { - this->setToConstant(GrColorPackRGBA(alpha, alpha, alpha, alpha)); - } - - void setToLCDCoverage() { fFlags = kIsLCDCoverage_Flag; } - - bool isLCDCoverage() const { return SkToBool(kIsLCDCoverage_Flag & fFlags); } - - bool isOpaque() const { return SkToBool(kIsOpaque_Flag & fFlags); } - - bool isSolidWhite() const { return (kColorIsKnown_Flag & fFlags) && GrColor_WHITE == fColor; } - - bool isConstant(GrColor* color) const { - if (kColorIsKnown_Flag & fFlags) { - *color = fColor; - return true; - } - return false; - } - -private: - enum Flags { - kColorIsKnown_Flag = 0x1, - kIsOpaque_Flag = 0x2, - kIsLCDCoverage_Flag = 0x4, - }; - uint32_t fFlags; - GrColor fColor; -}; - -#endif diff --git a/src/gpu/GrProcessorSet.cpp b/src/gpu/GrProcessorSet.cpp index a8423b6894..4a508921b1 100644 --- a/src/gpu/GrProcessorSet.cpp +++ b/src/gpu/GrProcessorSet.cpp @@ -8,7 +8,7 @@ #include "GrProcessorSet.h" #include "GrAppliedClip.h" #include "GrCaps.h" -#include "GrProcOptInfo.h" +#include "GrPipelineAnalysis.h" GrProcessorSet::GrProcessorSet(GrPaint&& paint) { fXPFactory = paint.fXPFactory; @@ -80,13 +80,14 @@ bool GrProcessorSet::operator==(const GrProcessorSet& that) const { ////////////////////////////////////////////////////////////////////////////// -void GrProcessorSet::FragmentProcessorAnalysis::internalInit(const GrPipelineInput& colorInput, - const GrPipelineInput coverageInput, - const GrProcessorSet& processors, - const GrFragmentProcessor* clipFP, - const GrCaps& caps) { - GrProcOptInfo colorInfo(colorInput); - fCompatibleWithCoverageAsAlpha = !coverageInput.isLCDCoverage(); +void GrProcessorSet::FragmentProcessorAnalysis::internalInit( + const GrPipelineAnalysisColor& colorInput, + const GrPipelineAnalysisCoverage coverageInput, + const GrProcessorSet& processors, + const GrFragmentProcessor* clipFP, + const GrCaps& caps) { + GrColorFragmentProcessorAnalysis colorInfo(colorInput); + fCompatibleWithCoverageAsAlpha = GrPipelineAnalysisCoverage::kLCD != coverageInput; fValidInputColor = colorInput.isConstant(&fInputColor); const GrFragmentProcessor* const* fps = @@ -115,27 +116,27 @@ void GrProcessorSet::FragmentProcessorAnalysis::internalInit(const GrPipelineInp fInitialColorProcessorsToEliminate = colorInfo.initialProcessorsToEliminate(&fInputColor); fValidInputColor |= SkToBool(fInitialColorProcessorsToEliminate); - bool opaque = colorInfo.isOpaque(); - if (colorInfo.hasKnownOutputColor(&fKnownOutputColor)) { - fOutputColorType = static_cast<unsigned>(opaque ? ColorType::kOpaqueConstant - : ColorType::kConstant); - } else if (opaque) { + GrPipelineAnalysisColor outputColor = colorInfo.outputColor(); + if (outputColor.isConstant(&fKnownOutputColor)) { + fOutputColorType = static_cast<unsigned>(outputColor.isOpaque() ? ColorType::kOpaqueConstant + : ColorType::kConstant); + } else if (outputColor.isOpaque()) { fOutputColorType = static_cast<unsigned>(ColorType::kOpaque); } else { fOutputColorType = static_cast<unsigned>(ColorType::kUnknown); } - if (coverageInput.isLCDCoverage()) { - fOutputCoverageType = static_cast<unsigned>(CoverageType::kLCD); + if (GrPipelineAnalysisCoverage::kLCD == coverageInput) { + fOutputCoverageType = static_cast<unsigned>(GrPipelineAnalysisCoverage::kLCD); + } else if (hasCoverageFP || GrPipelineAnalysisCoverage::kSingleChannel == coverageInput) { + fOutputCoverageType = static_cast<unsigned>(GrPipelineAnalysisCoverage::kSingleChannel); } else { - fOutputCoverageType = hasCoverageFP || !coverageInput.isSolidWhite() - ? static_cast<unsigned>(CoverageType::kSingleChannel) - : static_cast<unsigned>(CoverageType::kNone); + fOutputCoverageType = static_cast<unsigned>(GrPipelineAnalysisCoverage::kNone); } } -void GrProcessorSet::FragmentProcessorAnalysis::init(const GrPipelineInput& colorInput, - const GrPipelineInput coverageInput, +void GrProcessorSet::FragmentProcessorAnalysis::init(const GrPipelineAnalysisColor& colorInput, + const GrPipelineAnalysisCoverage coverageInput, const GrProcessorSet& processors, const GrAppliedClip* appliedClip, const GrCaps& caps) { @@ -146,16 +147,19 @@ void GrProcessorSet::FragmentProcessorAnalysis::init(const GrPipelineInput& colo } GrProcessorSet::FragmentProcessorAnalysis::FragmentProcessorAnalysis( - const GrPipelineInput& colorInput, const GrPipelineInput coverageInput, const GrCaps& caps) + const GrPipelineAnalysisColor& colorInput, + const GrPipelineAnalysisCoverage coverageInput, + const GrCaps& caps) : FragmentProcessorAnalysis() { this->internalInit(colorInput, coverageInput, GrProcessorSet(GrPaint()), nullptr, caps); } -void GrProcessorSet::analyzeAndEliminateFragmentProcessors(FragmentProcessorAnalysis* analysis, - const GrPipelineInput& colorInput, - const GrPipelineInput coverageInput, - const GrAppliedClip* clip, - const GrCaps& caps) { +void GrProcessorSet::analyzeAndEliminateFragmentProcessors( + FragmentProcessorAnalysis* analysis, + const GrPipelineAnalysisColor& colorInput, + const GrPipelineAnalysisCoverage 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) { diff --git a/src/gpu/GrProcessorSet.h b/src/gpu/GrProcessorSet.h index 71ab2d0f9f..bfad769a18 100644 --- a/src/gpu/GrProcessorSet.h +++ b/src/gpu/GrProcessorSet.h @@ -10,7 +10,7 @@ #include "GrFragmentProcessor.h" #include "GrPaint.h" -#include "GrPipelineInput.h" +#include "GrPipelineAnalysis.h" #include "SkTemplates.h" class GrAppliedClip; @@ -79,16 +79,16 @@ public: : fIsInitializedWithProcessorSet(false) , fCompatibleWithCoverageAsAlpha(true) , fValidInputColor(false) - , fOutputCoverageType(static_cast<unsigned>(CoverageType::kNone)) + , fOutputCoverageType(static_cast<unsigned>(GrPipelineAnalysisCoverage::kNone)) , fOutputColorType(static_cast<unsigned>(ColorType::kUnknown)) , fInitialColorProcessorsToEliminate(0) {} // This version is used by a unit test that assumes no clip, no processors, and no PLS. - FragmentProcessorAnalysis(const GrPipelineInput& colorInput, - const GrPipelineInput coverageInput, const GrCaps&); + FragmentProcessorAnalysis(const GrPipelineAnalysisColor&, GrPipelineAnalysisCoverage, + const GrCaps&); - void init(const GrPipelineInput& colorInput, const GrPipelineInput coverageInput, - const GrProcessorSet&, const GrAppliedClip*, const GrCaps&); + void init(const GrPipelineAnalysisColor&, GrPipelineAnalysisCoverage, const GrProcessorSet&, + const GrAppliedClip*, const GrCaps&); bool isInitializedWithProcessorSet() const { return fIsInitializedWithProcessorSet; } @@ -132,19 +132,19 @@ public: } return constant; } - bool hasCoverage() const { return CoverageType::kNone != this->outputCoverageType(); } - bool hasLCDCoverage() const { return CoverageType::kLCD == this->outputCoverageType(); } + GrPipelineAnalysisCoverage outputCoverageType() const { + return static_cast<GrPipelineAnalysisCoverage>(fOutputCoverageType); + } + bool hasCoverage() const { + return this->outputCoverageType() != GrPipelineAnalysisCoverage::kNone; + } private: enum class ColorType : unsigned { kUnknown, kOpaqueConstant, kConstant, kOpaque }; - enum class CoverageType : unsigned { kNone, kSingleChannel, kLCD }; - CoverageType outputCoverageType() const { - return static_cast<CoverageType>(fOutputCoverageType); - } ColorType outputColorType() const { return static_cast<ColorType>(fOutputColorType); } - void internalInit(const GrPipelineInput& colorInput, const GrPipelineInput coverageInput, + void internalInit(const GrPipelineAnalysisColor&, const GrPipelineAnalysisCoverage, const GrProcessorSet&, const GrFragmentProcessor* clipFP, const GrCaps&); // MSVS 2015 won't pack a bool with an unsigned. @@ -166,8 +166,8 @@ public: GR_STATIC_ASSERT(sizeof(FragmentProcessorAnalysis) == 2 * sizeof(GrColor) + sizeof(uint32_t)); void analyzeAndEliminateFragmentProcessors(FragmentProcessorAnalysis*, - const GrPipelineInput& colorInput, - const GrPipelineInput coverageInput, + const GrPipelineAnalysisColor& colorInput, + const GrPipelineAnalysisCoverage coverageInput, const GrAppliedClip*, const GrCaps&); private: diff --git a/src/gpu/GrXferProcessor.cpp b/src/gpu/GrXferProcessor.cpp index 32ab45c65e..bd63a0a40b 100644 --- a/src/gpu/GrXferProcessor.cpp +++ b/src/gpu/GrXferProcessor.cpp @@ -7,7 +7,6 @@ #include "GrXferProcessor.h" #include "GrPipeline.h" -#include "GrProcOptInfo.h" #include "gl/GrGLCaps.h" GrXferProcessor::GrXferProcessor() diff --git a/src/gpu/GrXferProcessor.h b/src/gpu/GrXferProcessor.h index 35ce5fa4a2..bdf6f7d50c 100644 --- a/src/gpu/GrXferProcessor.h +++ b/src/gpu/GrXferProcessor.h @@ -17,7 +17,6 @@ class GrShaderCaps; class GrGLSLXferProcessor; -class GrProcOptInfo; /** * Barriers for blending. When a shader reads the dst directly, an Xfer barrier is sometimes diff --git a/src/gpu/effects/GrCoverageSetOpXP.cpp b/src/gpu/effects/GrCoverageSetOpXP.cpp index 52ebaad309..1013706842 100644 --- a/src/gpu/effects/GrCoverageSetOpXP.cpp +++ b/src/gpu/effects/GrCoverageSetOpXP.cpp @@ -8,10 +8,9 @@ #include "effects/GrCoverageSetOpXP.h" #include "GrCaps.h" #include "GrColor.h" -#include "GrRenderTargetContext.h" #include "GrPipeline.h" #include "GrProcessor.h" -#include "GrProcOptInfo.h" +#include "GrRenderTargetContext.h" #include "glsl/GrGLSLBlend.h" #include "glsl/GrGLSLFragmentShaderBuilder.h" #include "glsl/GrGLSLUniformHandler.h" diff --git a/src/gpu/effects/GrCoverageSetOpXP.h b/src/gpu/effects/GrCoverageSetOpXP.h index 184ef4e56c..a0cb0c518c 100644 --- a/src/gpu/effects/GrCoverageSetOpXP.h +++ b/src/gpu/effects/GrCoverageSetOpXP.h @@ -12,8 +12,6 @@ #include "GrXferProcessor.h" #include "SkRegion.h" -class GrProcOptInfo; - // See the comment above GrXPFactory's definition about this warning suppression. #if defined(__GNUC__) || defined(__clang) #pragma GCC diagnostic push diff --git a/src/gpu/effects/GrCustomXfermode.cpp b/src/gpu/effects/GrCustomXfermode.cpp index 37e4c16765..1f2771cb52 100644 --- a/src/gpu/effects/GrCustomXfermode.cpp +++ b/src/gpu/effects/GrCustomXfermode.cpp @@ -52,12 +52,12 @@ static constexpr GrBlendEquation hw_blend_equation(SkBlendMode mode) { #undef EQ_OFFSET } -static bool can_use_hw_blend_equation(GrBlendEquation equation, bool isLCDCoverage, +static bool can_use_hw_blend_equation(GrBlendEquation equation, GrPipelineAnalysisCoverage coverage, const GrCaps& caps) { if (!caps.advancedBlendEquationSupport()) { return false; } - if (isLCDCoverage) { + if (GrPipelineAnalysisCoverage::kLCD == coverage) { return false; // LCD coverage must be applied after the blend equation. } if (caps.canUseAdvancedBlendEquation(equation)) { @@ -347,7 +347,7 @@ GrXferProcessor* CustomXPFactory::onCreateXferProcessor(const GrCaps& caps, bool hasMixedSamples, const DstTexture* dstTexture) const { SkASSERT(GrCustomXfermode::IsSupportedMode(fMode)); - if (can_use_hw_blend_equation(fHWBlendEquation, analysis.hasLCDCoverage(), caps)) { + if (can_use_hw_blend_equation(fHWBlendEquation, analysis.outputCoverageType(), caps)) { SkASSERT(!dstTexture || !dstTexture->texture()); return new CustomXP(fMode, fHWBlendEquation); } @@ -356,7 +356,7 @@ GrXferProcessor* CustomXPFactory::onCreateXferProcessor(const GrCaps& caps, bool CustomXPFactory::willReadDstInShader(const GrCaps& caps, const FragmentProcessorAnalysis& analysis) const { - return !can_use_hw_blend_equation(fHWBlendEquation, analysis.hasLCDCoverage(), caps); + return !can_use_hw_blend_equation(fHWBlendEquation, analysis.outputCoverageType(), caps); } GR_DEFINE_XP_FACTORY_TEST(CustomXPFactory); diff --git a/src/gpu/effects/GrDisableColorXP.h b/src/gpu/effects/GrDisableColorXP.h index 78442f4125..821ad2768e 100644 --- a/src/gpu/effects/GrDisableColorXP.h +++ b/src/gpu/effects/GrDisableColorXP.h @@ -12,8 +12,6 @@ #include "GrXferProcessor.h" #include "SkRefCnt.h" -class GrProcOptInfo; - // See the comment above GrXPFactory's definition about this warning suppression. #if defined(__GNUC__) || defined(__clang) #pragma GCC diagnostic push diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp index 3dc5325fd9..aa416e0d1b 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 "GrProcOptInfo.h" #include "GrTypes.h" #include "GrXferProcessor.h" #include "glsl/GrGLSLBlend.h" @@ -19,7 +19,6 @@ #include "glsl/GrGLSLProgramDataManager.h" #include "glsl/GrGLSLUniformHandler.h" #include "glsl/GrGLSLXferProcessor.h" -#include <utility> /** * Wraps the shader outputs and HW blend state that comprise a Porter Duff blend mode with coverage. @@ -736,7 +735,7 @@ GrXferProcessor* GrPorterDuffXPFactory::onCreateXferProcessor( bool hasMixedSamples, const DstTexture* dstTexture) const { BlendFormula blendFormula; - if (analysis.hasLCDCoverage()) { + if (analysis.outputCoverageType() == GrPipelineAnalysisCoverage::kLCD) { if (SkBlendMode::kSrcOver == fBlendMode && analysis.hasKnownOutputColor() && !caps.shaderCaps()->dualSourceBlendingSupport() && !caps.shaderCaps()->dstReadInShaderSupport()) { @@ -775,7 +774,7 @@ bool GrPorterDuffXPFactory::willReadDstInShader(const GrCaps& caps, // When we have four channel coverage we always need to read the dst in order to correctly // blend. The one exception is when we are using srcover mode and we know the input color into // the XP. - if (analysis.hasLCDCoverage()) { + if (analysis.outputCoverageType() == GrPipelineAnalysisCoverage::kLCD) { if (SkBlendMode::kSrcOver == fBlendMode && analysis.hasKnownOutputColor() && !caps.shaderCaps()->dstReadInShaderSupport()) { return false; @@ -838,7 +837,7 @@ GrXferProcessor* GrPorterDuffXPFactory::CreateSrcOverXferProcessor( // 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 (!analysis.hasLCDCoverage()) { + if (analysis.outputCoverageType() != GrPipelineAnalysisCoverage::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 @@ -880,7 +879,7 @@ bool GrPorterDuffXPFactory::WillSrcOverNeedDstTexture(const GrCaps& caps, // When we have four channel coverage we always need to read the dst in order to correctly // blend. The one exception is when we are using srcover mode and we know the input color // into the XP. - if (analysis.hasLCDCoverage()) { + if (analysis.outputCoverageType() == GrPipelineAnalysisCoverage::kLCD) { if (analysis.hasKnownOutputColor() && !caps.shaderCaps()->dstReadInShaderSupport()) { return false; } diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.h b/src/gpu/effects/GrPorterDuffXferProcessor.h index 719bd18527..23f1e9c5c5 100644 --- a/src/gpu/effects/GrPorterDuffXferProcessor.h +++ b/src/gpu/effects/GrPorterDuffXferProcessor.h @@ -12,8 +12,6 @@ #include "GrXferProcessor.h" #include "SkBlendMode.h" -class GrProcOptInfo; - // See the comment above GrXPFactory's definition about this warning suppression. #if defined(__GNUC__) || defined(__clang) #pragma GCC diagnostic push diff --git a/src/gpu/instanced/InstancedRendering.cpp b/src/gpu/instanced/InstancedRendering.cpp index f97c342ebe..e67a8be977 100644 --- a/src/gpu/instanced/InstancedRendering.cpp +++ b/src/gpu/instanced/InstancedRendering.cpp @@ -334,12 +334,12 @@ void InstancedRendering::Op::appendParamsTexel(SkScalar x, SkScalar y, SkScalar bool InstancedRendering::Op::xpRequiresDstTexture(const GrCaps& caps, const GrAppliedClip* clip) { GrProcessorSet::FragmentProcessorAnalysis analysis; - GrPipelineInput coverageInput; + GrPipelineAnalysisCoverage coverageInput; if (GrAAType::kCoverage == fInfo.aaType() || (GrAAType::kNone == fInfo.aaType() && !fInfo.isSimpleRects() && fInfo.fCannotDiscard)) { - coverageInput = GrPipelineInput(); + coverageInput = GrPipelineAnalysisCoverage::kSingleChannel; } else { - coverageInput = GrColor_WHITE; + coverageInput = GrPipelineAnalysisCoverage::kNone; } fProcessors.analyzeAndEliminateFragmentProcessors(&analysis, this->getSingleInstance().fColor, coverageInput, clip, caps); @@ -470,18 +470,18 @@ void InstancedRendering::Op::onExecute(GrOpFlushState* state) { state->gpu()->handleDirtyContext(); GrProcessorSet::FragmentProcessorAnalysis analysis; - GrPipelineInput coverageInput; + GrPipelineAnalysisCoverage coverageInput; if (GrAAType::kCoverage == fInfo.aaType() || (GrAAType::kNone == fInfo.aaType() && !fInfo.isSimpleRects() && fInfo.fCannotDiscard)) { - coverageInput = GrPipelineInput(); + coverageInput = GrPipelineAnalysisCoverage::kSingleChannel; } else { - coverageInput = GrColor_WHITE; + coverageInput = GrPipelineAnalysisCoverage::kNone; } - GrPipelineInput colorInput; + GrPipelineAnalysisColor colorInput; if (fDrawColorsAreSame) { colorInput = fHeadDraw->fInstance.fColor; } else if (fDrawColorsAreOpaque) { - colorInput = GrPipelineInput::Opaque::kYes; + colorInput = GrPipelineAnalysisColor::Opaque::kYes; } const GrAppliedClip* clip = state->drawOpArgs().fAppliedClip; analysis.init(colorInput, coverageInput, fProcessors, clip, state->caps()); diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp index e316fecc5f..79259b4aea 100644 --- a/src/gpu/ops/GrAAConvexPathRenderer.cpp +++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp @@ -747,9 +747,10 @@ private: this->setTransformedBounds(path.getBounds(), viewMatrix, HasAABloat::kYes, IsZeroArea::kNo); } - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrAAFillRectOp.cpp b/src/gpu/ops/GrAAFillRectOp.cpp index 850a3c9739..c6aadb92ed 100644 --- a/src/gpu/ops/GrAAFillRectOp.cpp +++ b/src/gpu/ops/GrAAFillRectOp.cpp @@ -203,9 +203,10 @@ public: } private: - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(this->first()->color()); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(this->first()->color()); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void onPrepareDraws(Target* target) const override { diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp index ec2610400f..494138d7b0 100644 --- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp +++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp @@ -710,9 +710,10 @@ private: IsZeroArea::kYes); } - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp index bdec758eaf..c9add9d3e9 100644 --- a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp +++ b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp @@ -172,9 +172,10 @@ private: this->setTransformedBounds(bounds, viewMatrix, HasAABloat::kYes, IsZeroArea::kNo); } - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fPaths[0].fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fPaths[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrAAStrokeRectOp.cpp b/src/gpu/ops/GrAAStrokeRectOp.cpp index b684782f23..89739e6116 100644 --- a/src/gpu/ops/GrAAStrokeRectOp.cpp +++ b/src/gpu/ops/GrAAStrokeRectOp.cpp @@ -174,9 +174,10 @@ public: private: AAStrokeRectOp() : INHERITED(ClassID()) {} - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fRects[0].fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fRects[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations&) override; void onPrepareDraws(Target*) const override; diff --git a/src/gpu/ops/GrAnalyticRectOp.cpp b/src/gpu/ops/GrAnalyticRectOp.cpp index 45e20f0dbc..87922cc60c 100644 --- a/src/gpu/ops/GrAnalyticRectOp.cpp +++ b/src/gpu/ops/GrAnalyticRectOp.cpp @@ -269,9 +269,10 @@ public: } private: - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fGeoData[0].fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fGeoData[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrAtlasTextOp.cpp b/src/gpu/ops/GrAtlasTextOp.cpp index e723bd01f3..f8c5443854 100644 --- a/src/gpu/ops/GrAtlasTextOp.cpp +++ b/src/gpu/ops/GrAtlasTextOp.cpp @@ -46,24 +46,25 @@ SkString GrAtlasTextOp::dumpInfo() const { return str; } -void GrAtlasTextOp::getFragmentProcessorAnalysisInputs( - FragmentProcessorAnalysisInputs* input) const { +void GrAtlasTextOp::getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const { if (kColorBitmapMask_MaskType == fMaskType) { - input->colorInput()->setToUnknown(); + color->setToUnknown(); } else { - input->colorInput()->setToConstant(fColor); + color->setToConstant(fColor); } switch (fMaskType) { case kGrayscaleDistanceField_MaskType: case kGrayscaleCoverageMask_MaskType: - input->coverageInput()->setToUnknown(); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; break; case kLCDCoverageMask_MaskType: case kLCDDistanceField_MaskType: - input->coverageInput()->setToLCDCoverage(); + *coverage = GrPipelineAnalysisCoverage::kLCD; break; case kColorBitmapMask_MaskType: - input->coverageInput()->setToSolidCoverage(); + *coverage = GrPipelineAnalysisCoverage::kNone; + break; } } diff --git a/src/gpu/ops/GrAtlasTextOp.h b/src/gpu/ops/GrAtlasTextOp.h index 699503a8cb..8c08544f7b 100644 --- a/src/gpu/ops/GrAtlasTextOp.h +++ b/src/gpu/ops/GrAtlasTextOp.h @@ -99,7 +99,8 @@ public: SkString dumpInfo() const override; private: - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs*) const override; + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor*, + GrPipelineAnalysisCoverage*) const override; void applyPipelineOptimizations(const GrPipelineOptimizations&) override; struct FlushInfo { diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp index 1372a8b466..9dfacded7f 100644 --- a/src/gpu/ops/GrDashOp.cpp +++ b/src/gpu/ops/GrDashOp.cpp @@ -296,9 +296,10 @@ private: this->setTransformedBounds(bounds, combinedMatrix, aaBloat, zeroArea); } - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrDefaultPathRenderer.cpp b/src/gpu/ops/GrDefaultPathRenderer.cpp index 300090d40c..62c9d45439 100644 --- a/src/gpu/ops/GrDefaultPathRenderer.cpp +++ b/src/gpu/ops/GrDefaultPathRenderer.cpp @@ -132,9 +132,11 @@ private: isHairline ? IsZeroArea::kYes : IsZeroArea::kNo); } - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fColor); - input->coverageInput()->setToScalar(this->coverage()); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fColor); + *coverage = this->coverage() == 0xff ? GrPipelineAnalysisCoverage::kNone + : GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrDrawAtlasOp.h b/src/gpu/ops/GrDrawAtlasOp.h index cde345ed8e..a39a7a92f2 100644 --- a/src/gpu/ops/GrDrawAtlasOp.h +++ b/src/gpu/ops/GrDrawAtlasOp.h @@ -39,13 +39,14 @@ private: GrDrawAtlasOp(GrColor color, const SkMatrix& viewMatrix, int spriteCount, const SkRSXform* xforms, const SkRect* rects, const SkColor* colors); - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { if (this->hasColors()) { - input->colorInput()->setToUnknown(); + color->setToUnknown(); } else { - input->colorInput()->setToConstant(fGeoData[0].fColor); + color->setToConstant(fGeoData[0].fColor); } - input->coverageInput()->setToSolidCoverage(); + *coverage = GrPipelineAnalysisCoverage::kNone; } void onPrepareDraws(Target*) const override; diff --git a/src/gpu/ops/GrDrawPathOp.h b/src/gpu/ops/GrDrawPathOp.h index 70a543f3e5..b1ce2dfe5a 100644 --- a/src/gpu/ops/GrDrawPathOp.h +++ b/src/gpu/ops/GrDrawPathOp.h @@ -43,8 +43,8 @@ protected: GrPipelineOptimizations initPipeline(const GrOpFlushState&, GrPipeline*); const GrProcessorSet::FragmentProcessorAnalysis& doFragmentProcessorAnalysis( const GrCaps& caps, const GrAppliedClip* clip) { - fProcessorSet.analyzeAndEliminateFragmentProcessors(&fAnalysis, fAnalysis.inputColor(), - GrColor_WHITE, clip, caps); + fProcessorSet.analyzeAndEliminateFragmentProcessors( + &fAnalysis, fAnalysis.inputColor(), GrPipelineAnalysisCoverage::kNone, clip, caps); return fAnalysis; } const GrProcessorSet::FragmentProcessorAnalysis& fragmentProcessorAnalysis() const { diff --git a/src/gpu/ops/GrDrawVerticesOp.cpp b/src/gpu/ops/GrDrawVerticesOp.cpp index 7c59d61e74..d8f91fe946 100644 --- a/src/gpu/ops/GrDrawVerticesOp.cpp +++ b/src/gpu/ops/GrDrawVerticesOp.cpp @@ -75,13 +75,13 @@ GrDrawVerticesOp::GrDrawVerticesOp(sk_sp<SkVertices> vertices, GrPrimitiveType p } void GrDrawVerticesOp::getFragmentProcessorAnalysisInputs( - FragmentProcessorAnalysisInputs* input) const { + GrPipelineAnalysisColor* color, GrPipelineAnalysisCoverage* coverage) const { if (this->requiresPerVertexColors()) { - input->colorInput()->setToUnknown(); + color->setToUnknown(); } else { - input->colorInput()->setToConstant(fMeshes[0].fColor); + color->setToConstant(fMeshes[0].fColor); } - input->coverageInput()->setToSolidCoverage(); + *coverage = GrPipelineAnalysisCoverage::kNone; } void GrDrawVerticesOp::applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) { diff --git a/src/gpu/ops/GrDrawVerticesOp.h b/src/gpu/ops/GrDrawVerticesOp.h index f881d61440..176b552e09 100644 --- a/src/gpu/ops/GrDrawVerticesOp.h +++ b/src/gpu/ops/GrDrawVerticesOp.h @@ -70,7 +70,8 @@ private: GrRenderTargetContext::ColorArrayType, const SkMatrix& viewMatrix, uint32_t flags = 0); - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override; + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override; void applyPipelineOptimizations(const GrPipelineOptimizations&) override; void onPrepareDraws(Target*) const override; diff --git a/src/gpu/ops/GrLatticeOp.cpp b/src/gpu/ops/GrLatticeOp.cpp index a1b758409a..598a83907d 100644 --- a/src/gpu/ops/GrLatticeOp.cpp +++ b/src/gpu/ops/GrLatticeOp.cpp @@ -61,9 +61,10 @@ public: } private: - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToUnknown(); - input->coverageInput()->setToSolidCoverage(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToUnknown(); + *coverage = GrPipelineAnalysisCoverage::kNone; } void applyPipelineOptimizations(const GrPipelineOptimizations& analysioptimizations) override { diff --git a/src/gpu/ops/GrMSAAPathRenderer.cpp b/src/gpu/ops/GrMSAAPathRenderer.cpp index ccbd0e2452..4e7f0361bf 100644 --- a/src/gpu/ops/GrMSAAPathRenderer.cpp +++ b/src/gpu/ops/GrMSAAPathRenderer.cpp @@ -259,9 +259,10 @@ private: this->setBounds(devBounds, HasAABloat::kNo, IsZeroArea::kNo); } - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fPaths[0].fColor); - input->coverageInput()->setToSolidCoverage(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fPaths[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kNone; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrMeshDrawOp.h b/src/gpu/ops/GrMeshDrawOp.h index 4cf7c52672..cbf1f62eb7 100644 --- a/src/gpu/ops/GrMeshDrawOp.h +++ b/src/gpu/ops/GrMeshDrawOp.h @@ -33,9 +33,10 @@ public: const GrProcessorSet& processors, const GrAppliedClip* appliedClip, const GrCaps& caps) const { - FragmentProcessorAnalysisInputs input; - this->getFragmentProcessorAnalysisInputs(&input); - analysis->init(*input.colorInput(), *input.coverageInput(), processors, appliedClip, caps); + GrPipelineAnalysisColor inputColor; + GrPipelineAnalysisCoverage inputCoverage; + this->getFragmentProcessorAnalysisInputs(&inputColor, &inputCoverage); + analysis->init(inputColor, inputCoverage, processors, appliedClip, caps); } void initPipeline(const GrPipeline::InitArgs& args) { @@ -98,27 +99,13 @@ protected: return &fPipeline; } - /** - * This describes aspects of the GrPrimitiveProcessor produced by a GrDrawOp that are used in - * pipeline analysis. - */ - class FragmentProcessorAnalysisInputs { - public: - FragmentProcessorAnalysisInputs() = default; - GrPipelineInput* colorInput() { return &fColorInput; } - GrPipelineInput* coverageInput() { return &fCoverageInput; } - - private: - GrPipelineInput fColorInput; - GrPipelineInput fCoverageInput; - }; - private: /** * Provides information about the GrPrimitiveProccesor color and coverage outputs which become * inputs to the first color and coverage fragment processors. */ - virtual void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs*) const = 0; + virtual void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor*, + GrPipelineAnalysisCoverage*) const = 0; /** * After GrPipeline analysis is complete this is called so that the op can use the analysis diff --git a/src/gpu/ops/GrNonAAFillRectOp.cpp b/src/gpu/ops/GrNonAAFillRectOp.cpp index a83da15006..ce4b21fada 100644 --- a/src/gpu/ops/GrNonAAFillRectOp.cpp +++ b/src/gpu/ops/GrNonAAFillRectOp.cpp @@ -110,9 +110,10 @@ public: private: NonAAFillRectOp() : INHERITED(ClassID()) {} - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fRects[0].fColor); - input->coverageInput()->setToSolidCoverage(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fRects[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kNone; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp b/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp index 26a646952f..324ea43ccf 100644 --- a/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp +++ b/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp @@ -130,9 +130,10 @@ public: private: NonAAFillRectPerspectiveOp() : INHERITED(ClassID()) {} - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fRects[0].fColor); - input->coverageInput()->setToSolidCoverage(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fRects[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kNone; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrNonAAStrokeRectOp.cpp b/src/gpu/ops/GrNonAAStrokeRectOp.cpp index a4de594a69..2f63d96327 100644 --- a/src/gpu/ops/GrNonAAStrokeRectOp.cpp +++ b/src/gpu/ops/GrNonAAStrokeRectOp.cpp @@ -102,9 +102,10 @@ public: private: NonAAStrokeRectOp() : INHERITED(ClassID()) {} - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fColor); - input->coverageInput()->setToSolidCoverage(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fColor); + *coverage = GrPipelineAnalysisCoverage::kNone; } void onPrepareDraws(Target* target) const override { diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp index dbab985a6c..83e783ff2f 100644 --- a/src/gpu/ops/GrOvalOpFactory.cpp +++ b/src/gpu/ops/GrOvalOpFactory.cpp @@ -805,9 +805,10 @@ public: private: CircleOp() : INHERITED(ClassID()) {} - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fGeoData[0].fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fGeoData[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { @@ -1256,9 +1257,10 @@ public: private: EllipseOp() : INHERITED(ClassID()) {} - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fGeoData[0].fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fGeoData[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { @@ -1470,9 +1472,10 @@ public: private: DIEllipseOp() : INHERITED(ClassID()) {} - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fGeoData[0].fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fGeoData[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { @@ -1785,9 +1788,10 @@ public: } private: - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fGeoData[0].fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fGeoData[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { @@ -2148,9 +2152,10 @@ public: private: EllipticalRRectOp() : INHERITED(ClassID()) {} - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fGeoData[0].fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fGeoData[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrRegionOp.cpp b/src/gpu/ops/GrRegionOp.cpp index 32cb8e4555..0ebec98e8f 100644 --- a/src/gpu/ops/GrRegionOp.cpp +++ b/src/gpu/ops/GrRegionOp.cpp @@ -77,9 +77,10 @@ public: } private: - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fRegions[0].fColor); - input->coverageInput()->setToSolidCoverage(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fRegions[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kNone; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrShadowRRectOp.cpp b/src/gpu/ops/GrShadowRRectOp.cpp index 1381bc93b7..bc1a4cca0a 100644 --- a/src/gpu/ops/GrShadowRRectOp.cpp +++ b/src/gpu/ops/GrShadowRRectOp.cpp @@ -142,9 +142,10 @@ public: private: ShadowCircleOp() : INHERITED(ClassID()) {} - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fCircles[0].fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fCircles[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { @@ -562,9 +563,10 @@ public: } private: - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fGeoData[0].fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fGeoData[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrSmallPathRenderer.cpp b/src/gpu/ops/GrSmallPathRenderer.cpp index 94364a643b..8d3f7b73ef 100644 --- a/src/gpu/ops/GrSmallPathRenderer.cpp +++ b/src/gpu/ops/GrSmallPathRenderer.cpp @@ -199,9 +199,10 @@ private: } - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fShapes[0].fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fShapes[0].fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrTessellatingPathRenderer.cpp b/src/gpu/ops/GrTessellatingPathRenderer.cpp index d1fd28adf3..914998878c 100644 --- a/src/gpu/ops/GrTessellatingPathRenderer.cpp +++ b/src/gpu/ops/GrTessellatingPathRenderer.cpp @@ -180,9 +180,10 @@ public: } private: - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/src/gpu/ops/GrTestMeshDrawOp.h b/src/gpu/ops/GrTestMeshDrawOp.h index 039f88d672..a4bf066a34 100644 --- a/src/gpu/ops/GrTestMeshDrawOp.h +++ b/src/gpu/ops/GrTestMeshDrawOp.h @@ -33,9 +33,10 @@ protected: bool usesLocalCoords() const { return fUsesLocalCoords; } private: - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(fColor); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(fColor); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/tests/GrPorterDuffTest.cpp b/tests/GrPorterDuffTest.cpp index de1843813a..ef217010ae 100644 --- a/tests/GrPorterDuffTest.cpp +++ b/tests/GrPorterDuffTest.cpp @@ -93,13 +93,11 @@ public: }; static void test_lcd_coverage(skiatest::Reporter* reporter, const GrCaps& caps) { - GrPipelineInput lcdInput; - lcdInput.setToLCDCoverage(); - GrProcessorSet::FragmentProcessorAnalysis analysis(GrPipelineInput(), lcdInput, caps); - + GrProcessorSet::FragmentProcessorAnalysis analysis(GrPipelineAnalysisColor(), + GrPipelineAnalysisCoverage::kLCD, caps); SkASSERT(!analysis.isOutputColorOpaque()); SkASSERT(!analysis.hasKnownOutputColor()); - SkASSERT(analysis.hasLCDCoverage()); + SkASSERT(analysis.outputCoverageType() == GrPipelineAnalysisCoverage::kLCD); for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) { SkBlendMode xfermode = static_cast<SkBlendMode>(m); @@ -263,12 +261,12 @@ static void test_lcd_coverage(skiatest::Reporter* reporter, const GrCaps& caps) } } static void test_color_unknown_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) { - GrProcessorSet::FragmentProcessorAnalysis analysis(GrPipelineInput(), GrPipelineInput(), caps); + GrProcessorSet::FragmentProcessorAnalysis analysis( + GrPipelineAnalysisColor(), GrPipelineAnalysisCoverage::kSingleChannel, caps); SkASSERT(!analysis.isOutputColorOpaque()); SkASSERT(!analysis.hasKnownOutputColor()); - SkASSERT(!analysis.hasLCDCoverage()); - SkASSERT(analysis.hasCoverage()); + SkASSERT(analysis.outputCoverageType() == GrPipelineAnalysisCoverage::kSingleChannel); for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) { SkBlendMode xfermode = static_cast<SkBlendMode>(m); @@ -434,7 +432,7 @@ static void test_color_unknown_with_coverage(skiatest::Reporter* reporter, const static void test_color_unknown_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) { GrProcessorSet::FragmentProcessorAnalysis analysis(GrColorPackRGBA(229, 0, 154, 240), - GrColorPackA4(255), caps); + GrPipelineAnalysisCoverage::kNone, caps); SkASSERT(!analysis.isOutputColorOpaque()); SkASSERT(analysis.hasKnownOutputColor()); @@ -603,13 +601,13 @@ static void test_color_unknown_no_coverage(skiatest::Reporter* reporter, const G } static void test_color_opaque_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) { - GrProcessorSet::FragmentProcessorAnalysis analysis(GrPipelineInput::Opaque::kYes, - GrPipelineInput(), caps); + GrProcessorSet::FragmentProcessorAnalysis analysis(GrPipelineAnalysisColor::Opaque::kYes, + GrPipelineAnalysisCoverage::kSingleChannel, + caps); SkASSERT(analysis.isOutputColorOpaque()); SkASSERT(!analysis.hasKnownOutputColor()); - SkASSERT(analysis.hasCoverage()); - SkASSERT(!analysis.hasLCDCoverage()); + SkASSERT(analysis.outputCoverageType() == GrPipelineAnalysisCoverage::kSingleChannel); for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) { SkBlendMode xfermode = static_cast<SkBlendMode>(m); @@ -775,8 +773,8 @@ static void test_color_opaque_with_coverage(skiatest::Reporter* reporter, const } static void test_color_opaque_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) { - GrProcessorSet::FragmentProcessorAnalysis analysis(GrPipelineInput::Opaque::kYes, - GrColorPackA4(255), caps); + GrProcessorSet::FragmentProcessorAnalysis analysis(GrPipelineAnalysisColor::Opaque::kYes, + GrPipelineAnalysisCoverage::kNone, caps); SkASSERT(analysis.isOutputColorOpaque()); SkASSERT(!analysis.hasKnownOutputColor()); @@ -957,9 +955,10 @@ static void test_lcd_coverage_fallback_case(skiatest::Reporter* reporter, const private: void getFragmentProcessorAnalysisInputs( - FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToConstant(GrColorPackRGBA(123, 45, 67, 221)); - input->coverageInput()->setToLCDCoverage(); + GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToConstant(GrColorPackRGBA(123, 45, 67, 221)); + *coverage = GrPipelineAnalysisCoverage::kLCD; } void applyPipelineOptimizations(const GrPipelineOptimizations&) override {} @@ -973,7 +972,7 @@ static void test_lcd_coverage_fallback_case(skiatest::Reporter* reporter, const testLCDCoverageOp.analyzeProcessors(&analysis, GrProcessorSet(GrPaint()), nullptr, caps); SkASSERT(analysis.hasKnownOutputColor()); - SkASSERT(analysis.hasLCDCoverage()); + SkASSERT(analysis.outputCoverageType() == GrPipelineAnalysisCoverage::kLCD); const GrXPFactory* xpf = GrPorterDuffXPFactory::Get(SkBlendMode::kSrcOver); TEST_ASSERT(!GrXPFactory::WillNeedDstTexture(xpf, caps, analysis)); @@ -1017,21 +1016,16 @@ DEF_GPUTEST(PorterDuffNoDualSourceBlending, reporter, /*factory*/) { fakeDstTexture.setTexture( ctx->resourceProvider()->wrapBackendTexture(fakeDesc, kBorrow_GrWrapOwnership)); - static const GrPipelineInput colorInputs[] = {GrPipelineInput(), - GrPipelineInput(GrPipelineInput::Opaque::kYes), - GrPipelineInput(GrColorPackRGBA(0, 82, 17, 100)), - GrPipelineInput(GrColorPackRGBA(0, 82, 17, 255))}; + static const GrPipelineAnalysisColor colorInputs[] = { + GrPipelineAnalysisColor::Opaque::kNo, GrPipelineAnalysisColor::Opaque::kYes, + GrPipelineAnalysisColor(GrColorPackRGBA(0, 82, 17, 100)), + GrPipelineAnalysisColor(GrColorPackRGBA(0, 82, 17, 255))}; for (const auto& colorInput : colorInputs) { GrProcessorSet::FragmentProcessorAnalysis analysis; - for (bool fractionalCoverage : {true, false}) { - if (fractionalCoverage) { - analysis = GrProcessorSet::FragmentProcessorAnalysis(colorInput, GrPipelineInput(), - caps); - } else { - analysis = GrProcessorSet::FragmentProcessorAnalysis(colorInput, GrColorPackA4(255), - caps); - } + for (GrPipelineAnalysisCoverage coverageType : + {GrPipelineAnalysisCoverage::kSingleChannel, GrPipelineAnalysisCoverage::kNone}) { + analysis = GrProcessorSet::FragmentProcessorAnalysis(colorInput, coverageType, caps); for (int m = 0; m <= (int)SkBlendMode::kLastCoeffMode; m++) { SkBlendMode xfermode = static_cast<SkBlendMode>(m); const GrXPFactory* xpf = GrPorterDuffXPFactory::Get(xfermode); diff --git a/tests/PreFlushCallbackTest.cpp b/tests/PreFlushCallbackTest.cpp index 773cfde347..e008009efd 100644 --- a/tests/PreFlushCallbackTest.cpp +++ b/tests/PreFlushCallbackTest.cpp @@ -64,9 +64,10 @@ protected: SkRect fRect; private: - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToUnknown(); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToUnknown(); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override { diff --git a/tests/PrimitiveProcessorTest.cpp b/tests/PrimitiveProcessorTest.cpp index 30bfed9ff0..0a9d0021f0 100644 --- a/tests/PrimitiveProcessorTest.cpp +++ b/tests/PrimitiveProcessorTest.cpp @@ -40,9 +40,10 @@ private: this->setBounds(SkRect::MakeWH(1.f, 1.f), HasAABloat::kNo, IsZeroArea::kNo); } - void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs* input) const override { - input->colorInput()->setToUnknown(); - input->coverageInput()->setToUnknown(); + void getFragmentProcessorAnalysisInputs(GrPipelineAnalysisColor* color, + GrPipelineAnalysisCoverage* coverage) const override { + color->setToUnknown(); + *coverage = GrPipelineAnalysisCoverage::kSingleChannel; } void applyPipelineOptimizations(const GrPipelineOptimizations&) override {} |