#include <GrSkSLFP.h>

Inheritance diagram for GrSkSLFP:

Classes
struct	GrIgnoreOptFlags

struct	GrOptionalUniform

struct	GrSpecializedUniform

class	Impl

Public Types
enum class	OptFlags : uint32_t { kNone = kNone_OptimizationFlags , kCompatibleWithCoverageAsAlpha = kCompatibleWithCoverageAsAlpha_OptimizationFlag , kPreservesOpaqueInput = kPreservesOpaqueInput_OptimizationFlag , kAll = kCompatibleWithCoverageAsAlpha \| kPreservesOpaqueInput }

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 }

Public Member Functions
const char *	name () const override

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

Public Member Functions inherited from GrFragmentProcessor
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

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
template<typename T >
static GrSpecializedUniform< T >	Specialize (const T &value)

template<typename T >
static GrSpecializedUniform< T >	SpecializeIf (bool condition, const T &value)

template<typename T >
static GrOptionalUniform< T >	When (bool condition, const T &value)

static GrIgnoreOptFlags	IgnoreOptFlags (std::unique_ptr< GrFragmentProcessor > child)

static std::unique_ptr< GrSkSLFP >	MakeWithData (sk_sp< SkRuntimeEffect > effect, const char *name, sk_sp< SkColorSpace > dstColorSpace, std::unique_ptr< GrFragmentProcessor > inputFP, std::unique_ptr< GrFragmentProcessor > destColorFP, const sk_sp< const SkData > &uniforms, SkSpan< std::unique_ptr< GrFragmentProcessor > > childFPs)

template<typename... Args>
static std::unique_ptr< GrSkSLFP >	Make (const SkRuntimeEffect effect, const char name, std::unique_ptr< GrFragmentProcessor > inputFP, OptFlags optFlags, Args &&... args)

Static Public Member Functions inherited from GrFragmentProcessor
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 >)

Private Member Functions
std::unique_ptr< ProgramImpl >	onMakeProgramImpl () const override

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

bool	onIsEqual (const GrFragmentProcessor &) const override

SkPMColor4f	constantOutputForConstantInput (const SkPMColor4f &) const override

Friends
class	GrSkSLFPFactory

Additional Inherited Members
Protected Types inherited from GrFragmentProcessor
enum	OptimizationFlags : uint32_t { kNone_OptimizationFlags , kCompatibleWithCoverageAsAlpha_OptimizationFlag = 0x1 , kPreservesOpaqueInput_OptimizationFlag = 0x2 , kConstantOutputForConstantInput_OptimizationFlag = 0x4 , kAll_OptimizationFlags }

Protected Member Functions inherited from GrFragmentProcessor
	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 inherited from GrFragmentProcessor
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)

Protected Attributes inherited from GrProcessor
const ClassID	fClassID

Detailed Description

Definition at line 69 of file GrSkSLFP.h.

Member Enumeration Documentation

◆ OptFlags

enum class GrSkSLFP::OptFlags : uint32_t

strong

Enumerator
kNone
kCompatibleWithCoverageAsAlpha
kPreservesOpaqueInput
kAll

Definition at line 100 of file GrSkSLFP.h.

                        : uint32_t {
        kNone                          = kNone_OptimizationFlags,
        kCompatibleWithCoverageAsAlpha = kCompatibleWithCoverageAsAlpha_OptimizationFlag,
        kPreservesOpaqueInput          = kPreservesOpaqueInput_OptimizationFlag,
        kAll                           = kCompatibleWithCoverageAsAlpha | kPreservesOpaqueInput,
    };

Member Function Documentation

◆ clone()

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

overridevirtual

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

Implements GrFragmentProcessor.

Definition at line 448 of file GrSkSLFP.cpp.

                                                         {
    return std::unique_ptr<GrFragmentProcessor>(new (UniformPayloadSize(fEffect.get()))
                                                        GrSkSLFP(*this));
}

◆ constantOutputForConstantInput()

SkPMColor4f GrSkSLFP::constantOutputForConstantInput ( const SkPMColor4f & inputColor ) const

overrideprivatevirtual

Reimplemented from GrFragmentProcessor.

Definition at line 453 of file GrSkSLFP.cpp.

                                                                                        {
    SkPMColor4f color = (fInputChildIndex >= 0)
            ? ConstantOutputForConstantInput(this->childProcessor(fInputChildIndex), inputColor)
            : inputColor;
 
    class ConstantOutputForConstantInput_SkRPCallbacks : public SkSL::RP::Callbacks {
    public:
        bool appendShader(int index) override {
           SkDEBUGFAIL("constant-output-for-constant-input unsupported when child shaders present");
           return false;
        }
        bool appendColorFilter(int index) override {
           SkDEBUGFAIL("constant-output-for-constant-input unsupported when child shaders present");
           return false;
        }
        bool appendBlender(int index) override {
           SkDEBUGFAIL("constant-output-for-constant-input unsupported when child shaders present");
           return false;
        }
        void toLinearSrgb(const void* color) override { /* identity color conversion */ }
        void fromLinearSrgb(const void* color) override { /* identity color conversion */ }
    };
 
    if (const SkSL::RP::Program* program = fEffect->getRPProgram(/*debugTrace=*/nullptr)) {
        // No color conversion is happening here, so we can use untransformed uniforms.
        SkSpan<const float> uniforms{reinterpret_cast<const float*>(this->uniformData()),
                                     fUniformSize / sizeof(float)};
        SkSTArenaAlloc<2048> alloc;  // sufficient for a tiny SkSL program
        SkRasterPipeline pipeline(&alloc);
        pipeline.appendConstantColor(&alloc, color.vec());
        ConstantOutputForConstantInput_SkRPCallbacks callbacks;
        if (program->appendStages(&pipeline, &alloc, &callbacks, uniforms)) {
            SkPMColor4f outputColor;
            SkRasterPipeline_MemoryCtx outputCtx = {&outputColor, 0};
            pipeline.append(SkRasterPipelineOp::store_f32, &outputCtx);
            pipeline.run(0, 0, 1, 1);
            return outputColor;
        }
    }
 
    // We weren't able to run the Raster Pipeline program.
    return color;
}

◆ IgnoreOptFlags()

static GrIgnoreOptFlags GrSkSLFP::IgnoreOptFlags ( std::unique_ptr< GrFragmentProcessor > child )

inlinestatic

Definition at line 96 of file GrSkSLFP.h.

                                                                                     {
        return {std::move(child)};
    }

◆ Make()

template<typename... Args>

static std::unique_ptr< GrSkSLFP > GrSkSLFP::Make	(	const SkRuntimeEffect *	effect,
		const char *	name,
		std::unique_ptr< GrFragmentProcessor >	inputFP,
		OptFlags	optFlags,
		Args &&...	args
	)

inlinestatic

Definition at line 158 of file GrSkSLFP.h.

                                                          {
#ifdef SK_DEBUG
        checkArgs(effect->fUniforms.begin(),
                  effect->fUniforms.end(),
                  effect->fChildren.begin(),
                  effect->fChildren.end(),
                  std::forward<Args>(args)...);
#endif
        // This factory is used internally (for "runtime FPs"). We don't pass/know the destination
        // color space, so these effects can't use the color transform intrinsics. Callers of this
        // factory should instead construct an GrColorSpaceXformEffect as part of the FP tree.
        SkASSERT(!effect->usesColorTransform());
 
        size_t uniformPayloadSize = UniformPayloadSize(effect);
        std::unique_ptr<GrSkSLFP> fp(new (uniformPayloadSize) GrSkSLFP(sk_ref_sp(effect),
                                                                       name, optFlags));
        fp->appendArgs(fp->uniformData(), fp->specialized(), std::forward<Args>(args)...);
        if (inputFP) {
            fp->setInput(std::move(inputFP));
        }
        return fp;
    }

◆ MakeWithData()

std::unique_ptr< GrSkSLFP > GrSkSLFP::MakeWithData	(	sk_sp< SkRuntimeEffect >	effect,
		const char *	name,
		sk_sp< SkColorSpace >	dstColorSpace,
		std::unique_ptr< GrFragmentProcessor >	inputFP,
		std::unique_ptr< GrFragmentProcessor >	destColorFP,
		const sk_sp< const SkData > &	uniforms,
		SkSpan< std::unique_ptr< GrFragmentProcessor > >	childFPs
	)

static

Both factories support a single 'input' FP, as well as a collection of other 'child' FPs. The 'child' FPs correspond to the children declared in the effect's SkSL. The inputFP is optional, and intended for instances that have color filter semantics. This is an implicit child - if present, it's evaluated to produce the input color fed to the SkSL. Otherwise, the SkSL receives this FP's input color directly. Creates a new fragment processor from an SkRuntimeEffect and a data blob containing values for all of the 'uniform' variables in the SkSL source. The layout of the uniforms blob is dictated by the SkRuntimeEffect.

Definition at line 289 of file GrSkSLFP.cpp.

                                                             {
    if (uniforms->size() != effect->uniformSize()) {
        return nullptr;
    }
    size_t uniformSize = uniforms->size();
    size_t specializedSize = effect->uniforms().size() * sizeof(Specialized);
    std::unique_ptr<GrSkSLFP> fp(new (uniformSize + specializedSize)
                                         GrSkSLFP(std::move(effect), name, OptFlags::kNone));
    sk_careful_memcpy(fp->uniformData(), uniforms->data(), uniformSize);
    for (auto& childFP : childFPs) {
        fp->addChild(std::move(childFP), /*mergeOptFlags=*/true);
    }
    if (inputFP) {
        fp->setInput(std::move(inputFP));
    }
    if (destColorFP) {
        fp->setDestColorFP(std::move(destColorFP));
    }
    if (fp->fEffect->usesColorTransform() && dstColorSpace) {
        fp->addColorTransformChildren(dstColorSpace.get());
    }
    return fp;
}

◆ name()

const char * GrSkSLFP::name ( ) const

inlineoverridevirtual

Human-meaningful string to identify this processor; may be embedded in generated shader code and must be a legal SkSL identifier prefix.

Implements GrProcessor.

Definition at line 185 of file GrSkSLFP.h.

185{ return fName; }

◆ onAddToKey()

void GrSkSLFP::onAddToKey	(	const GrShaderCaps &	caps,
		skgpu::KeyBuilder *	b
	)		const

overrideprivatevirtual

Implements GrFragmentProcessor.

Definition at line 416 of file GrSkSLFP.cpp.

                                                                            {
    // In the unlikely event of a hash collision, we also include the uniform size in the key.
    // That ensures that we will (at worst) use the wrong program, but one that expects the same
    // amount of uniform data.
    b->add32(fEffect->hash());
    b->add32(fUniformSize);
 
    const Specialized* specialized = this->specialized();
    const uint8_t* uniformData = this->uniformData();
    size_t uniformCount = this->uniformCount();
    auto iter = fEffect->uniforms().begin();
 
    for (size_t i = 0; i < uniformCount; ++i, ++iter) {
        bool specialize = specialized[i] == Specialized::kYes;
        b->addBool(specialize, "specialize");
        if (specialize) {
            b->addBytes(iter->sizeInBytes(), uniformData + iter->offset, iter->name);
        }
    }
}

◆ onIsEqual()

bool GrSkSLFP::onIsEqual ( const GrFragmentProcessor & ) const

overrideprivatevirtual

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).

Implements GrFragmentProcessor.

Definition at line 437 of file GrSkSLFP.cpp.

                                                               {
    const GrSkSLFP& sk = other.cast<GrSkSLFP>();
    const size_t specializedSize = this->uniformCount() * sizeof(Specialized);
    return fEffect->hash() == sk.fEffect->hash() &&
           this->uniformCount() == sk.uniformCount() &&
           fUniformSize == sk.fUniformSize &&
           !sk_careful_memcmp(this->uniformData(),
                              sk.uniformData(),
                              fUniformSize + specializedSize);
}

◆ onMakeProgramImpl()

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

overrideprivatevirtual

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.

Implements GrFragmentProcessor.

Definition at line 412 of file GrSkSLFP.cpp.

                                                                                {
    return std::make_unique<Impl>();
}

◆ Specialize()

template<typename T >

static GrSpecializedUniform< T > GrSkSLFP::Specialize ( const T & value )

inlinestatic

Definition at line 76 of file GrSkSLFP.h.

                                                              {
        return {true, value};
    }

◆ SpecializeIf()

template<typename T >

static GrSpecializedUniform< T > GrSkSLFP::SpecializeIf	(	bool	condition,
		const T &	value
	)

inlinestatic

Definition at line 80 of file GrSkSLFP.h.

                                                                                {
        return {condition, value};
    }

◆ When()

template<typename T >

static GrOptionalUniform< T > GrSkSLFP::When	(	bool	condition,
		const T &	value
	)

inlinestatic

Definition at line 89 of file GrSkSLFP.h.

                                                                     {
        return {condition, value};
    }

Friends And Related Symbol Documentation

◆ GrSkSLFPFactory

friend class GrSkSLFPFactory

friend

Definition at line 444 of file GrSkSLFP.h.

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

third_party/skia/src/gpu/ganesh/effects/GrSkSLFP.h
third_party/skia/src/gpu/ganesh/effects/GrSkSLFP.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ OptFlags

Member Function Documentation

◆ clone()

◆ constantOutputForConstantInput()

◆ IgnoreOptFlags()

◆ Make()

◆ MakeWithData()

◆ name()

◆ onAddToKey()

◆ onIsEqual()

◆ onMakeProgramImpl()

◆ Specialize()

◆ SpecializeIf()

◆ When()

Friends And Related Symbol Documentation

◆ GrSkSLFPFactory