GrGLSLProgramBuilder Class Reference

#include <GrGLSLProgramBuilder.h>

Inheritance diagram for GrGLSLProgramBuilder:

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

Public Member Functions
virtual	~GrGLSLProgramBuilder ()
virtual const GrCaps *	caps () const =0
const GrShaderCaps *	shaderCaps () const
GrSurfaceOrigin	origin () const
const GrPipeline &	pipeline () const
const GrGeometryProcessor &	geometryProcessor () const
bool	snapVerticesToPixelCenters () const
bool	hasPointSize () const
const GrProgramDesc &	desc () const
void	appendUniformDecls (GrShaderFlags visibility, SkString *) const
const char *	samplerVariable (SamplerHandle handle) const
skgpu::Swizzle	samplerSwizzle (SamplerHandle handle) const
const char *	inputSamplerVariable (SamplerHandle handle) const
skgpu::Swizzle	inputSamplerSwizzle (SamplerHandle handle) const
void	addRTFlipUniform (const char *name)
SkString	nameVariable (char prefix, const char *name, bool mangle=true)
bool	emitTextureSamplersForFPs (const GrFragmentProcessor &fp, GrFragmentProcessor::ProgramImpl &impl, int *samplerIndex)
void	advanceStage ()
void	writeFPFunction (const GrFragmentProcessor &fp, GrFragmentProcessor::ProgramImpl &impl)
std::string	invokeFP (const GrFragmentProcessor &fp, const GrFragmentProcessor::ProgramImpl &impl, const char *inputColor, const char *destColor, const char *coords) const
bool	fragmentProcessorHasCoordsParam (const GrFragmentProcessor *) const
virtual GrGLSLUniformHandler *	uniformHandler ()=0
virtual const GrGLSLUniformHandler *	uniformHandler () const =0
virtual GrGLSLVaryingHandler *	varyingHandler ()=0
virtual void	finalizeFragmentSecondaryColor (GrShaderVar &outputColor)

Public Attributes
GrGLSLVertexBuilder	fVS
GrGLSLFragmentShaderBuilder	fFS
const GrProgramDesc &	fDesc
const GrProgramInfo &	fProgramInfo
GrGLSLBuiltinUniformHandles	fUniformHandles
std::unique_ptr< GrGeometryProcessor::ProgramImpl >	fGPImpl
std::unique_ptr< GrXferProcessor::ProgramImpl >	fXPImpl
std::vector< std::unique_ptr< GrFragmentProcessor::ProgramImpl > >	fFPImpls
SamplerHandle	fDstTextureSamplerHandle
GrSurfaceOrigin	fDstTextureOrigin

Static Public Attributes
static const int	kVarsPerBlock = 8

Protected Member Functions
	GrGLSLProgramBuilder (const GrProgramDesc &, const GrProgramInfo &)
void	addFeature (GrShaderFlags shaders, uint32_t featureBit, const char *extensionName)
bool	emitAndInstallProcs ()
void	finalizeShaders ()
bool	fragColorIsInOut () const

Detailed Description

Definition at line 39 of file GrGLSLProgramBuilder.h.

Member Typedef Documentation

SamplerHandle

using GrGLSLProgramBuilder::SamplerHandle = GrGLSLUniformHandler::SamplerHandle

Definition at line 42 of file GrGLSLProgramBuilder.h.

UniformHandle

using GrGLSLProgramBuilder::UniformHandle = GrGLSLUniformHandler::UniformHandle

Definition at line 41 of file GrGLSLProgramBuilder.h.

Constructor & Destructor Documentation

~GrGLSLProgramBuilder()

GrGLSLProgramBuilder::~GrGLSLProgramBuilder ( )

virtualdefault

GrGLSLProgramBuilder()

GrGLSLProgramBuilder::GrGLSLProgramBuilder ( const GrProgramDesc &  desc, const GrProgramInfo &  programInfo  )

explicitprotected

Definition at line 40 of file GrGLSLProgramBuilder.cpp.

        : fVS(this)
        , fFS(this)
        , fDesc(desc)
        , fProgramInfo(programInfo)
        , fNumFragmentSamplers(0) {}

Member Function Documentation

addFeature()

void GrGLSLProgramBuilder::addFeature ( GrShaderFlags  shaders, uint32_t  featureBit, const char *  extensionName  )

protected

Definition at line 50 of file GrGLSLProgramBuilder.cpp.

                                                                 {
    if (shaders & kVertex_GrShaderFlag) {
        fVS.addFeature(featureBit, extensionName);
    }
    if (shaders & kFragment_GrShaderFlag) {
        fFS.addFeature(featureBit, extensionName);
    }
}

addRTFlipUniform()

void GrGLSLProgramBuilder::addRTFlipUniform

(

const char *

name

)

Definition at line 514 of file GrGLSLProgramBuilder.cpp.

                                                            {
    SkASSERT(!fUniformHandles.fRTFlipUni.isValid());
    GrGLSLUniformHandler* uniformHandler = this->uniformHandler();
    fUniformHandles.fRTFlipUni =
            uniformHandler->internalAddUniformArray(nullptr,
                                                    kFragment_GrShaderFlag,
                                                    SkSLType::kFloat2,
                                                    name,
                                                    false,
                                                    0,
                                                    nullptr);
}

advanceStage()

void GrGLSLProgramBuilder::advanceStage ( )

inline

advanceStage is called by program creator between each processor's emit code. It increments the stage index for variable name mangling, and also ensures verification variables in the fragment shader are cleared.

Definition at line 100 of file GrGLSLProgramBuilder.h.

                        {
        fStageIndex++;
        SkDEBUGCODE(fFS.debugOnly_resetPerStageVerification();)
        fFS.nextStage();
    }

appendUniformDecls()

void GrGLSLProgramBuilder::appendUniformDecls	(	GrShaderFlags	visibility,
		SkString *	out
	)		const

Definition at line 510 of file GrGLSLProgramBuilder.cpp.

                                                                                           {
    this->uniformHandler()->appendUniformDecls(visibility, out);
}

caps()

virtual const GrCaps * GrGLSLProgramBuilder::caps ( ) const

pure virtual

Implemented in GrD3DPipelineStateBuilder, GrGLProgramBuilder, and GrVkPipelineStateBuilder.

desc()

const GrProgramDesc & GrGLSLProgramBuilder::desc ( ) const

inline

Definition at line 57 of file GrGLSLProgramBuilder.h.

{ return fDesc; }

emitAndInstallProcs()

bool GrGLSLProgramBuilder::emitAndInstallProcs ( )

protected

Definition at line 61 of file GrGLSLProgramBuilder.cpp.

                                               {
    // First we loop over all of the installed processors and collect coord transforms.  These will
    // be sent to the ProgramImpl in its emitCode function
    SkString inputColor;
    SkString inputCoverage;
    if (!this->emitAndInstallPrimProc(&inputColor, &inputCoverage)) {
        return false;
    }
    if (!this->emitAndInstallDstTexture()) {
        return false;
    }
    if (!this->emitAndInstallFragProcs(&inputColor, &inputCoverage)) {
        return false;
    }
    if (!this->emitAndInstallXferProc(inputColor, inputCoverage)) {
        return false;
    }
    fGPImpl->emitTransformCode(&fVS, this->uniformHandler());
 
    return this->checkSamplerCounts();
}

emitTextureSamplersForFPs()

bool GrGLSLProgramBuilder::emitTextureSamplersForFPs	(	const GrFragmentProcessor &	fp,
		GrFragmentProcessor::ProgramImpl &	impl,
		int *	samplerIndex
	)

Emits samplers for TextureEffect fragment processors as needed. fp can be a TextureEffect, or a tree containing zero or more TextureEffects.

Definition at line 151 of file GrGLSLProgramBuilder.cpp.

                                                                        {
    bool ok = true;
    fp.visitWithImpls([&](const GrFragmentProcessor& fp, GrFragmentProcessor::ProgramImpl& impl) {
        if (const GrTextureEffect* te = fp.asTextureEffect()) {
            SkString name = SkStringPrintf("TextureSampler_%d", *samplerIndex);
            *samplerIndex += 1;
 
            GrSamplerState samplerState = te->samplerState();
            const GrBackendFormat& format = te->view().proxy()->backendFormat();
            skgpu::Swizzle swizzle = te->view().swizzle();
            SamplerHandle handle = this->emitSampler(format, samplerState, swizzle, name.c_str());
            if (!handle.isValid()) {
                ok = false;
                return;
            }
            static_cast<GrTextureEffect::Impl&>(impl).setSamplerHandle(handle);
        }
    }, impl);
 
    return ok;
}

finalizeFragmentSecondaryColor()

virtual void GrGLSLProgramBuilder::finalizeFragmentSecondaryColor ( GrShaderVar &  outputColor )

inlinevirtual

Reimplemented in GrD3DPipelineStateBuilder, and GrVkPipelineStateBuilder.

Definition at line 130 of file GrGLSLProgramBuilder.h.

{}

finalizeShaders()

void GrGLSLProgramBuilder::finalizeShaders ( )

protected

Definition at line 533 of file GrGLSLProgramBuilder.cpp.

                                           {
    this->varyingHandler()->finalize();
    fVS.finalize(kVertex_GrShaderFlag);
    fFS.finalize(kFragment_GrShaderFlag);
}

fragColorIsInOut()

bool GrGLSLProgramBuilder::fragColorIsInOut ( ) const

inlineprotected

Definition at line 159 of file GrGLSLProgramBuilder.h.

{ return fFS.primaryColorOutputIsInOut(); }

fragmentProcessorHasCoordsParam()

bool GrGLSLProgramBuilder::fragmentProcessorHasCoordsParam

(

const GrFragmentProcessor *

fp

)

const

If the FP's coords are unused or all uses have been lifted to interpolated varyings then don't put coords in the FP's function signature or call sites.

Definition at line 527 of file GrGLSLProgramBuilder.cpp.

                                                                                              {
    auto iter = fFPCoordsMap.find(fp);
    return (iter != fFPCoordsMap.end()) ? iter->second.hasCoordsParam
                                        : fp->usesSampleCoords();
}

geometryProcessor()

const GrGeometryProcessor & GrGLSLProgramBuilder::geometryProcessor ( ) const

inline

Definition at line 51 of file GrGLSLProgramBuilder.h.

{ return fProgramInfo.geomProc(); }

hasPointSize()

bool GrGLSLProgramBuilder::hasPointSize ( ) const

inline

Definition at line 55 of file GrGLSLProgramBuilder.h.

{ return fProgramInfo.primitiveType() == GrPrimitiveType::kPoints; }

inputSamplerSwizzle()

skgpu::Swizzle GrGLSLProgramBuilder::inputSamplerSwizzle ( SamplerHandle  handle ) const

inline

Definition at line 73 of file GrGLSLProgramBuilder.h.

                                                                 {
        return this->uniformHandler()->inputSamplerSwizzle(handle);
    }

inputSamplerVariable()

const char * GrGLSLProgramBuilder::inputSamplerVariable ( SamplerHandle  handle ) const

inline

Definition at line 69 of file GrGLSLProgramBuilder.h.

                                                                 {
        return this->uniformHandler()->inputSamplerVariable(handle);
    }

invokeFP()

std::string GrGLSLProgramBuilder::invokeFP	(	const GrFragmentProcessor &	fp,
		const GrFragmentProcessor::ProgramImpl &	impl,
		const char *	inputColor,
		const char *	destColor,
		const char *	coords
	)		const

Returns a function-call invocation of fp in string form, passing the appropriate combination of inputColor, destColor and fLocalCoordsVar for the FP.

Definition at line 175 of file GrGLSLProgramBuilder.cpp.

                                                                     {
    if (fp.isBlendFunction()) {
        if (this->fragmentProcessorHasCoordsParam(&fp)) {
            return SkSL::String::printf("%s(%s, %s, %s)", impl.functionName(), inputColor,
                                                          destColor, coords);
        } else {
            return SkSL::String::printf("%s(%s, %s)", impl.functionName(), inputColor, destColor);
        }
    }
 
    if (this->fragmentProcessorHasCoordsParam(&fp)) {
        return SkSL::String::printf("%s(%s, %s)", impl.functionName(), inputColor, coords);
    } else {
        return SkSL::String::printf("%s(%s)", impl.functionName(), inputColor);
    }
}

nameVariable()

SkString GrGLSLProgramBuilder::nameVariable	(	char	prefix,
		const char *	name,
		bool	mangle = true
	)

Definition at line 486 of file GrGLSLProgramBuilder.cpp.

                                                                                      {
    SkString out;
    if ('\0' == prefix) {
        out = name;
    } else {
        out.printf("%c%s", prefix, name);
    }
    if (mangle) {
        SkString suffix = this->getMangleSuffix();
        // Names containing "__" are reserved; add "x" if needed to avoid consecutive underscores.
        const char *underscoreSplitter = out.endsWith('_') ? "x" : "";
        out.appendf("%s%s", underscoreSplitter, suffix.c_str());
    }
    return out;
}

origin()

GrSurfaceOrigin GrGLSLProgramBuilder::origin ( ) const

inline

Definition at line 49 of file GrGLSLProgramBuilder.h.

{ return fProgramInfo.origin(); }

pipeline()

const GrPipeline & GrGLSLProgramBuilder::pipeline ( ) const

inline

Definition at line 50 of file GrGLSLProgramBuilder.h.

{ return fProgramInfo.pipeline(); }

samplerSwizzle()

skgpu::Swizzle GrGLSLProgramBuilder::samplerSwizzle ( SamplerHandle  handle ) const

inline

Definition at line 65 of file GrGLSLProgramBuilder.h.

                                                            {
        return this->uniformHandler()->samplerSwizzle(handle);
    }

samplerVariable()

const char * GrGLSLProgramBuilder::samplerVariable ( SamplerHandle  handle ) const

inline

Definition at line 61 of file GrGLSLProgramBuilder.h.

                                                            {
        return this->uniformHandler()->samplerVariable(handle);
    }

shaderCaps()

const GrShaderCaps * GrGLSLProgramBuilder::shaderCaps ( ) const

inline

Definition at line 47 of file GrGLSLProgramBuilder.h.

{ return this->caps()->shaderCaps(); }

snapVerticesToPixelCenters()

bool GrGLSLProgramBuilder::snapVerticesToPixelCenters ( ) const

inline

Definition at line 52 of file GrGLSLProgramBuilder.h.

                                            {
        return fProgramInfo.pipeline().snapVerticesToPixelCenters();
    }

uniformHandler() [1/2]

virtual const GrGLSLUniformHandler * GrGLSLProgramBuilder::uniformHandler ( ) const

pure virtual

uniformHandler() [2/2]

virtual GrGLSLUniformHandler * GrGLSLProgramBuilder::uniformHandler ( )

pure virtual

varyingHandler()

virtual GrGLSLVaryingHandler * GrGLSLProgramBuilder::varyingHandler ( )

pure virtual

writeFPFunction()

void GrGLSLProgramBuilder::writeFPFunction	(	const GrFragmentProcessor &	fp,
		GrFragmentProcessor::ProgramImpl &	impl
	)

Adds the SkSL function that implements an FP assuming its children are already written.

Definition at line 243 of file GrGLSLProgramBuilder.cpp.

                                                                                 {
    constexpr const char*       kDstColor    = "_dst";
              const char* const inputColor   = fp.isBlendFunction() ? "_src" : "_input";
              const char*       sampleCoords = "_coords";
    fFS.nextStage();
    // Conceptually, an FP is always sampled at a particular coordinate. However, if it is only
    // sampled by a chain of uniform matrix expressions (or legacy coord transforms), the value that
    // would have been passed to _coords is lifted to the vertex shader and
    // varying. In that case it uses that variable and we do not pass a second argument for _coords.
    GrShaderVar params[3];
    int numParams = 0;
 
    params[numParams++] = GrShaderVar(inputColor, SkSLType::kHalf4);
 
    if (fp.isBlendFunction()) {
        // Blend functions take a dest color as input.
        params[numParams++] = GrShaderVar(kDstColor, SkSLType::kHalf4);
    }
 
    auto fpCoordsIter = fFPCoordsMap.find(&fp);
    if (fpCoordsIter == fFPCoordsMap.end()) {
        // This FP isn't in our coords map at all, so its coords (if any) couldn't have been lifted
        // to a varying.
        if (fp.usesSampleCoords()) {
            params[numParams++] = GrShaderVar(sampleCoords, SkSLType::kFloat2);
        }
    } else if (fpCoordsIter->second.hasCoordsParam) {
        // This FP is in our map, and it takes an explicit coords param.
        params[numParams++] = GrShaderVar(sampleCoords, SkSLType::kFloat2);
    } else {
        // Either doesn't use coords at all or sampled through a chain of passthrough/matrix
        // samples usages. In the latter case the coords are emitted in the vertex shader as a
        // varying, so this only has to access it. Add a float2 _coords variable that maps to the
        // associated varying and replaces the absent 2nd argument to the fp's function.
        GrShaderVar varying = fpCoordsIter->second.coordsVarying;
 
        switch (varying.getType()) {
            case SkSLType::kVoid:
                SkASSERT(!fp.usesSampleCoordsDirectly());
                break;
            case SkSLType::kFloat2:
                // Just point the local coords to the varying
                sampleCoords = varying.getName().c_str();
                break;
            case SkSLType::kFloat3:
                // Must perform the perspective divide in the frag shader based on the
                // varying, and since we won't actually have a function parameter for local
                // coords, add it as a local variable.
                fFS.codeAppendf("float2 %s = %s.xy / %s.z;\n",
                                sampleCoords,
                                varying.getName().c_str(),
                                varying.getName().c_str());
                break;
            default:
                SkDEBUGFAILF("Unexpected varying type for coord: %s %d\n",
                             varying.getName().c_str(),
                             (int)varying.getType());
                break;
        }
    }
 
    SkASSERT(numParams <= (int)std::size(params));
 
    // First, emit every child's function. This needs to happen (even for children that aren't
    // sampled), so that all of the expected uniforms are registered.
    this->writeChildFPFunctions(fp, impl);
    GrFragmentProcessor::ProgramImpl::EmitArgs args(&fFS,
                                                    this->uniformHandler(),
                                                    this->shaderCaps(),
                                                    fp,
                                                    inputColor,
                                                    kDstColor,
                                                    sampleCoords);
 
    impl.emitCode(args);
    impl.setFunctionName(fFS.getMangledFunctionName(args.fFp.name()));
 
    fFS.emitFunction(SkSLType::kHalf4,
                     impl.functionName(),
                     SkSpan(params, numParams),
                     fFS.code().c_str());
    fFS.deleteStage();
}

Member Data Documentation

fDesc

const GrProgramDesc& GrGLSLProgramBuilder::fDesc

Definition at line 138 of file GrGLSLProgramBuilder.h.

fDstTextureOrigin

GrSurfaceOrigin GrGLSLProgramBuilder::fDstTextureOrigin

Definition at line 148 of file GrGLSLProgramBuilder.h.

fDstTextureSamplerHandle

SamplerHandle GrGLSLProgramBuilder::fDstTextureSamplerHandle

Definition at line 147 of file GrGLSLProgramBuilder.h.

fFPImpls

std::vector<std::unique_ptr<GrFragmentProcessor::ProgramImpl> > GrGLSLProgramBuilder::fFPImpls

Definition at line 145 of file GrGLSLProgramBuilder.h.

fFS

GrGLSLFragmentShaderBuilder GrGLSLProgramBuilder::fFS

Definition at line 136 of file GrGLSLProgramBuilder.h.

fGPImpl

std::unique_ptr<GrGeometryProcessor::ProgramImpl> GrGLSLProgramBuilder::fGPImpl

Definition at line 143 of file GrGLSLProgramBuilder.h.

fProgramInfo

const GrProgramInfo& GrGLSLProgramBuilder::fProgramInfo

Definition at line 139 of file GrGLSLProgramBuilder.h.

fUniformHandles

GrGLSLBuiltinUniformHandles GrGLSLProgramBuilder::fUniformHandles

Definition at line 141 of file GrGLSLProgramBuilder.h.

fVS

GrGLSLVertexBuilder GrGLSLProgramBuilder::fVS

Definition at line 135 of file GrGLSLProgramBuilder.h.

fXPImpl

std::unique_ptr<GrXferProcessor::ProgramImpl> GrGLSLProgramBuilder::fXPImpl

Definition at line 144 of file GrGLSLProgramBuilder.h.

kVarsPerBlock

const int GrGLSLProgramBuilder::kVarsPerBlock = 8

static

Definition at line 133 of file GrGLSLProgramBuilder.h.

---

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

• third_party/skia/src/gpu/ganesh/glsl/GrGLSLProgramBuilder.h
• third_party/skia/src/gpu/ganesh/glsl/GrGLSLProgramBuilder.cpp