GrColorFragmentProcessorAnalysis Class Reference

#include <GrProcessorAnalysis.h>

Public Member Functions
	GrColorFragmentProcessorAnalysis ()=delete
	GrColorFragmentProcessorAnalysis (const GrProcessorAnalysisColor &input, std::unique_ptr< GrFragmentProcessor > const fps[], int count)
bool	isOpaque () const
bool	allProcessorsCompatibleWithCoverageAsAlpha () const
bool	usesLocalCoords () const
bool	willReadDstColor () const
bool	requiresDstTexture (const GrCaps &caps) const
int	initialProcessorsToEliminate (SkPMColor4f *newPipelineInputColor) const
GrProcessorAnalysisColor	outputColor () const

Detailed Description

GrColorFragmentProcessorAnalysis gathers invariant data from a set of color fragment processors. It is used to recognize optimizations that can simplify the generated shader or make blending more effecient.

Definition at line 96 of file GrProcessorAnalysis.h.

Constructor & Destructor Documentation

GrColorFragmentProcessorAnalysis() [1/2]

GrColorFragmentProcessorAnalysis::GrColorFragmentProcessorAnalysis ( )

delete

GrColorFragmentProcessorAnalysis() [2/2]

GrColorFragmentProcessorAnalysis::GrColorFragmentProcessorAnalysis	(	const GrProcessorAnalysisColor &	input,
		std::unique_ptr< GrFragmentProcessor > const	fps[],
		int	count
	)

Definition at line 13 of file GrProcessorAnalysis.cpp.

                   {
    fCompatibleWithCoverageAsAlpha = true;
    fIsOpaque = input.isOpaque();
    fUsesLocalCoords = false;
    fWillReadDstColor = false;
    fProcessorsToEliminate = 0;
    fOutputColorKnown = input.isConstant(&fLastKnownOutputColor);
    for (int i = 0; i < count; ++i) {
        const GrFragmentProcessor* fp = fps[i].get();
        if (fOutputColorKnown && fp->hasConstantOutputForConstantInput(fLastKnownOutputColor,
                                                                       &fLastKnownOutputColor)) {
            ++fProcessorsToEliminate;
            fIsOpaque = fLastKnownOutputColor.isOpaque();
            // We reset these flags since the earlier fragment processors are being eliminated.
            fCompatibleWithCoverageAsAlpha = true;
            fUsesLocalCoords = false;
            fWillReadDstColor = false;
            continue;
        }
 
        fOutputColorKnown = false;
        if (fIsOpaque && !fp->preservesOpaqueInput()) {
            fIsOpaque = false;
        }
        if (fCompatibleWithCoverageAsAlpha && !fp->compatibleWithCoverageAsAlpha()) {
            fCompatibleWithCoverageAsAlpha = false;
        }
        if (fp->usesSampleCoords()) {
            fUsesLocalCoords = true;
        }
        if (fp->willReadDstColor()) {
            fWillReadDstColor = true;
        }
    }
}

Member Function Documentation

allProcessorsCompatibleWithCoverageAsAlpha()

bool GrColorFragmentProcessorAnalysis::allProcessorsCompatibleWithCoverageAsAlpha ( ) const

inline

Are all the fragment processors compatible with conflating coverage with color prior to the the first fragment processor. This result assumes that processors that should be eliminated as indicated by initialProcessorsToEliminate() are in fact eliminated.

Definition at line 111 of file GrProcessorAnalysis.h.

                                                            {
        return fCompatibleWithCoverageAsAlpha;
    }

initialProcessorsToEliminate()

int GrColorFragmentProcessorAnalysis::initialProcessorsToEliminate ( SkPMColor4f *  newPipelineInputColor ) const

inline

If we detected that the result after the first N processors is a known color then we eliminate those N processors and replace the GrDrawOp's color input to the GrPipeline with the known output of the Nth processor, so that the Nth+1 fragment processor (or the XP if there are only N processors) sees its expected input. If this returns 0 then there are no processors to eliminate.

Definition at line 139 of file GrProcessorAnalysis.h.

                                                                               {
        if (fProcessorsToEliminate > 0) {
            *newPipelineInputColor = fLastKnownOutputColor;
        }
        return fProcessorsToEliminate;
    }

isOpaque()

bool GrColorFragmentProcessorAnalysis::isOpaque ( ) const

inline

Definition at line 104 of file GrProcessorAnalysis.h.

{ return fIsOpaque; }

outputColor()

GrProcessorAnalysisColor GrColorFragmentProcessorAnalysis::outputColor ( ) const

inline

Provides known information about the last processor's output color.

Definition at line 149 of file GrProcessorAnalysis.h.

                                                 {
        if (fOutputColorKnown) {
            return fLastKnownOutputColor;
        }
        return fIsOpaque ? GrProcessorAnalysisColor::Opaque::kYes
                         : GrProcessorAnalysisColor::Opaque::kNo;
    }

requiresDstTexture()

bool GrColorFragmentProcessorAnalysis::requiresDstTexture

(

const GrCaps &

caps

)

const

Will we require a destination-surface texture?

Definition at line 52 of file GrProcessorAnalysis.cpp.

                                                                                  {
    return this->willReadDstColor() && !caps.shaderCaps()->fDstReadInShaderSupport;
}

usesLocalCoords()

bool GrColorFragmentProcessorAnalysis::usesLocalCoords ( ) const

inline

Do any of the fragment processors require local coords. This result assumes that processors that should be eliminated as indicated by initialProcessorsToEliminate() are in fact eliminated.

Definition at line 120 of file GrProcessorAnalysis.h.

{ return fUsesLocalCoords; }

willReadDstColor()

bool GrColorFragmentProcessorAnalysis::willReadDstColor ( ) const

inline

Do any of the fragment processors read back the destination color?

Definition at line 125 of file GrProcessorAnalysis.h.

{ return fWillReadDstColor; }

---

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

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