GrFragmentProcessor Class Reference

#include <GrFragmentProcessor.h>

Inheritance diagram for GrFragmentProcessor:

Classes
class	ProgramImpl

Public Member Functions
virtual std::unique_ptr< GrFragmentProcessor >	clone () const =0
const GrFragmentProcessor *	parent () const
std::unique_ptr< ProgramImpl >	makeProgramImpl () const
void	addToKey (const GrShaderCaps &caps, skgpu::KeyBuilder *b) const
int	numChildProcessors () const
int	numNonNullChildProcessors () const
GrFragmentProcessor *	childProcessor (int index)
const GrFragmentProcessor *	childProcessor (int index) const
	SkDEBUGCODE (bool isInstantiated() const ;) bool willReadDstColor() const
bool	isBlendFunction () const
bool	usesSampleCoordsDirectly () const
bool	usesSampleCoords () const
const SkSL::SampleUsage &	sampleUsage () const
bool	compatibleWithCoverageAsAlpha () const
bool	preservesOpaqueInput () const
bool	hasConstantOutputForConstantInput (SkPMColor4f inputColor, SkPMColor4f *outputColor) const
bool	hasConstantOutputForConstantInput () const
void	clearConstantOutputForConstantInputFlag ()
bool	isEqual (const GrFragmentProcessor &that) const
void	visitProxies (const GrVisitProxyFunc &) const
void	visitTextureEffects (const std::function< void(const GrTextureEffect &)> &) const
void	visitWithImpls (const std::function< void(const GrFragmentProcessor &, ProgramImpl &)> &, ProgramImpl &) const
GrTextureEffect *	asTextureEffect ()
const GrTextureEffect *	asTextureEffect () const
Public Member Functions inherited from GrProcessor
virtual	~GrProcessor ()=default
virtual const char *	name () const =0
void *	operator new (size_t size)
void *	operator new (size_t object_size, size_t footer_size)
void	operator delete (void *target)
void *	operator new (size_t size, void *placement)
void	operator delete (void *target, void *placement)
template<typename T >
const T &	cast () const
ClassID	classID () const

Static Public Member Functions
static std::unique_ptr< GrFragmentProcessor >	MakeColor (SkPMColor4f color)
static std::unique_ptr< GrFragmentProcessor >	MulInputByChildAlpha (std::unique_ptr< GrFragmentProcessor > child)
static std::unique_ptr< GrFragmentProcessor >	ApplyPaintAlpha (std::unique_ptr< GrFragmentProcessor > child)
static std::unique_ptr< GrFragmentProcessor >	ModulateRGBA (std::unique_ptr< GrFragmentProcessor > child, const SkPMColor4f &color)
static std::unique_ptr< GrFragmentProcessor >	OverrideInput (std::unique_ptr< GrFragmentProcessor >, const SkPMColor4f &)
static std::unique_ptr< GrFragmentProcessor >	DisableCoverageAsAlpha (std::unique_ptr< GrFragmentProcessor >)
static std::unique_ptr< GrFragmentProcessor >	DestColor ()
static std::unique_ptr< GrFragmentProcessor >	SwizzleOutput (std::unique_ptr< GrFragmentProcessor >, const skgpu::Swizzle &)
static std::unique_ptr< GrFragmentProcessor >	ClampOutput (std::unique_ptr< GrFragmentProcessor >)
static std::unique_ptr< GrFragmentProcessor >	Compose (std::unique_ptr< GrFragmentProcessor > f, std::unique_ptr< GrFragmentProcessor > g)
static std::unique_ptr< GrFragmentProcessor >	ColorMatrix (std::unique_ptr< GrFragmentProcessor > child, const float matrix[20], bool unpremulInput, bool clampRGBOutput, bool premulOutput)
static std::unique_ptr< GrFragmentProcessor >	SurfaceColor ()
static std::unique_ptr< GrFragmentProcessor >	DeviceSpace (std::unique_ptr< GrFragmentProcessor >)
static std::unique_ptr< GrFragmentProcessor >	Rect (std::unique_ptr< GrFragmentProcessor >, GrClipEdgeType, SkRect)
static GrFPResult	Circle (std::unique_ptr< GrFragmentProcessor >, GrClipEdgeType, SkPoint center, float radius)
static GrFPResult	Ellipse (std::unique_ptr< GrFragmentProcessor >, GrClipEdgeType, SkPoint center, SkPoint radii, const GrShaderCaps &)
static std::unique_ptr< GrFragmentProcessor >	HighPrecision (std::unique_ptr< GrFragmentProcessor >)

Protected Types
enum	OptimizationFlags : uint32_t {   kNone_OptimizationFlags , kCompatibleWithCoverageAsAlpha_OptimizationFlag = 0x1 , kPreservesOpaqueInput_OptimizationFlag = 0x2 , kConstantOutputForConstantInput_OptimizationFlag = 0x4 ,   kAll_OptimizationFlags }

Protected Member Functions
	GrFragmentProcessor (ClassID classID, OptimizationFlags optimizationFlags)
	GrFragmentProcessor (const GrFragmentProcessor &src)
OptimizationFlags	optimizationFlags () const
void	registerChild (std::unique_ptr< GrFragmentProcessor > child, SkSL::SampleUsage sampleUsage=SkSL::SampleUsage::PassThrough())
void	cloneAndRegisterAllChildProcessors (const GrFragmentProcessor &src)
void	setUsesSampleCoordsDirectly ()
void	setWillReadDstColor ()
void	setIsBlendFunction ()
void	mergeOptimizationFlags (OptimizationFlags flags)
Protected Member Functions inherited from GrProcessor
	GrProcessor (ClassID classID)
	GrProcessor (const GrProcessor &)=delete
GrProcessor &	operator= (const GrProcessor &)=delete

Static Protected Member Functions
static OptimizationFlags	ModulateForSamplerOptFlags (SkAlphaType alphaType, bool samplingDecal)
static OptimizationFlags	ModulateForClampedSamplerOptFlags (SkAlphaType alphaType)
static OptimizationFlags	ProcessorOptimizationFlags (const GrFragmentProcessor *fp)
static SkPMColor4f	ConstantOutputForConstantInput (const GrFragmentProcessor *fp, const SkPMColor4f &input)

Private Member Functions
virtual SkPMColor4f	constantOutputForConstantInput (const SkPMColor4f &) const
virtual std::unique_ptr< ProgramImpl >	onMakeProgramImpl () const =0
virtual void	onAddToKey (const GrShaderCaps &, skgpu::KeyBuilder *) const =0
virtual bool	onIsEqual (const GrFragmentProcessor &) const =0

Additional Inherited Members
Public Types inherited from GrProcessor
enum	ClassID {   kNull_ClassID , kAttributeTestProcessor_ClassID , kBigKeyProcessor_ClassID , kBlendFragmentProcessor_ClassID ,   kBlockInputFragmentProcessor_ClassID , kButtCapStrokedCircleGeometryProcessor_ClassID , kCircleGeometryProcessor_ClassID , kCircularRRectEffect_ClassID ,   kClockwiseTestProcessor_ClassID , kColorTableEffect_ClassID , kCoverageSetOpXP_ClassID , kCustomXP_ClassID ,   kDashingCircleEffect_ClassID , kDashingLineEffect_ClassID , kDefaultGeoProc_ClassID , kDeviceSpace_ClassID ,   kDIEllipseGeometryProcessor_ClassID , kDisableColorXP_ClassID , kDrawAtlasPathShader_ClassID , kEllipseGeometryProcessor_ClassID ,   kEllipticalRRectEffect_ClassID , kFwidthSquircleTestProcessor_ClassID , kGP_ClassID , kGrBicubicEffect_ClassID ,   kGrBitmapTextGeoProc_ClassID , kGrColorSpaceXformEffect_ClassID , kGrConicEffect_ClassID , kGrConvexPolyEffect_ClassID ,   kGrDiffuseLightingEffect_ClassID , kGrDisplacementMapEffect_ClassID , kGrDistanceFieldA8TextGeoProc_ClassID , kGrDistanceFieldLCDTextGeoProc_ClassID ,   kGrDistanceFieldPathGeoProc_ClassID , kGrFillRRectOp_Processor_ClassID , kGrGaussianConvolutionFragmentProcessor_ClassID , kGrMatrixConvolutionEffect_ClassID ,   kGrMatrixEffect_ClassID , kGrMeshTestProcessor_ClassID , kGrMorphologyEffect_ClassID , kGrPerlinNoise2Effect_ClassID ,   kGrPipelineDynamicStateTestProcessor_ClassID , kGrQuadEffect_ClassID , kGrRRectShadowGeoProc_ClassID , kGrSkSLFP_ClassID ,   kGrSpecularLightingEffect_ClassID , kGrTextureEffect_ClassID , kGrUnrolledBinaryGradientColorizer_ClassID , kGrYUVtoRGBEffect_ClassID ,   kHighPrecisionFragmentProcessor_ClassID , kLatticeGP_ClassID , kPDLCDXferProcessor_ClassID , kPorterDuffXferProcessor_ClassID ,   kPremulFragmentProcessor_ClassID , kQuadEdgeEffect_ClassID , kQuadPerEdgeAAGeometryProcessor_ClassID , kSeriesFragmentProcessor_ClassID ,   kShaderPDXferProcessor_ClassID , kSurfaceColorProcessor_ClassID , kSwizzleFragmentProcessor_ClassID , kTessellate_BoundingBoxShader_ClassID ,   kTessellate_GrModulateAtlasCoverageEffect_ClassID , kTessellate_GrStrokeTessellationShader_ClassID , kTessellate_HullShader_ClassID , kTessellate_MiddleOutShader_ClassID ,   kTessellate_SimpleTriangleShader_ClassID , kTessellationTestTriShader_ClassID , kTestFP_ClassID , kTestRectOp_ClassID ,   kVertexColorSpaceBenchGP_ClassID , kVerticesGP_ClassID }
Protected Attributes inherited from GrProcessor
const ClassID	fClassID

Detailed Description

Provides custom fragment shader code. Fragment processors receive an input position and produce an output color. They may contain uniforms and may have children fragment processors that are sampled.

Definition at line 45 of file GrFragmentProcessor.h.

Member Enumeration Documentation

OptimizationFlags

enum GrFragmentProcessor::OptimizationFlags : uint32_t

protected

Enumerator
kNone_OptimizationFlags
kCompatibleWithCoverageAsAlpha_OptimizationFlag
kPreservesOpaqueInput_OptimizationFlag
kConstantOutputForConstantInput_OptimizationFlag
kAll_OptimizationFlags

Definition at line 307 of file GrFragmentProcessor.h.

                           : uint32_t {
        kNone_OptimizationFlags,
        kCompatibleWithCoverageAsAlpha_OptimizationFlag = 0x1,
        kPreservesOpaqueInput_OptimizationFlag = 0x2,
        kConstantOutputForConstantInput_OptimizationFlag = 0x4,
        kAll_OptimizationFlags = kCompatibleWithCoverageAsAlpha_OptimizationFlag |
                                 kPreservesOpaqueInput_OptimizationFlag |
                                 kConstantOutputForConstantInput_OptimizationFlag
    };

Constructor & Destructor Documentation

GrFragmentProcessor() [1/2]

GrFragmentProcessor::GrFragmentProcessor ( ClassID  classID, OptimizationFlags  optimizationFlags  )

inlineprotected

Definition at line 346 of file GrFragmentProcessor.h.

            : INHERITED(classID), fFlags(optimizationFlags) {
        SkASSERT((optimizationFlags & ~kAll_OptimizationFlags) == 0);
    }

GrFragmentProcessor() [2/2]

GrFragmentProcessor::GrFragmentProcessor ( const GrFragmentProcessor &  src )

inlineexplicitprotected

Definition at line 351 of file GrFragmentProcessor.h.

            : INHERITED(src.classID()), fFlags(src.fFlags) {
        this->cloneAndRegisterAllChildProcessors(src);
    }

Member Function Documentation

addToKey()

void GrFragmentProcessor::addToKey ( const GrShaderCaps &  caps, skgpu::KeyBuilder *  b  ) const

inline

Definition at line 184 of file GrFragmentProcessor.h.

                                                                      {
        this->onAddToKey(caps, b);
        for (const auto& child : fChildProcessors) {
            if (child) {
                child->addToKey(caps, b);
            }
        }
    }

ApplyPaintAlpha()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::ApplyPaintAlpha ( std::unique_ptr< GrFragmentProcessor >  child )

static

Invokes child with an opaque version of the input color, then applies the input alpha to the result. Used to incorporate paint alpha to the evaluation of an SkShader tree FP.

Definition at line 214 of file GrFragmentProcessor.cpp.

                                                  {
    SkASSERT(child);
    static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
        "uniform colorFilter fp;"
        "half4 main(half4 inColor) {"
            "return fp.eval(inColor.rgb1) * inColor.a;"
        "}"
    );
    return GrSkSLFP::Make(effect, "ApplyPaintAlpha", /*inputFP=*/nullptr,
                          GrSkSLFP::OptFlags::kPreservesOpaqueInput |
                          GrSkSLFP::OptFlags::kCompatibleWithCoverageAsAlpha,
                          "fp", std::move(child));
}

asTextureEffect() [1/2]

GrTextureEffect * GrFragmentProcessor::asTextureEffect

(

)

Definition at line 81 of file GrFragmentProcessor.cpp.

                                                      {
    if (this->classID() == kGrTextureEffect_ClassID) {
        return static_cast<GrTextureEffect*>(this);
    }
    return nullptr;
}

asTextureEffect() [2/2]

const GrTextureEffect * GrFragmentProcessor::asTextureEffect

(

)

const

Definition at line 88 of file GrFragmentProcessor.cpp.

                                                                  {
    if (this->classID() == kGrTextureEffect_ClassID) {
        return static_cast<const GrTextureEffect*>(this);
    }
    return nullptr;
}

childProcessor() [1/2]

GrFragmentProcessor * GrFragmentProcessor::childProcessor ( int  index )

inline

Definition at line 196 of file GrFragmentProcessor.h.

{ return fChildProcessors[index].get(); }

childProcessor() [2/2]

const GrFragmentProcessor * GrFragmentProcessor::childProcessor ( int  index ) const

inline

Definition at line 197 of file GrFragmentProcessor.h.

                                                               {
        return fChildProcessors[index].get();
    }

Circle()

GrFPResult GrFragmentProcessor::Circle ( std::unique_ptr< GrFragmentProcessor >  inputFP, GrClipEdgeType  edgeType, SkPoint  center, float  radius  )

static

Definition at line 647 of file GrFragmentProcessor.cpp.

                                                     {
    // A radius below half causes the implicit insetting done by this processor to become
    // inverted. We could handle this case by making the processor code more complicated.
    if (radius < .5f && GrClipEdgeTypeIsInverseFill(edgeType)) {
        return GrFPFailure(std::move(inputFP));
    }
 
    static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
    CLIP_EDGE_SKSL
        "uniform int edgeType;"  // GrClipEdgeType, specialized
        // The circle uniform is (center.x, center.y, radius + 0.5, 1 / (radius + 0.5)) for regular
        // fills and (..., radius - 0.5, 1 / (radius - 0.5)) for inverse fills.
        "uniform float4 circle;"
 
        "half4 main(float2 xy) {"
            // TODO: Right now the distance to circle calculation is performed in a space normalized
            // to the radius and then denormalized. This is to mitigate overflow on devices that
            // don't have full float.
            "half d;"
            "if (edgeType == kInverseFillBW || edgeType == kInverseFillAA) {"
                "d = half((length((circle.xy - sk_FragCoord.xy) * circle.w) - 1.0) * circle.z);"
            "} else {"
                "d = half((1.0 - length((circle.xy - sk_FragCoord.xy) * circle.w)) * circle.z);"
            "}"
            "return half4((edgeType == kFillAA || edgeType == kInverseFillAA)"
                              "? saturate(d)"
                              ": (d > 0.5 ? 1 : 0));"
        "}"
    );
 
    SkScalar effectiveRadius = radius;
    if (GrClipEdgeTypeIsInverseFill(edgeType)) {
        effectiveRadius -= 0.5f;
        // When the radius is 0.5 effectiveRadius is 0 which causes an inf * 0 in the shader.
        effectiveRadius = std::max(0.001f, effectiveRadius);
    } else {
        effectiveRadius += 0.5f;
    }
    SkV4 circle = {center.fX, center.fY, effectiveRadius, SkScalarInvert(effectiveRadius)};
 
    auto circleFP = GrSkSLFP::Make(effect, "Circle", /*inputFP=*/nullptr,
                                   GrSkSLFP::OptFlags::kCompatibleWithCoverageAsAlpha,
                                   "edgeType", GrSkSLFP::Specialize(static_cast<int>(edgeType)),
                                   "circle", circle);
    return GrFPSuccess(GrBlendFragmentProcessor::Make<SkBlendMode::kModulate>(std::move(inputFP),
                                                                              std::move(circleFP)));
}

ClampOutput()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::ClampOutput ( std::unique_ptr< GrFragmentProcessor >  fp )

static

Returns a fragment processor that calls the passed in fragment processor, and then clamps the output to [0, 1].

Definition at line 236 of file GrFragmentProcessor.cpp.

                                               {
    SkASSERT(fp);
    static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
        "half4 main(half4 inColor) {"
            "return saturate(inColor);"
        "}"
    );
    SkASSERT(SkRuntimeEffectPriv::SupportsConstantOutputForConstantInput(effect));
    return GrSkSLFP::Make(effect, "Clamp", std::move(fp),
                          GrSkSLFP::OptFlags::kPreservesOpaqueInput);
}

clearConstantOutputForConstantInputFlag()

void GrFragmentProcessor::clearConstantOutputForConstantInputFlag ( )

inline

Definition at line 277 of file GrFragmentProcessor.h.

                                                   {
        fFlags &= ~kConstantOutputForConstantInput_OptimizationFlag;
    }

clone()

virtual std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::clone ( ) const

pure virtual

Makes a copy of this fragment processor that draws equivalently to the original. If the processor has child processors they are cloned as well.

Implemented in SampleCoordEffect, GrBicubicEffect, BlendFragmentProcessor, ColorTableEffect, GrConvexPolyEffect, GrMatrixEffect, GrModulateAtlasCoverageEffect, GrPerlinNoise2Effect, GrSkSLFP, GrTextureEffect, GrYUVtoRGBEffect, GrColorSpaceXformEffect, LazyProxyTest::ClipFP, and BlockInputFragmentProcessor.

cloneAndRegisterAllChildProcessors()

void GrFragmentProcessor::cloneAndRegisterAllChildProcessors ( const GrFragmentProcessor &  src )

protected

This method takes an existing fragment processor, clones all of its children, and registers the clones as children of this fragment processor.

Definition at line 183 of file GrFragmentProcessor.cpp.

                                                                                           {
    for (int i = 0; i < src.numChildProcessors(); ++i) {
        if (auto fp = src.childProcessor(i)) {
            this->registerChild(fp->clone(), fp->sampleUsage());
        } else {
            this->registerChild(nullptr);
        }
    }
}

ColorMatrix()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::ColorMatrix ( std::unique_ptr< GrFragmentProcessor >  child, const float  matrix[20], bool  unpremulInput, bool  clampRGBOutput, bool  premulOutput  )

static

Definition at line 456 of file GrFragmentProcessor.cpp.

                           {
    static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
        "uniform half4x4 m;"
        "uniform half4 v;"
        "uniform int unpremulInput;"   // always specialized
        "uniform int clampRGBOutput;"  // always specialized
        "uniform int premulOutput;"    // always specialized
        "half4 main(half4 color) {"
            "if (bool(unpremulInput)) {"
                "color = unpremul(color);"
            "}"
            "color = m * color + v;"
            "if (bool(clampRGBOutput)) {"
                "color = saturate(color);"
            "} else {"
                "color.a = saturate(color.a);"
            "}"
            "if (bool(premulOutput)) {"
                "color.rgb *= color.a;"
            "}"
            "return color;"
        "}"
    );
    SkASSERT(SkRuntimeEffectPriv::SupportsConstantOutputForConstantInput(effect));
 
    SkM44 m44(matrix[ 0], matrix[ 1], matrix[ 2], matrix[ 3],
              matrix[ 5], matrix[ 6], matrix[ 7], matrix[ 8],
              matrix[10], matrix[11], matrix[12], matrix[13],
              matrix[15], matrix[16], matrix[17], matrix[18]);
    SkV4 v4 = {matrix[4], matrix[9], matrix[14], matrix[19]};
    return GrSkSLFP::Make(effect, "ColorMatrix", std::move(child), GrSkSLFP::OptFlags::kNone,
                          "m", m44,
                          "v", v4,
                          "unpremulInput",  GrSkSLFP::Specialize(unpremulInput  ? 1 : 0),
                          "clampRGBOutput", GrSkSLFP::Specialize(clampRGBOutput ? 1 : 0),
                          "premulOutput",   GrSkSLFP::Specialize(premulOutput   ? 1 : 0));
}

compatibleWithCoverageAsAlpha()

bool GrFragmentProcessor::compatibleWithCoverageAsAlpha ( ) const

inline

A GrDrawOp may premultiply its antialiasing coverage into its GrGeometryProcessor's color output under the following scenario:

• all the color fragment processors report true to this query,
• all the coverage fragment processors report true to this query,
• the blend mode arithmetic allows for it it. To be compatible a fragment processor's output must be a modulation of its input color or alpha with a computed premultiplied color or alpha that is in 0..1 range. The computed color or alpha that is modulated against the input cannot depend on the input's alpha. The computed value cannot depend on the input's color channels unless it unpremultiplies the input color channels by the input alpha.

Definition at line 250 of file GrFragmentProcessor.h.

                                               {
        return SkToBool(fFlags & kCompatibleWithCoverageAsAlpha_OptimizationFlag);
    }

Compose()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::Compose ( std::unique_ptr< GrFragmentProcessor >  f, std::unique_ptr< GrFragmentProcessor >  g  )

static

Returns a fragment processor that composes two fragment processors f and g into f(g(x)). This is equivalent to running them in series (g, then f). This is not the same as transfer-mode composition; there is no blending step.

Definition at line 366 of file GrFragmentProcessor.cpp.

                                                                                    {
    class ComposeProcessor : public GrFragmentProcessor {
    public:
        static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor> f,
                                                         std::unique_ptr<GrFragmentProcessor> g) {
            return std::unique_ptr<GrFragmentProcessor>(new ComposeProcessor(std::move(f),
                                                                             std::move(g)));
        }
 
        const char* name() const override { return "Compose"; }
 
        std::unique_ptr<GrFragmentProcessor> clone() const override {
            return std::unique_ptr<GrFragmentProcessor>(new ComposeProcessor(*this));
        }
 
    private:
        std::unique_ptr<ProgramImpl> onMakeProgramImpl() const override {
            class Impl : public ProgramImpl {
            public:
                void emitCode(EmitArgs& args) override {
                    SkString result = this->invokeChild(1, args);         // g(x)
                    result = this->invokeChild(0, result.c_str(), args);  // f(g(x))
                    args.fFragBuilder->codeAppendf("return %s;", result.c_str());
                }
            };
            return std::make_unique<Impl>();
        }
 
        ComposeProcessor(std::unique_ptr<GrFragmentProcessor> f,
                         std::unique_ptr<GrFragmentProcessor> g)
                : INHERITED(kSeriesFragmentProcessor_ClassID,
                            f->optimizationFlags() & g->optimizationFlags()) {
            this->registerChild(std::move(f));
            this->registerChild(std::move(g));
        }
 
        ComposeProcessor(const ComposeProcessor& that) : INHERITED(that) {}
 
        void onAddToKey(const GrShaderCaps&, skgpu::KeyBuilder*) const override {}
 
        bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
 
        SkPMColor4f constantOutputForConstantInput(const SkPMColor4f& inColor) const override {
            SkPMColor4f color = inColor;
            color = ConstantOutputForConstantInput(this->childProcessor(1), color);
            color = ConstantOutputForConstantInput(this->childProcessor(0), color);
            return color;
        }
 
        using INHERITED = GrFragmentProcessor;
    };
 
    // Allow either of the composed functions to be null.
    if (f == nullptr) {
        return g;
    }
    if (g == nullptr) {
        return f;
    }
 
    // Run an optimization pass on this composition.
    GrProcessorAnalysisColor inputColor;
    inputColor.setToUnknown();
 
    std::unique_ptr<GrFragmentProcessor> series[2] = {std::move(g), std::move(f)};
    GrColorFragmentProcessorAnalysis info(inputColor, series, std::size(series));
 
    SkPMColor4f knownColor;
    int leadingFPsToEliminate = info.initialProcessorsToEliminate(&knownColor);
    switch (leadingFPsToEliminate) {
        default:
            // We shouldn't eliminate more than we started with.
            SkASSERT(leadingFPsToEliminate <= 2);
            [[fallthrough]];
        case 0:
            // Compose the two processors as requested.
            return ComposeProcessor::Make(/*f=*/std::move(series[1]), /*g=*/std::move(series[0]));
        case 1:
            // Replace the first processor with a constant color.
            return ComposeProcessor::Make(/*f=*/std::move(series[1]),
                                          /*g=*/MakeColor(knownColor));
        case 2:
            // Replace the entire composition with a constant color.
            return MakeColor(knownColor);
    }
}

ConstantOutputForConstantInput()

static SkPMColor4f GrFragmentProcessor::ConstantOutputForConstantInput ( const GrFragmentProcessor *  fp, const SkPMColor4f &  input  )

inlinestaticprotected

This allows one subclass to access another subclass's implementation of constantOutputForConstantInput. It must only be called when hasConstantOutputForConstantInput() is known to be true.

Definition at line 370 of file GrFragmentProcessor.h.

                                                                                {
        if (fp) {
            SkASSERT(fp->hasConstantOutputForConstantInput());
            return fp->constantOutputForConstantInput(input);
        } else {
            return input;
        }
    }

constantOutputForConstantInput()

virtual SkPMColor4f GrFragmentProcessor::constantOutputForConstantInput ( const SkPMColor4f &  ) const

inlineprivatevirtual

Reimplemented in GrBicubicEffect, GrSkSLFP, BlendFragmentProcessor, GrColorSpaceXformEffect, and GrMatrixEffect.

Definition at line 424 of file GrFragmentProcessor.h.

                                                                                   {
        SK_ABORT("Subclass must override this if advertising this optimization.");
    }

DestColor()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::DestColor ( )

static

Returns a fragment processor which returns args.fDestColor. This is only meaningful in contexts like blenders, which use a source and dest color.)

Definition at line 355 of file GrFragmentProcessor.cpp.

                                                                  {
    static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForBlender,
        "half4 main(half4 src, half4 dst) {"
            "return dst;"
        "}"
    );
    return GrSkSLFP::Make(effect, "DestColor", /*inputFP=*/nullptr, GrSkSLFP::OptFlags::kNone);
}

DeviceSpace()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::DeviceSpace ( std::unique_ptr< GrFragmentProcessor >  fp )

static

Returns a fragment processor that calls the passed in fragment processor, but evaluates it in device-space (rather than local space).

Definition at line 541 of file GrFragmentProcessor.cpp.

                                               {
    if (!fp) {
        return nullptr;
    }
 
    class DeviceSpace : GrFragmentProcessor {
    public:
        static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor> fp) {
            return std::unique_ptr<GrFragmentProcessor>(new DeviceSpace(std::move(fp)));
        }
 
    private:
        DeviceSpace(std::unique_ptr<GrFragmentProcessor> fp)
                : GrFragmentProcessor(kDeviceSpace_ClassID, fp->optimizationFlags()) {
            // Passing FragCoord here is the reason this is a subclass and not a runtime-FP.
            this->registerChild(std::move(fp), SkSL::SampleUsage::FragCoord());
        }
 
        std::unique_ptr<GrFragmentProcessor> clone() const override {
            auto child = this->childProcessor(0)->clone();
            return std::unique_ptr<GrFragmentProcessor>(new DeviceSpace(std::move(child)));
        }
 
        SkPMColor4f constantOutputForConstantInput(const SkPMColor4f& f) const override {
            return this->childProcessor(0)->constantOutputForConstantInput(f);
        }
 
        std::unique_ptr<ProgramImpl> onMakeProgramImpl() const override {
            class Impl : public ProgramImpl {
            public:
                Impl() = default;
                void emitCode(ProgramImpl::EmitArgs& args) override {
                    auto child = this->invokeChild(0, args.fInputColor, args, "sk_FragCoord.xy");
                    args.fFragBuilder->codeAppendf("return %s;", child.c_str());
                }
            };
            return std::make_unique<Impl>();
        }
 
        void onAddToKey(const GrShaderCaps&, skgpu::KeyBuilder*) const override {}
 
        bool onIsEqual(const GrFragmentProcessor& processor) const override { return true; }
 
        const char* name() const override { return "DeviceSpace"; }
    };
 
    return DeviceSpace::Make(std::move(fp));
}

DisableCoverageAsAlpha()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::DisableCoverageAsAlpha ( std::unique_ptr< GrFragmentProcessor >  fp )

static

Returns a parent fragment processor that adopts the passed fragment processor as a child. The parent will simply return the child's color, but disable the coverage-as-alpha optimization.

Definition at line 340 of file GrFragmentProcessor.cpp.

                                               {
    if (!fp || !fp->compatibleWithCoverageAsAlpha()) {
        return fp;
    }
    static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
        "half4 main(half4 inColor) { return inColor; }"
    );
    SkASSERT(SkRuntimeEffectPriv::SupportsConstantOutputForConstantInput(effect));
    return GrSkSLFP::Make(effect, "DisableCoverageAsAlpha", std::move(fp),
                          GrSkSLFP::OptFlags::kPreservesOpaqueInput);
}

Ellipse()

GrFPResult GrFragmentProcessor::Ellipse ( std::unique_ptr< GrFragmentProcessor >  inputFP, GrClipEdgeType  edgeType, SkPoint  center, SkPoint  radii, const GrShaderCaps &  caps  )

static

Definition at line 698 of file GrFragmentProcessor.cpp.

                                                                  {
    const bool medPrecision = !caps.fFloatIs32Bits;
 
    // Small radii produce bad results on devices without full float.
    if (medPrecision && (radii.fX < 0.5f || radii.fY < 0.5f)) {
        return GrFPFailure(std::move(inputFP));
    }
    // Very narrow ellipses produce bad results on devices without full float
    if (medPrecision && (radii.fX > 255*radii.fY || radii.fY > 255*radii.fX)) {
        return GrFPFailure(std::move(inputFP));
    }
    // Very large ellipses produce bad results on devices without full float
    if (medPrecision && (radii.fX > 16384 || radii.fY > 16384)) {
        return GrFPFailure(std::move(inputFP));
    }
 
    static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
    CLIP_EDGE_SKSL
        "uniform int edgeType;"      // GrClipEdgeType, specialized
        "uniform int medPrecision;"  // !sk_Caps.floatIs32Bits, specialized
 
        "uniform float4 ellipse;"
        "uniform float2 scale;"    // only for medPrecision
 
        "half4 main(float2 xy) {"
            // d is the offset to the ellipse center
            "float2 d = sk_FragCoord.xy - ellipse.xy;"
            // If we're on a device with a "real" mediump then we'll do the distance computation in
            // a space that is normalized by the larger radius or 128, whichever is smaller. The
            // scale uniform will be scale, 1/scale. The inverse squared radii uniform values are
            // already in this normalized space. The center is not.
            "if (bool(medPrecision)) {"
                "d *= scale.y;"
            "}"
            "float2 Z = d * ellipse.zw;"
            // implicit is the evaluation of (x/rx)^2 + (y/ry)^2 - 1.
            "float implicit = dot(Z, d) - 1;"
            // grad_dot is the squared length of the gradient of the implicit.
            "float grad_dot = 4 * dot(Z, Z);"
            // Avoid calling inversesqrt on zero.
            "if (bool(medPrecision)) {"
                "grad_dot = max(grad_dot, 6.1036e-5);"
            "} else {"
                "grad_dot = max(grad_dot, 1.1755e-38);"
            "}"
            "float approx_dist = implicit * inversesqrt(grad_dot);"
            "if (bool(medPrecision)) {"
                "approx_dist *= scale.x;"
            "}"
 
            "half alpha;"
            "if (edgeType == kFillBW) {"
                "alpha = approx_dist > 0.0 ? 0.0 : 1.0;"
            "} else if (edgeType == kFillAA) {"
                "alpha = saturate(0.5 - half(approx_dist));"
            "} else if (edgeType == kInverseFillBW) {"
                "alpha = approx_dist > 0.0 ? 1.0 : 0.0;"
            "} else {"  // edgeType == kInverseFillAA
                "alpha = saturate(0.5 + half(approx_dist));"
            "}"
            "return half4(alpha);"
        "}"
    );
 
    float invRXSqd;
    float invRYSqd;
    SkV2 scale = {1, 1};
    // If we're using a scale factor to work around precision issues, choose the larger radius as
    // the scale factor. The inv radii need to be pre-adjusted by the scale factor.
    if (medPrecision) {
        if (radii.fX > radii.fY) {
            invRXSqd = 1.f;
            invRYSqd = (radii.fX * radii.fX) / (radii.fY * radii.fY);
            scale = {radii.fX, 1.f / radii.fX};
        } else {
            invRXSqd = (radii.fY * radii.fY) / (radii.fX * radii.fX);
            invRYSqd = 1.f;
            scale = {radii.fY, 1.f / radii.fY};
        }
    } else {
        invRXSqd = 1.f / (radii.fX * radii.fX);
        invRYSqd = 1.f / (radii.fY * radii.fY);
    }
    SkV4 ellipse = {center.fX, center.fY, invRXSqd, invRYSqd};
 
    auto ellipseFP = GrSkSLFP::Make(effect, "Ellipse", /*inputFP=*/nullptr,
                                    GrSkSLFP::OptFlags::kCompatibleWithCoverageAsAlpha,
                                    "edgeType", GrSkSLFP::Specialize(static_cast<int>(edgeType)),
                                    "medPrecision",  GrSkSLFP::Specialize<int>(medPrecision),
                                    "ellipse", ellipse,
                                    "scale", scale);
    return GrFPSuccess(GrBlendFragmentProcessor::Make<SkBlendMode::kModulate>(std::move(ellipseFP),
                                                                              std::move(inputFP)));
}

hasConstantOutputForConstantInput() [1/2]

bool GrFragmentProcessor::hasConstantOutputForConstantInput ( ) const

inline

Definition at line 273 of file GrFragmentProcessor.h.

                                                   {
        return SkToBool(fFlags & kConstantOutputForConstantInput_OptimizationFlag);
    }

hasConstantOutputForConstantInput() [2/2]

bool GrFragmentProcessor::hasConstantOutputForConstantInput ( SkPMColor4f  inputColor, SkPMColor4f *  outputColor  ) const

inline

Tests whether given a constant input color the processor produces a constant output color (for all fragments). If true outputColor will contain the constant color produces for inputColor.

Definition at line 266 of file GrFragmentProcessor.h.

                                                                                                   {
        if (fFlags & kConstantOutputForConstantInput_OptimizationFlag) {
            *outputColor = this->constantOutputForConstantInput(inputColor);
            return true;
        }
        return false;
    }

HighPrecision()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::HighPrecision ( std::unique_ptr< GrFragmentProcessor >  fp )

static

Returns a fragment processor that calls the passed in fragment processor, but ensures the entire program is compiled with high-precision types.

Definition at line 799 of file GrFragmentProcessor.cpp.

                                               {
    class HighPrecisionFragmentProcessor : public GrFragmentProcessor {
    public:
        static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor> fp) {
            return std::unique_ptr<GrFragmentProcessor>(
                    new HighPrecisionFragmentProcessor(std::move(fp)));
        }
 
        const char* name() const override { return "HighPrecision"; }
 
        std::unique_ptr<GrFragmentProcessor> clone() const override {
            return Make(this->childProcessor(0)->clone());
        }
 
    private:
        HighPrecisionFragmentProcessor(std::unique_ptr<GrFragmentProcessor> fp)
                : INHERITED(kHighPrecisionFragmentProcessor_ClassID,
                            ProcessorOptimizationFlags(fp.get())) {
            this->registerChild(std::move(fp));
        }
 
        std::unique_ptr<ProgramImpl> onMakeProgramImpl() const override {
            class Impl : public ProgramImpl {
            public:
                void emitCode(EmitArgs& args) override {
                    SkString childColor = this->invokeChild(0, args);
 
                    args.fFragBuilder->forceHighPrecision();
                    args.fFragBuilder->codeAppendf("return %s;", childColor.c_str());
                }
            };
            return std::make_unique<Impl>();
        }
 
        void onAddToKey(const GrShaderCaps&, skgpu::KeyBuilder*) const override {}
        bool onIsEqual(const GrFragmentProcessor& other) const override { return true; }
 
        SkPMColor4f constantOutputForConstantInput(const SkPMColor4f& input) const override {
            return ConstantOutputForConstantInput(this->childProcessor(0), input);
        }
 
        using INHERITED = GrFragmentProcessor;
    };
 
    return HighPrecisionFragmentProcessor::Make(std::move(fp));
}

isBlendFunction()

bool GrFragmentProcessor::isBlendFunction ( ) const

inline

Does the SkSL for this FP take two colors as its input arguments?

Definition at line 209 of file GrFragmentProcessor.h.

                                 {
        return SkToBool(fFlags & kIsBlendFunction_Flag);
    }

isEqual()

bool GrFragmentProcessor::isEqual

(

const GrFragmentProcessor &

that

)

const

Returns true if this and other processor conservatively draw identically. It can only return true when the two processor are of the same subclass (i.e. they return the same object from from getFactory()).

A return value of true from isEqual() should not be used to test whether the processor would generate the same shader code. To test for identical code generation use addToKey.

Definition at line 25 of file GrFragmentProcessor.cpp.

                                                                       {
    if (this->classID() != that.classID()) {
        return false;
    }
    if (this->sampleUsage() != that.sampleUsage()) {
        return false;
    }
    if (!this->onIsEqual(that)) {
        return false;
    }
    if (this->numChildProcessors() != that.numChildProcessors()) {
        return false;
    }
    for (int i = 0; i < this->numChildProcessors(); ++i) {
        auto thisChild = this->childProcessor(i),
             thatChild = that .childProcessor(i);
        if (SkToBool(thisChild) != SkToBool(thatChild)) {
            return false;
        }
        if (thisChild && !thisChild->isEqual(*thatChild)) {
            return false;
        }
    }
    return true;
}

MakeColor()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::MakeColor ( SkPMColor4f  color )

static

Always returns 'color'.

Definition at line 193 of file GrFragmentProcessor.cpp.

                                                                                   {
    // Use ColorFilter signature/factory to get the constant output for constant input optimization
    static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
        "uniform half4 color;"
        "half4 main(half4 inColor) { return color; }"
    );
    SkASSERT(SkRuntimeEffectPriv::SupportsConstantOutputForConstantInput(effect));
    return GrSkSLFP::Make(effect, "color_fp", /*inputFP=*/nullptr,
                          color.isOpaque() ? GrSkSLFP::OptFlags::kPreservesOpaqueInput
                                           : GrSkSLFP::OptFlags::kNone,
                          "color", color);
}

makeProgramImpl()

std::unique_ptr< GrFragmentProcessor::ProgramImpl > GrFragmentProcessor::makeProgramImpl

(

)

const

Definition at line 119 of file GrFragmentProcessor.cpp.

                                                                                         {
    std::unique_ptr<ProgramImpl> impl = this->onMakeProgramImpl();
    impl->fChildProcessors.push_back_n(fChildProcessors.size());
    for (int i = 0; i < fChildProcessors.size(); ++i) {
        impl->fChildProcessors[i] = fChildProcessors[i] ? fChildProcessors[i]->makeProgramImpl()
                                                        : nullptr;
    }
    return impl;
}

mergeOptimizationFlags()

void GrFragmentProcessor::mergeOptimizationFlags ( OptimizationFlags  flags )

inlineprotected

Definition at line 418 of file GrFragmentProcessor.h.

                                                         {
        SkASSERT((flags & ~kAll_OptimizationFlags) == 0);
        fFlags &= (flags | ~kAll_OptimizationFlags);
    }

ModulateForClampedSamplerOptFlags()

static OptimizationFlags GrFragmentProcessor::ModulateForClampedSamplerOptFlags ( SkAlphaType  alphaType )

inlinestaticprotected

Definition at line 337 of file GrFragmentProcessor.h.

                                                                                      {
        if (alphaType == kOpaque_SkAlphaType) {
            return kCompatibleWithCoverageAsAlpha_OptimizationFlag |
                   kPreservesOpaqueInput_OptimizationFlag;
        } else {
            return kCompatibleWithCoverageAsAlpha_OptimizationFlag;
        }
    }

ModulateForSamplerOptFlags()

static OptimizationFlags GrFragmentProcessor::ModulateForSamplerOptFlags ( SkAlphaType  alphaType, bool  samplingDecal  )

inlinestaticprotected

Can be used as a helper to decide which fragment processor OptimizationFlags should be set. This assumes that the subclass output color will be a modulation of the input color with a value read from a texture of the passed color type and that the texture contains premultiplied color or alpha values that are in range.

Since there are multiple ways in which a sampler may have its coordinates clamped or wrapped, callers must determine on their own if the sampling uses a decal strategy in any way, in which case the texture may become transparent regardless of the color type.

Definition at line 328 of file GrFragmentProcessor.h.

                                                                                                   {
        if (samplingDecal) {
            return kCompatibleWithCoverageAsAlpha_OptimizationFlag;
        } else {
            return ModulateForClampedSamplerOptFlags(alphaType);
        }
    }

ModulateRGBA()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::ModulateRGBA ( std::unique_ptr< GrFragmentProcessor >  child, const SkPMColor4f &  color  )

static

Returns a fragment processor that generates the passed-in color, modulated by the child's RGBA color. The child's input color will be the parent's fInputColor. (Pass a null FP to use the color from fInputColor instead of a child FP.)

Definition at line 229 of file GrFragmentProcessor.cpp.

                                                                              {
    auto colorFP = MakeColor(color);
    return GrBlendFragmentProcessor::Make<SkBlendMode::kModulate>(std::move(colorFP),
                                                                  std::move(inputFP));
}

MulInputByChildAlpha()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::MulInputByChildAlpha ( std::unique_ptr< GrFragmentProcessor >  child )

static

Returns the input color, modulated by the child's alpha.

output = input * child.a

Definition at line 206 of file GrFragmentProcessor.cpp.

                                               {
    if (!fp) {
        return nullptr;
    }
    return GrBlendFragmentProcessor::Make<SkBlendMode::kSrcIn>(/*src=*/nullptr, std::move(fp));
}

numChildProcessors()

int GrFragmentProcessor::numChildProcessors ( ) const

inline

Definition at line 193 of file GrFragmentProcessor.h.

{ return fChildProcessors.size(); }

numNonNullChildProcessors()

int GrFragmentProcessor::numNonNullChildProcessors

(

)

const

Definition at line 129 of file GrFragmentProcessor.cpp.

                                                         {
    return std::count_if(fChildProcessors.begin(), fChildProcessors.end(),
                         [](const auto& c) { return c != nullptr; });
}

onAddToKey()

virtual void GrFragmentProcessor::onAddToKey ( const GrShaderCaps &  , skgpu::KeyBuilder *    ) const

privatepure virtual

Implemented in SampleCoordEffect, GrBicubicEffect, ColorTableEffect, GrConvexPolyEffect, GrMatrixEffect, GrSkSLFP, GrTextureEffect, GrYUVtoRGBEffect, GrColorSpaceXformEffect, LazyProxyTest::ClipFP, BlockInputFragmentProcessor, GrModulateAtlasCoverageEffect, BlendFragmentProcessor, and GrPerlinNoise2Effect.

onIsEqual()

virtual bool GrFragmentProcessor::onIsEqual ( const GrFragmentProcessor &  ) const

privatepure virtual

Subclass implements this to support isEqual(). It will only be called if it is known that the two processors are of the same subclass (i.e. have the same ClassID).

Implemented in SampleCoordEffect, GrBicubicEffect, ColorTableEffect, GrMatrixEffect, GrSkSLFP, GrTextureEffect, GrYUVtoRGBEffect, GrColorSpaceXformEffect, LazyProxyTest::ClipFP, BlockInputFragmentProcessor, BlendFragmentProcessor, GrConvexPolyEffect, GrPerlinNoise2Effect, and GrModulateAtlasCoverageEffect.

onMakeProgramImpl()

virtual std::unique_ptr< ProgramImpl > GrFragmentProcessor::onMakeProgramImpl ( ) const

privatepure virtual

Returns a new instance of the appropriate ProgramImpl subclass for the given GrFragmentProcessor. It will emit the appropriate code and live with the cached program to setup uniform data for each draw that uses the program.

Implemented in SampleCoordEffect, GrBicubicEffect, BlendFragmentProcessor, ColorTableEffect, GrConvexPolyEffect, GrMatrixEffect, GrModulateAtlasCoverageEffect, GrPerlinNoise2Effect, GrSkSLFP, GrTextureEffect, GrYUVtoRGBEffect, GrColorSpaceXformEffect, LazyProxyTest::ClipFP, and BlockInputFragmentProcessor.

optimizationFlags()

OptimizationFlags GrFragmentProcessor::optimizationFlags ( ) const

inlineprotected

Definition at line 356 of file GrFragmentProcessor.h.

                                                {
        return static_cast<OptimizationFlags>(kAll_OptimizationFlags & fFlags);
    }

OverrideInput()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::OverrideInput ( std::unique_ptr< GrFragmentProcessor >  fp, const SkPMColor4f &  color  )

static

Returns a parent fragment processor that adopts the passed fragment processor as a child. The parent will ignore its input color and instead feed the passed in color as input to the child.

Definition at line 319 of file GrFragmentProcessor.cpp.

                                                                         {
    if (!fp) {
        return nullptr;
    }
    static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
        "uniform colorFilter fp;"  // Declared as colorFilter so we can pass a color
        "uniform half4 color;"
        "half4 main(half4 inColor) {"
            "return fp.eval(color);"
        "}"
    );
    return GrSkSLFP::Make(effect, "OverrideInput", /*inputFP=*/nullptr,
                          color.isOpaque() ? GrSkSLFP::OptFlags::kPreservesOpaqueInput
                                           : GrSkSLFP::OptFlags::kNone,
                          "fp", std::move(fp),
                          "color", color);
}

parent()

const GrFragmentProcessor * GrFragmentProcessor::parent ( ) const

inline

Definition at line 180 of file GrFragmentProcessor.h.

{ return fParent; }

preservesOpaqueInput()

bool GrFragmentProcessor::preservesOpaqueInput ( ) const

inline

If this is true then all opaque input colors to the processor produce opaque output colors.

Definition at line 257 of file GrFragmentProcessor.h.

                                      {
        return SkToBool(fFlags & kPreservesOpaqueInput_OptimizationFlag);
    }

ProcessorOptimizationFlags()

static OptimizationFlags GrFragmentProcessor::ProcessorOptimizationFlags ( const GrFragmentProcessor *  fp )

inlinestaticprotected

Useful when you can't call fp->optimizationFlags() on a base class object from a subclass.

Definition at line 361 of file GrFragmentProcessor.h.

                                                                                       {
        return fp ? fp->optimizationFlags() : kAll_OptimizationFlags;
    }

Rect()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::Rect ( std::unique_ptr< GrFragmentProcessor >  inputFP, GrClipEdgeType  edgeType, SkRect  rect  )

static

"Shape" FPs, often used for clipping. Each one evaluates a particular kind of shape (rect, circle, ellipse), and modulates the coverage of that shape against the results of the input FP. GrClipEdgeType is used to select inverse/normal fill, and AA or non-AA edges.

Definition at line 604 of file GrFragmentProcessor.cpp.

                                                                                          {
    static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
    CLIP_EDGE_SKSL
        "uniform int edgeType;"  // GrClipEdgeType, specialized
        "uniform float4 rectUniform;"
 
        "half4 main(float2 xy) {"
            "half coverage;"
            "if (edgeType == kFillBW || edgeType == kInverseFillBW) {"
                // non-AA
                "coverage = half(all(greaterThan(float4(sk_FragCoord.xy, rectUniform.zw),"
                                                "float4(rectUniform.xy, sk_FragCoord.xy))));"
            "} else {"
                // compute coverage relative to left and right edges, add, then subtract 1 to
                // account for double counting. And similar for top/bottom.
                "half4 dists4 = saturate(half4(1, 1, -1, -1) *"
                                        "half4(sk_FragCoord.xyxy - rectUniform));"
                "half2 dists2 = dists4.xy + dists4.zw - 1;"
                "coverage = dists2.x * dists2.y;"
            "}"
 
            "if (edgeType == kInverseFillBW || edgeType == kInverseFillAA) {"
                "coverage = 1.0 - coverage;"
            "}"
 
            "return half4(coverage);"
        "}"
    );
 
    SkASSERT(rect.isSorted());
    // The AA math in the shader evaluates to 0 at the uploaded coordinates, so outset by 0.5
    // to interpolate from 0 at a half pixel inset and 1 at a half pixel outset of rect.
    SkRect rectUniform = GrClipEdgeTypeIsAA(edgeType) ? rect.makeOutset(.5f, .5f) : rect;
 
    auto rectFP = GrSkSLFP::Make(effect, "Rect", /*inputFP=*/nullptr,
                                 GrSkSLFP::OptFlags::kCompatibleWithCoverageAsAlpha,
                                "edgeType", GrSkSLFP::Specialize(static_cast<int>(edgeType)),
                                "rectUniform", rectUniform);
    return GrBlendFragmentProcessor::Make<SkBlendMode::kModulate>(std::move(rectFP),
                                                                  std::move(inputFP));
}

registerChild()

void GrFragmentProcessor::registerChild ( std::unique_ptr< GrFragmentProcessor >  child, SkSL::SampleUsage  sampleUsage = SkSL::SampleUsage::PassThrough()  )

protected

FragmentProcessor subclasses call this from their constructor to register any child FragmentProcessors they have. This must be called AFTER all texture accesses and coord transforms have been added. This is for processors whose shader code will be composed of nested processors whose output colors will be combined somehow to produce its output color. Registering these child processors will allow the ProgramBuilder to automatically handle their transformed coords and texture accesses and mangle their uniform and output color names.

The SampleUsage parameter describes all of the ways that the child is sampled by the parent.

Definition at line 146 of file GrFragmentProcessor.cpp.

                                                                     {
    SkASSERT(sampleUsage.isSampled());
 
    if (!child) {
        fChildProcessors.push_back(nullptr);
        return;
    }
 
    // The child should not have been attached to another FP already and not had any sampling
    // strategy set on it.
    SkASSERT(!child->fParent && !child->sampleUsage().isSampled());
 
    // Configure child's sampling state first
    child->fUsage = sampleUsage;
 
    // Propagate the "will read dest-color" flag up to parent FPs.
    if (child->willReadDstColor()) {
        this->setWillReadDstColor();
    }
 
    // If this child receives passthrough or matrix transformed coords from its parent then note
    // that the parent's coords are used indirectly to ensure that they aren't omitted.
    if ((sampleUsage.isPassThrough() || sampleUsage.isUniformMatrix()) &&
        child->usesSampleCoords()) {
        fFlags |= kUsesSampleCoordsIndirectly_Flag;
    }
 
    // Record that the child is attached to us; this FP is the source of any uniform data needed
    // to evaluate the child sample matrix.
    child->fParent = this;
    fChildProcessors.push_back(std::move(child));
 
    // Validate: our sample strategy comes from a parent we shouldn't have yet.
    SkASSERT(!fUsage.isSampled() && !fParent);
}

sampleUsage()

const SkSL::SampleUsage & GrFragmentProcessor::sampleUsage ( ) const

inline

Definition at line 234 of file GrFragmentProcessor.h.

                                               {
        return fUsage;
    }

setIsBlendFunction()

void GrFragmentProcessor::setIsBlendFunction ( )

inlineprotected

Definition at line 414 of file GrFragmentProcessor.h.

                              {
        fFlags |= kIsBlendFunction_Flag;
    }

setUsesSampleCoordsDirectly()

void GrFragmentProcessor::setUsesSampleCoordsDirectly ( )

inlineprotected

Definition at line 402 of file GrFragmentProcessor.h.

                                       {
        fFlags |= kUsesSampleCoordsDirectly_Flag;
    }

setWillReadDstColor()

void GrFragmentProcessor::setWillReadDstColor ( )

inlineprotected

Definition at line 408 of file GrFragmentProcessor.h.

                               {
        fFlags |= kWillReadDstColor_Flag;
    }

SkDEBUGCODE()

GrFragmentProcessor::SkDEBUGCODE ( bool isInstantiated() const ;  ) const

inline

Do any of the FPs in this tree read back the color from the destination surface?

Definition at line 201 of file GrFragmentProcessor.h.

                                  {
        return SkToBool(fFlags & kWillReadDstColor_Flag);
    }

SurfaceColor()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::SurfaceColor ( )

static

Returns a fragment processor that reads back the color on the surface being painted; that is, sampling this will return the color of the pixel that is currently being painted over.

Definition at line 501 of file GrFragmentProcessor.cpp.

                                                                     {
    class SurfaceColorProcessor : public GrFragmentProcessor {
    public:
        static std::unique_ptr<GrFragmentProcessor> Make() {
            return std::unique_ptr<GrFragmentProcessor>(new SurfaceColorProcessor());
        }
 
        std::unique_ptr<GrFragmentProcessor> clone() const override { return Make(); }
 
        const char* name() const override { return "SurfaceColor"; }
 
    private:
        std::unique_ptr<ProgramImpl> onMakeProgramImpl() const override {
            class Impl : public ProgramImpl {
            public:
                void emitCode(EmitArgs& args) override {
                    const char* dstColor = args.fFragBuilder->dstColor();
                    args.fFragBuilder->codeAppendf("return %s;", dstColor);
                }
            };
            return std::make_unique<Impl>();
        }
 
        SurfaceColorProcessor()
                : INHERITED(kSurfaceColorProcessor_ClassID, kNone_OptimizationFlags) {
            this->setWillReadDstColor();
        }
 
        void onAddToKey(const GrShaderCaps&, skgpu::KeyBuilder*) const override {}
 
        bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
 
        using INHERITED = GrFragmentProcessor;
    };
 
    return SurfaceColorProcessor::Make();
}

SwizzleOutput()

std::unique_ptr< GrFragmentProcessor > GrFragmentProcessor::SwizzleOutput ( std::unique_ptr< GrFragmentProcessor >  fp, const skgpu::Swizzle &  swizzle  )

static

Returns a fragment processor that calls the passed in fragment processor, and then swizzles the output.

Definition at line 249 of file GrFragmentProcessor.cpp.

                                                                            {
    class SwizzleFragmentProcessor : public GrFragmentProcessor {
    public:
        static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor> fp,
                                                         const skgpu::Swizzle& swizzle) {
            return std::unique_ptr<GrFragmentProcessor>(
                    new SwizzleFragmentProcessor(std::move(fp), swizzle));
        }
 
        const char* name() const override { return "Swizzle"; }
 
        std::unique_ptr<GrFragmentProcessor> clone() const override {
            return Make(this->childProcessor(0)->clone(), fSwizzle);
        }
 
    private:
        SwizzleFragmentProcessor(std::unique_ptr<GrFragmentProcessor> fp,
                                 const skgpu::Swizzle& swizzle)
                : INHERITED(kSwizzleFragmentProcessor_ClassID, ProcessorOptimizationFlags(fp.get()))
                , fSwizzle(swizzle) {
            this->registerChild(std::move(fp));
        }
 
        std::unique_ptr<ProgramImpl> onMakeProgramImpl() const override {
            class Impl : public ProgramImpl {
            public:
                void emitCode(EmitArgs& args) override {
                    SkString childColor = this->invokeChild(0, args);
 
                    const SwizzleFragmentProcessor& sfp = args.fFp.cast<SwizzleFragmentProcessor>();
                    const skgpu::Swizzle& swizzle = sfp.fSwizzle;
                    GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
 
                    fragBuilder->codeAppendf("return %s.%s;",
                                             childColor.c_str(), swizzle.asString().c_str());
                }
            };
            return std::make_unique<Impl>();
        }
 
        void onAddToKey(const GrShaderCaps&, skgpu::KeyBuilder* b) const override {
            b->add32(fSwizzle.asKey());
        }
 
        bool onIsEqual(const GrFragmentProcessor& other) const override {
            const SwizzleFragmentProcessor& sfp = other.cast<SwizzleFragmentProcessor>();
            return fSwizzle == sfp.fSwizzle;
        }
 
        SkPMColor4f constantOutputForConstantInput(const SkPMColor4f& input) const override {
            return fSwizzle.applyTo(ConstantOutputForConstantInput(this->childProcessor(0), input));
        }
 
        skgpu::Swizzle fSwizzle;
 
        using INHERITED = GrFragmentProcessor;
    };
 
    if (!fp) {
        return nullptr;
    }
    if (skgpu::Swizzle::RGBA() == swizzle) {
        return fp;
    }
    return SwizzleFragmentProcessor::Make(std::move(fp), swizzle);
}

usesSampleCoords()

bool GrFragmentProcessor::usesSampleCoords ( ) const

inline

True if this FP uses its input coordinates or if any descendant FP uses them through a chain of non-explicit sample usages. (e.g. uses EmitArgs::fSampleCoord in emitCode()). This is decided at FP-tree construction time and is not affected by lifting coords to varyings.

Definition at line 227 of file GrFragmentProcessor.h.

                                  {
        return SkToBool(fFlags & (kUsesSampleCoordsDirectly_Flag |
                                  kUsesSampleCoordsIndirectly_Flag));
    }

usesSampleCoordsDirectly()

bool GrFragmentProcessor::usesSampleCoordsDirectly ( ) const

inline

True if this FP refers directly to the sample coordinate parameter of its function (e.g. uses EmitArgs::fSampleCoord in emitCode()). This is decided at FP-tree construction time and is not affected by lifting coords to varyings.

Definition at line 218 of file GrFragmentProcessor.h.

                                          {
        return SkToBool(fFlags & kUsesSampleCoordsDirectly_Flag);
    }

visitProxies()

void GrFragmentProcessor::visitProxies

(

const GrVisitProxyFunc &

func

)

const

Definition at line 51 of file GrFragmentProcessor.cpp.

                                                                         {
    this->visitTextureEffects([&func](const GrTextureEffect& te) {
        func(te.view().proxy(), te.samplerState().mipmapped());
    });
}

visitTextureEffects()

void GrFragmentProcessor::visitTextureEffects

(

const std::function< void(const GrTextureEffect &)> &

func

)

const

Definition at line 57 of file GrFragmentProcessor.cpp.

                                                                     {
    if (auto* te = this->asTextureEffect()) {
        func(*te);
    }
    for (auto& child : fChildProcessors) {
        if (child) {
            child->visitTextureEffects(func);
        }
    }
}

visitWithImpls()

void GrFragmentProcessor::visitWithImpls	(	const std::function< void(const GrFragmentProcessor &, ProgramImpl &)> &	f,
		ProgramImpl &	impl
	)		const

Definition at line 69 of file GrFragmentProcessor.cpp.

                                 {
    f(*this, impl);
    SkASSERT(impl.numChildProcessors() == this->numChildProcessors());
    for (int i = 0; i < this->numChildProcessors(); ++i) {
        if (const auto* child = this->childProcessor(i)) {
            child->visitWithImpls(f, *impl.childProcessor(i));
        }
    }
}

---

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

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