GrFragmentProcessor::ProgramImpl Class Reference

#include <GrFragmentProcessor.h>

Inheritance diagram for GrFragmentProcessor::ProgramImpl:

Classes
struct	EmitArgs
class	Iter

Public Types
using	UniformHandle = GrGLSLUniformHandler::UniformHandle
using	SamplerHandle = GrGLSLUniformHandler::SamplerHandle

Public Member Functions
	ProgramImpl ()=default
virtual	~ProgramImpl ()=default
virtual void	emitCode (EmitArgs &)=0
void	setData (const GrGLSLProgramDataManager &pdman, const GrFragmentProcessor &processor)
int	numChildProcessors () const
ProgramImpl *	childProcessor (int index) const
void	setFunctionName (SkString name)
const char *	functionName () const
SkString	invokeChild (int childIndex, EmitArgs &parentArgs, std::string_view skslCoords={})
SkString	invokeChildWithMatrix (int childIndex, EmitArgs &parentArgs)
SkString	invokeChild (int childIndex, const char *inputColor, EmitArgs &parentArgs, std::string_view skslCoords={})
SkString	invokeChildWithMatrix (int childIndex, const char *inputColor, EmitArgs &parentArgs)
SkString	invokeChild (int childIndex, const char *inputColor, const char *destColor, EmitArgs &parentArgs, std::string_view skslCoords={})
SkString	invokeChildWithMatrix (int childIndex, const char *inputColor, const char *destColor, EmitArgs &parentArgs)

Private Member Functions
virtual void	onSetData (const GrGLSLProgramDataManager &, const GrFragmentProcessor &)

Friends
class	GrFragmentProcessor

Detailed Description

Definition at line 472 of file GrFragmentProcessor.h.

Member Typedef Documentation

SamplerHandle

using GrFragmentProcessor::ProgramImpl::SamplerHandle = GrGLSLUniformHandler::SamplerHandle

Definition at line 479 of file GrFragmentProcessor.h.

UniformHandle

using GrFragmentProcessor::ProgramImpl::UniformHandle = GrGLSLUniformHandler::UniformHandle

Definition at line 478 of file GrFragmentProcessor.h.

Constructor & Destructor Documentation

ProgramImpl()

GrFragmentProcessor::ProgramImpl::ProgramImpl ( )

default

~ProgramImpl()

virtual GrFragmentProcessor::ProgramImpl::~ProgramImpl ( )

virtualdefault

Member Function Documentation

childProcessor()

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

inline

Definition at line 533 of file GrFragmentProcessor.h.

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

emitCode()

virtual void GrFragmentProcessor::ProgramImpl::emitCode ( EmitArgs &  )

pure virtual

Implemented in GrBicubicEffect::Impl, CircularRRectEffect::Impl, EllipticalRRectEffect::Impl, GrTextureEffect::Impl, and GrSkSLFP::Impl.

functionName()

const char * GrFragmentProcessor::ProgramImpl::functionName ( ) const

inline

Definition at line 540 of file GrFragmentProcessor.h.

                                     {
        SkASSERT(!fFunctionName.isEmpty());
        return fFunctionName.c_str();
    }

invokeChild() [1/3]

SkString ProgramImpl::invokeChild	(	int	childIndex,
		const char *	inputColor,
		const char *	destColor,
		EmitArgs &	parentArgs,
		std::string_view	skslCoords = {}
	)

Invokes a child proc in its own scope. Pass in the parent's EmitArgs and invokeChild will automatically extract the coords and samplers of that child and pass them on to the child's emitCode(). Also, any uniforms or functions emitted by the child will have their names mangled to prevent redefinitions. The returned string contains the output color (as a call to the child's helper function). It is legal to pass nullptr as inputColor, since all fragment processors are required to work without an input color.

When skslCoords is empty, the child is invoked at the sample coordinates from parentArgs. When skslCoords is not empty, is must be an SkSL expression that evaluates to a float2. That expression is passed to the child's processor function as the "_coords" argument.

Definition at line 856 of file GrFragmentProcessor.cpp.

                                                             {
    SkASSERT(childIndex >= 0);
 
    if (!inputColor) {
        inputColor = args.fInputColor;
    }
 
    const GrFragmentProcessor* childProc = args.fFp.childProcessor(childIndex);
    if (!childProc) {
        // If no child processor is provided, return the input color as-is.
        return SkString(inputColor);
    }
 
    auto invocation = SkStringPrintf("%s(%s", this->childProcessor(childIndex)->functionName(),
                                     inputColor);
 
    if (childProc->isBlendFunction()) {
        if (!destColor) {
            destColor = args.fFp.isBlendFunction() ? args.fDestColor : "half4(1)";
        }
        invocation.appendf(", %s", destColor);
    }
 
    // Assert that the child has no sample matrix. A uniform matrix sample call would go through
    // invokeChildWithMatrix, not here.
    SkASSERT(!childProc->sampleUsage().isUniformMatrix());
 
    if (args.fFragBuilder->getProgramBuilder()->fragmentProcessorHasCoordsParam(childProc)) {
        SkASSERT(!childProc->sampleUsage().isFragCoord() || skslCoords == "sk_FragCoord.xy");
        // The child's function takes a half4 color and a float2 coordinate
        if (!skslCoords.empty()) {
            invocation.appendf(", %.*s", (int)skslCoords.size(), skslCoords.data());
        } else {
            invocation.appendf(", %s", args.fSampleCoord);
        }
    }
 
    invocation.append(")");
    return invocation;
}

invokeChild() [2/3]

SkString GrFragmentProcessor::ProgramImpl::invokeChild ( int  childIndex, const char *  inputColor, EmitArgs &  parentArgs, std::string_view  skslCoords = {}  )

inline

Definition at line 564 of file GrFragmentProcessor.h.

                                                            {}) {
        return this->invokeChild(childIndex,
                                 inputColor,
                                 /*destColor=*/nullptr,
                                 parentArgs,
                                 skslCoords);
    }

invokeChild() [3/3]

SkString GrFragmentProcessor::ProgramImpl::invokeChild ( int  childIndex, EmitArgs &  parentArgs, std::string_view  skslCoords = {}  )

inline

Definition at line 546 of file GrFragmentProcessor.h.

                                                            {}) {
        return this->invokeChild(childIndex,
                                 /*inputColor=*/nullptr,
                                 /*destColor=*/nullptr,
                                 parentArgs,
                                 skslCoords);
    }

invokeChildWithMatrix() [1/3]

SkString ProgramImpl::invokeChildWithMatrix	(	int	childIndex,
		const char *	inputColor,
		const char *	destColor,
		EmitArgs &	parentArgs
	)

As invokeChild, but transforms the coordinates according to the matrix expression attached to the child's SampleUsage object. This is only valid if the child is sampled with a const-uniform matrix.

Definition at line 901 of file GrFragmentProcessor.cpp.

                                                            {
    SkASSERT(childIndex >= 0);
 
    if (!inputColor) {
        inputColor = args.fInputColor;
    }
 
    const GrFragmentProcessor* childProc = args.fFp.childProcessor(childIndex);
    if (!childProc) {
        // If no child processor is provided, return the input color as-is.
        return SkString(inputColor);
    }
 
    SkASSERT(childProc->sampleUsage().isUniformMatrix());
 
    // Every uniform matrix has the same (initial) name. Resolve that into the mangled name:
    GrShaderVar uniform = args.fUniformHandler->getUniformMapping(
            args.fFp, SkString(SkSL::SampleUsage::MatrixUniformName()));
    SkASSERT(uniform.getType() == SkSLType::kFloat3x3);
    const SkString& matrixName(uniform.getName());
 
    auto invocation = SkStringPrintf("%s(%s", this->childProcessor(childIndex)->functionName(),
                                     inputColor);
 
    if (childProc->isBlendFunction()) {
        if (!destColor) {
            destColor = args.fFp.isBlendFunction() ? args.fDestColor : "half4(1)";
        }
        invocation.appendf(", %s", destColor);
    }
 
    // Produce a string containing the call to the helper function. We have a uniform variable
    // containing our transform (matrixName). If the parent coords were produced by uniform
    // transforms, then the entire expression (matrixName * coords) is lifted to a vertex shader
    // and is stored in a varying. In that case, childProc will not be sampled explicitly, so its
    // function signature will not take in coords.
    //
    // In all other cases, we need to insert sksl to compute matrix * parent coords and then invoke
    // the function.
    if (args.fFragBuilder->getProgramBuilder()->fragmentProcessorHasCoordsParam(childProc)) {
        // Only check perspective for this specific matrix transform, not the aggregate FP property.
        // Any parent perspective will have already been applied when evaluated in the FS.
        if (childProc->sampleUsage().hasPerspective()) {
            invocation.appendf(", proj((%s) * %s.xy1)", matrixName.c_str(), args.fSampleCoord);
        } else if (args.fShaderCaps->fNonsquareMatrixSupport) {
            invocation.appendf(", float3x2(%s) * %s.xy1", matrixName.c_str(), args.fSampleCoord);
        } else {
            invocation.appendf(", ((%s) * %s.xy1).xy", matrixName.c_str(), args.fSampleCoord);
        }
    }
 
    invocation.append(")");
    return invocation;
}

invokeChildWithMatrix() [2/3]

SkString GrFragmentProcessor::ProgramImpl::invokeChildWithMatrix ( int  childIndex, const char *  inputColor, EmitArgs &  parentArgs  )

inline

Definition at line 575 of file GrFragmentProcessor.h.

                                                                {
        return this->invokeChildWithMatrix(childIndex,
                                           inputColor,
                                           /*destColor=*/nullptr,
                                           parentArgs);
    }

invokeChildWithMatrix() [3/3]

SkString GrFragmentProcessor::ProgramImpl::invokeChildWithMatrix ( int  childIndex, EmitArgs &  parentArgs  )

inline

Definition at line 556 of file GrFragmentProcessor.h.

                                                                                {
        return this->invokeChildWithMatrix(childIndex,
                                           /*inputColor=*/nullptr,
                                           /*destColor=*/nullptr,
                                           parentArgs);
    }

numChildProcessors()

int GrFragmentProcessor::ProgramImpl::numChildProcessors ( ) const

inline

Definition at line 531 of file GrFragmentProcessor.h.

{ return fChildProcessors.size(); }

onSetData()

virtual void GrFragmentProcessor::ProgramImpl::onSetData ( const GrGLSLProgramDataManager &  , const GrFragmentProcessor &    )

inlineprivatevirtual

A ProgramImpl instance can be reused with any GrFragmentProcessor that produces the same the same key; this function reads data from a GrFragmentProcessor and uploads any uniform variables required by the shaders created in emitCode(). The GrFragmentProcessor parameter is guaranteed to be of the same type that created this ProgramImpl and to have an identical key as the one that created this ProgramImpl.

Definition at line 643 of file GrFragmentProcessor.h.

{}

setData()

void ProgramImpl::setData	(	const GrGLSLProgramDataManager &	pdman,
		const GrFragmentProcessor &	processor
	)

Definition at line 851 of file GrFragmentProcessor.cpp.

                                                                {
    this->onSetData(pdman, processor);
}

setFunctionName()

void GrFragmentProcessor::ProgramImpl::setFunctionName ( SkString  name )

inline

Definition at line 535 of file GrFragmentProcessor.h.

                                        {
        SkASSERT(fFunctionName.isEmpty());
        fFunctionName = std::move(name);
    }

Friends And Related Function Documentation

GrFragmentProcessor

friend class GrFragmentProcessor

friend

Definition at line 650 of file GrFragmentProcessor.h.

---

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