GrProcessorSet Class Reference

#include <GrProcessorSet.h>

Classes
class	Analysis

Public Member Functions
	GrProcessorSet (GrPaint &&)
	GrProcessorSet (SkBlendMode)
	GrProcessorSet (std::unique_ptr< GrFragmentProcessor > colorFP)
	GrProcessorSet (GrProcessorSet &&)
	GrProcessorSet (const GrProcessorSet &)=delete
GrProcessorSet &	operator= (const GrProcessorSet &)=delete
	~GrProcessorSet ()
bool	hasColorFragmentProcessor () const
bool	hasCoverageFragmentProcessor () const
const GrFragmentProcessor *	colorFragmentProcessor () const
const GrFragmentProcessor *	coverageFragmentProcessor () const
const GrXferProcessor *	xferProcessor () const
sk_sp< const GrXferProcessor >	refXferProcessor () const
std::unique_ptr< GrFragmentProcessor >	detachColorFragmentProcessor ()
std::unique_ptr< GrFragmentProcessor >	detachCoverageFragmentProcessor ()
bool	operator== (const GrProcessorSet &that) const
bool	operator!= (const GrProcessorSet &that) const
Analysis	finalize (const GrProcessorAnalysisColor &, const GrProcessorAnalysisCoverage, const GrAppliedClip *, const GrUserStencilSettings *, const GrCaps &, GrClampType, SkPMColor4f *inputColorOverride)
bool	isFinalized () const
void	visitProxies (const GrVisitProxyFunc &) const

Static Public Member Functions
static const GrProcessorSet &	EmptySet ()
static GrProcessorSet	MakeEmptySet ()
static constexpr Analysis	EmptySetAnalysis ()

Detailed Description

Definition at line 21 of file GrProcessorSet.h.

Constructor & Destructor Documentation

GrProcessorSet() [1/5]

GrProcessorSet::GrProcessorSet

(

GrPaint &&

paint

)

Definition at line 25 of file GrProcessorSet.cpp.

                                              : fXP(paint.getXPFactory()) {
    fColorFragmentProcessor = std::move(paint.fColorFragmentProcessor);
    fCoverageFragmentProcessor = std::move(paint.fCoverageFragmentProcessor);
 
    SkDEBUGCODE(paint.fAlive = false;)
}

GrProcessorSet() [2/5]

GrProcessorSet::GrProcessorSet

(

SkBlendMode

mode

)

Definition at line 32 of file GrProcessorSet.cpp.

: fXP(GrXPFactory::FromBlendMode(mode)) {}

GrProcessorSet() [3/5]

GrProcessorSet::GrProcessorSet

(

std::unique_ptr< GrFragmentProcessor >

colorFP

)

Definition at line 34 of file GrProcessorSet.cpp.

        : fXP((const GrXPFactory*)nullptr) {
    SkASSERT(colorFP);
    fColorFragmentProcessor = std::move(colorFP);
}

GrProcessorSet() [4/5]

GrProcessorSet::GrProcessorSet

(

GrProcessorSet &&

that

)

Definition at line 40 of file GrProcessorSet.cpp.

        : fColorFragmentProcessor(std::move(that.fColorFragmentProcessor))
        , fCoverageFragmentProcessor(std::move(that.fCoverageFragmentProcessor))
        , fXP(std::move(that.fXP))
        , fFlags(that.fFlags) {}

GrProcessorSet() [5/5]

GrProcessorSet::GrProcessorSet ( const GrProcessorSet &  )

delete

~GrProcessorSet()

GrProcessorSet::~GrProcessorSet

(

)

Definition at line 46 of file GrProcessorSet.cpp.

                                {
    if (this->isFinalized() && this->xferProcessor()) {
        this->xferProcessor()->unref();
    }
}

Member Function Documentation

colorFragmentProcessor()

const GrFragmentProcessor * GrProcessorSet::colorFragmentProcessor ( ) const

inline

Definition at line 39 of file GrProcessorSet.h.

                                                              {
        return fColorFragmentProcessor.get();
    }

coverageFragmentProcessor()

const GrFragmentProcessor * GrProcessorSet::coverageFragmentProcessor ( ) const

inline

Definition at line 42 of file GrProcessorSet.h.

                                                                 {
        return fCoverageFragmentProcessor.get();
    }

detachColorFragmentProcessor()

std::unique_ptr< GrFragmentProcessor > GrProcessorSet::detachColorFragmentProcessor ( )

inline

Definition at line 55 of file GrProcessorSet.h.

                                                                      {
        return std::move(fColorFragmentProcessor);
    }

detachCoverageFragmentProcessor()

std::unique_ptr< GrFragmentProcessor > GrProcessorSet::detachCoverageFragmentProcessor ( )

inline

Definition at line 59 of file GrProcessorSet.h.

                                                                         {
        return std::move(fCoverageFragmentProcessor);
    }

EmptySet()

const GrProcessorSet & GrProcessorSet::EmptySet ( )

static

These are valid only for non-LCD coverage.

Definition at line 16 of file GrProcessorSet.cpp.

                                               {
    static GrProcessorSet gEmpty(GrProcessorSet::Empty::kEmpty);
    return gEmpty;
}

EmptySetAnalysis()

static constexpr Analysis GrProcessorSet::EmptySetAnalysis ( )

inlinestaticconstexpr

Definition at line 151 of file GrProcessorSet.h.

{ return Analysis(Empty::kEmpty); }

finalize()

GrProcessorSet::Analysis GrProcessorSet::finalize	(	const GrProcessorAnalysisColor &	colorInput,
		const GrProcessorAnalysisCoverage	coverageInput,
		const GrAppliedClip *	clip,
		const GrUserStencilSettings *	userStencil,
		const GrCaps &	caps,
		GrClampType	clampType,
		SkPMColor4f *	inputColorOverride
	)

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 inputColorIsOverridden(). '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.

Definition at line 115 of file GrProcessorSet.cpp.

                                                                                    {
    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;
}

hasColorFragmentProcessor()

bool GrProcessorSet::hasColorFragmentProcessor ( ) const

inline

Definition at line 36 of file GrProcessorSet.h.

{ return fColorFragmentProcessor != nullptr; }

hasCoverageFragmentProcessor()

bool GrProcessorSet::hasCoverageFragmentProcessor ( ) const

inline

Definition at line 37 of file GrProcessorSet.h.

{ return fCoverageFragmentProcessor != nullptr; }

isFinalized()

bool GrProcessorSet::isFinalized ( ) const

inline

Definition at line 146 of file GrProcessorSet.h.

{ return SkToBool(kFinalized_Flag & fFlags); }

MakeEmptySet()

GrProcessorSet GrProcessorSet::MakeEmptySet ( )

static

Definition at line 21 of file GrProcessorSet.cpp.

                                            {
    return GrProcessorSet(GrProcessorSet::Empty::kEmpty);
}

operator!=()

bool GrProcessorSet::operator!= ( const GrProcessorSet &  that ) const

inline

Definition at line 65 of file GrProcessorSet.h.

{ return !(*this == that); }

operator=()

GrProcessorSet & GrProcessorSet::operator= ( const GrProcessorSet &  )

delete

operator==()

bool GrProcessorSet::operator==

(

const GrProcessorSet &

that

)

const

Comparisons are only legal on finalized processor sets.

Definition at line 81 of file GrProcessorSet.cpp.

                                                                {
    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);
}

refXferProcessor()

sk_sp< const GrXferProcessor > GrProcessorSet::refXferProcessor ( ) const

inline

Definition at line 50 of file GrProcessorSet.h.

                                                          {
        SkASSERT(this->isFinalized());
        return sk_ref_sp(fXP.fProcessor);
    }

visitProxies()

void GrProcessorSet::visitProxies

(

const GrVisitProxyFunc &

func

)

const

Definition at line 199 of file GrProcessorSet.cpp.

                                                                    {
    if (this->hasColorFragmentProcessor()) {
        fColorFragmentProcessor->visitProxies(func);
    }
    if (this->hasCoverageFragmentProcessor()) {
        fCoverageFragmentProcessor->visitProxies(func);
    }
}

xferProcessor()

const GrXferProcessor * GrProcessorSet::xferProcessor ( ) const

inline

Definition at line 46 of file GrProcessorSet.h.

                                                 {
        SkASSERT(this->isFinalized());
        return fXP.fProcessor;
    }

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/ganesh/GrProcessorSet.h
• third_party/skia/src/gpu/ganesh/GrProcessorSet.cpp