GrGLSLShaderBuilder Class Reference

#include <GrGLSLShaderBuilder.h>

Inheritance diagram for GrGLSLShaderBuilder:

Classes
class	ShaderBlock

Public Types
using	SamplerHandle = GrGLSLUniformHandler::SamplerHandle

Public Member Functions
	GrGLSLShaderBuilder (GrGLSLProgramBuilder *program)
virtual	~GrGLSLShaderBuilder ()
void	appendTextureLookup (SkString *out, SamplerHandle, const char *coordName) const
void	appendTextureLookup (SamplerHandle, const char *coordName, GrGLSLColorSpaceXformHelper *colorXformHelper=nullptr)
void	appendTextureLookupAndBlend (const char *dst, SkBlendMode, SamplerHandle, const char *coordName, GrGLSLColorSpaceXformHelper *colorXformHelper=nullptr)
void	appendInputLoad (SamplerHandle)
void	appendColorGamutXform (SkString *out, const char *srcColor, GrGLSLColorSpaceXformHelper *colorXformHelper)
void	appendColorGamutXform (const char *srcColor, GrGLSLColorSpaceXformHelper *colorXformHelper)
void	defineConstant (const char *type, const char *name, const char *value)
void	defineConstant (const char *name, int value)
void	defineConstant (const char *name, float value)
void	defineConstantf (const char *type, const char *name, const char *fmt,...) SK_PRINTF_LIKE(4
	va_start (args, fmt)
this	definitions ().appendVAList(fmt
	va_end (args)
this	definitions ().append("
void	definitionAppend (const char *str)
void	declareGlobal (const GrShaderVar &)
SkString	newTmpVarName (const char *suffix)
void	codeAppendf (const char format[],...) SK_PRINTF_LIKE(2
void	va_start (args, format)
this	code ().appendVAList(format
	va_end (args)
void	codeAppend (const char *str)
void	codeAppend (const char *str, size_t length)
void	codePrependf (const char format[],...) SK_PRINTF_LIKE(2
void	va_start (args, format)
this	code ().prependVAList(format
	va_end (args)
void	declAppend (const GrShaderVar &var)
SkString	getMangledFunctionName (const char *baseName)
void	emitFunctionPrototype (SkSLType returnType, const char *mangledName, SkSpan< const GrShaderVar > args)
void	emitFunctionPrototype (const char *declaration)
void	emitFunction (SkSLType returnType, const char *mangledName, SkSpan< const GrShaderVar > args, const char *body)
void	emitFunction (const char *declaration, const char *body)
void	finalize (uint32_t visibility)
GrGLSLProgramBuilder *	getProgramBuilder ()

Public Attributes
void va_list	args
this	args
	n

Protected Types
enum	GLSLPrivateFeature {   kFragCoordConventions_GLSLPrivateFeature , kBlendEquationAdvanced_GLSLPrivateFeature , kBlendFuncExtended_GLSLPrivateFeature , kFramebufferFetch_GLSLPrivateFeature ,   kNoPerspectiveInterpolation_GLSLPrivateFeature , kSampleVariables_GLSLPrivateFeature , kLastGLSLPrivateFeature = kSampleVariables_GLSLPrivateFeature }
enum	InterfaceQualifier { kIn_InterfaceQualifier , kOut_InterfaceQualifier , kLastInterfaceQualifier = kOut_InterfaceQualifier }
enum	{   kExtensions , kDefinitions , kPrecisionQualifier , kLayoutQualifiers ,   kUniforms , kInputs , kOutputs , kFunctions ,   kMain , kCode , kPrealloc = kCode + 6 }
typedef SkTBlockList< GrShaderVar >	VarArray

Protected Member Functions
void	appendDecls (const VarArray &vars, SkString *out) const
void	appendFunctionDecl (SkSLType returnType, const char *mangledName, SkSpan< const GrShaderVar > args)
bool	addFeature (uint32_t featureBit, const char *extensionName)
void	addLayoutQualifier (const char *param, InterfaceQualifier)
void	compileAndAppendLayoutQualifiers ()
void	nextStage ()
void	deleteStage ()
SkString &	extensions ()
SkString &	definitions ()
SkString &	precisionQualifier ()
SkString &	layoutQualifiers ()
SkString &	uniforms ()
SkString &	inputs ()
SkString &	outputs ()
SkString &	functions ()
SkString &	main ()
SkString &	code ()
virtual void	onFinalize ()=0

Protected Attributes
GrGLSLProgramBuilder *	fProgramBuilder
std::string	fCompilerString
skia_private::STArray< kPrealloc, SkString >	fShaderStrings
SkString	fCode
SkString	fFunctions
SkString	fExtensions
SkSL::StatementArray	fDeclarations
VarArray	fInputs
VarArray	fOutputs
uint32_t	fFeaturesAddedMask
skia_private::STArray< 1, SkString >	fLayoutParams [kLastInterfaceQualifier+1]
int	fCodeIndex
bool	fFinalized
int	fTmpVariableCounter

Friends
class	GrGLSLProgramBuilder
class	GrGLProgramBuilder
class	GrD3DPipelineStateBuilder
class	GrDawnProgramBuilder
class	GrGLSLVaryingHandler
class	GrGLPathProgramBuilder
class	GrVkPipelineStateBuilder
class	GrMtlPipelineStateBuilder

Detailed Description

base class for all shaders builders

Definition at line 34 of file GrGLSLShaderBuilder.h.

Member Typedef Documentation

SamplerHandle

using GrGLSLShaderBuilder::SamplerHandle = GrGLSLUniformHandler::SamplerHandle

Definition at line 39 of file GrGLSLShaderBuilder.h.

VarArray

typedef SkTBlockList<GrShaderVar> GrGLSLShaderBuilder::VarArray

protected

Definition at line 185 of file GrGLSLShaderBuilder.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

protected

Enumerator
kExtensions
kDefinitions
kPrecisionQualifier
kLayoutQualifiers
kUniforms
kInputs
kOutputs
kFunctions
kMain
kCode
kPrealloc

Definition at line 252 of file GrGLSLShaderBuilder.h.

         {
        kExtensions,
        kDefinitions,
        kPrecisionQualifier,
        kLayoutQualifiers,
        kUniforms,
        kInputs,
        kOutputs,
        kFunctions,
        kMain,
        kCode,
 
        kPrealloc = kCode + 6,  // 6 == Reasonable upper bound on number of processor stages
    };

GLSLPrivateFeature

enum GrGLSLShaderBuilder::GLSLPrivateFeature

protected

Features that should only be enabled internally by the builders.

Enumerator
kFragCoordConventions_GLSLPrivateFeature
kBlendEquationAdvanced_GLSLPrivateFeature
kBlendFuncExtended_GLSLPrivateFeature
kFramebufferFetch_GLSLPrivateFeature
kNoPerspectiveInterpolation_GLSLPrivateFeature
kSampleVariables_GLSLPrivateFeature
kLastGLSLPrivateFeature

Definition at line 195 of file GrGLSLShaderBuilder.h.

                            {
        kFragCoordConventions_GLSLPrivateFeature,
        kBlendEquationAdvanced_GLSLPrivateFeature,
        kBlendFuncExtended_GLSLPrivateFeature,
        kFramebufferFetch_GLSLPrivateFeature,
        kNoPerspectiveInterpolation_GLSLPrivateFeature,
        kSampleVariables_GLSLPrivateFeature,
        kLastGLSLPrivateFeature = kSampleVariables_GLSLPrivateFeature
    };

InterfaceQualifier

enum GrGLSLShaderBuilder::InterfaceQualifier

protected

Enumerator
kIn_InterfaceQualifier
kOut_InterfaceQualifier
kLastInterfaceQualifier

Definition at line 212 of file GrGLSLShaderBuilder.h.

                            {
        kIn_InterfaceQualifier,
        kOut_InterfaceQualifier,
        kLastInterfaceQualifier = kOut_InterfaceQualifier
    };

Constructor & Destructor Documentation

GrGLSLShaderBuilder()

GrGLSLShaderBuilder::GrGLSLShaderBuilder

(

GrGLSLProgramBuilder *

program

)

Definition at line 23 of file GrGLSLShaderBuilder.cpp.

    : fProgramBuilder(program)
    , fInputs(GrGLSLProgramBuilder::kVarsPerBlock)
    , fOutputs(GrGLSLProgramBuilder::kVarsPerBlock)
    , fFeaturesAddedMask(0)
    , fCodeIndex(kCode)
    , fFinalized(false)
    , fTmpVariableCounter(0) {
    // We push back some placeholder pointers which will later become our header
    for (int i = 0; i <= kCode; i++) {
        fShaderStrings.push_back();
    }
 
    this->main() = "void main() {";
}

~GrGLSLShaderBuilder()

virtual GrGLSLShaderBuilder::~GrGLSLShaderBuilder ( )

inlinevirtual

Definition at line 37 of file GrGLSLShaderBuilder.h.

{}

Member Function Documentation

addFeature()

bool GrGLSLShaderBuilder::addFeature ( uint32_t  featureBit, const char *  extensionName  )

protected

Definition at line 258 of file GrGLSLShaderBuilder.cpp.

                                                                                   {
    if (featureBit & fFeaturesAddedMask) {
        return false;
    }
    this->extensions().appendf("#extension %s: require\n", extensionName);
    fFeaturesAddedMask |= featureBit;
    return true;
}

addLayoutQualifier()

void GrGLSLShaderBuilder::addLayoutQualifier ( const char *  param, InterfaceQualifier  interface  )

protected

Definition at line 274 of file GrGLSLShaderBuilder.cpp.

                                                                                            {
    SkASSERT(fProgramBuilder->shaderCaps()->fGLSLGeneration >= SkSL::GLSLGeneration::k330 ||
             fProgramBuilder->shaderCaps()->mustEnableAdvBlendEqs());
    fLayoutParams[interface].push_back() = param;
}

appendColorGamutXform() [1/2]

void GrGLSLShaderBuilder::appendColorGamutXform	(	const char *	srcColor,
		GrGLSLColorSpaceXformHelper *	colorXformHelper
	)

Version of above that appends the result to the shader code instead.

Definition at line 251 of file GrGLSLShaderBuilder.cpp.

                                                                                               {
    SkString xform;
    this->appendColorGamutXform(&xform, srcColor, colorXformHelper);
    this->codeAppend(xform.c_str());
}

appendColorGamutXform() [2/2]

void GrGLSLShaderBuilder::appendColorGamutXform	(	SkString *	out,
		const char *	srcColor,
		GrGLSLColorSpaceXformHelper *	colorXformHelper
	)

Adds a helper function to facilitate color gamut transformation, and produces code that returns the srcColor transformed into a new gamut (via multiplication by the xform from colorXformHelper). Premultiplied sources are also handled correctly (colorXformHelper determines if the source is premultipled or not).

Definition at line 141 of file GrGLSLShaderBuilder.cpp.

                                                                                               {
    if (!colorXformHelper || colorXformHelper->isNoop()) {
        *out = srcColor;
        return;
    }
 
    GrGLSLUniformHandler* uniformHandler = fProgramBuilder->uniformHandler();
 
    // We define up to three helper functions, to keep things clearer. One for the source transfer
    // function, one for the (inverse) destination transfer function, and one for the gamut xform.
    // Any combination of these may be present, although some configurations are much more likely.
 
    auto emitTFFunc = [this, &uniformHandler](const char* name,
                                              GrGLSLProgramDataManager::UniformHandle uniform,
                                              skcms_TFType tfType) {
        const GrShaderVar gTFArgs[] = { GrShaderVar("x", SkSLType::kFloat) };
        const char* coeffs = uniformHandler->getUniformCStr(uniform);
        SkString body;
        // Temporaries to make evaluation line readable. We always use the sRGBish names, so the
        // PQ and HLG math is confusing.
        body.appendf("float G = %s[0];", coeffs);
        body.appendf("float A = %s[1];", coeffs);
        body.appendf("float B = %s[2];", coeffs);
        body.appendf("float C = %s[3];", coeffs);
        body.appendf("float D = %s[4];", coeffs);
        body.appendf("float E = %s[5];", coeffs);
        body.appendf("float F = %s[6];", coeffs);
        body.append("float s = sign(x);");
        body.append("x = abs(x);");
        switch (tfType) {
            case skcms_TFType_sRGBish:
                body.append("x = (x < D) ? (C * x) + F : pow(A * x + B, G) + E;");
                break;
            case skcms_TFType_PQish:
                body.append("x = pow(max(A + B * pow(x, C), 0) / (D + E * pow(x, C)), F);");
                break;
            case skcms_TFType_HLGish:
                body.append("x = (x*A <= 1) ? pow(x*A, B) : exp((x-E)*C) + D; x *= (F+1);");
                break;
            case skcms_TFType_HLGinvish:
                body.append("x /= (F+1); x = (x <= 1) ? A * pow(x, B) : C * log(x - D) + E;");
                break;
            default:
                SkASSERT(false);
                break;
        }
        body.append("return s * x;");
        SkString funcName = this->getMangledFunctionName(name);
        this->emitFunction(SkSLType::kFloat, funcName.c_str(), {gTFArgs, std::size(gTFArgs)},
                           body.c_str());
        return funcName;
    };
 
    SkString srcTFFuncName;
    if (colorXformHelper->applySrcTF()) {
        srcTFFuncName = emitTFFunc("src_tf", colorXformHelper->srcTFUniform(),
                                   colorXformHelper->srcTFType());
    }
 
    SkString dstTFFuncName;
    if (colorXformHelper->applyDstTF()) {
        dstTFFuncName = emitTFFunc("dst_tf", colorXformHelper->dstTFUniform(),
                                   colorXformHelper->dstTFType());
    }
 
    SkString gamutXformFuncName;
    if (colorXformHelper->applyGamutXform()) {
        const GrShaderVar gGamutXformArgs[] = { GrShaderVar("color", SkSLType::kFloat4) };
        const char* xform = uniformHandler->getUniformCStr(colorXformHelper->gamutXformUniform());
        SkString body;
        body.appendf("color.rgb = (%s * color.rgb);", xform);
        body.append("return color;");
        gamutXformFuncName = this->getMangledFunctionName("gamut_xform");
        this->emitFunction(SkSLType::kFloat4, gamutXformFuncName.c_str(),
                           {gGamutXformArgs, std::size(gGamutXformArgs)}, body.c_str());
    }
 
    // Now define a wrapper function that applies all the intermediate steps
    {
        const GrShaderVar gColorXformArgs[] = { GrShaderVar("color", SkSLType::kFloat4) };
        SkString body;
        if (colorXformHelper->applyUnpremul()) {
            body.append("color = unpremul(color);");
        }
        if (colorXformHelper->applySrcTF()) {
            body.appendf("color.r = %s(color.r);", srcTFFuncName.c_str());
            body.appendf("color.g = %s(color.g);", srcTFFuncName.c_str());
            body.appendf("color.b = %s(color.b);", srcTFFuncName.c_str());
        }
        if (colorXformHelper->applyGamutXform()) {
            body.appendf("color = %s(color);", gamutXformFuncName.c_str());
        }
        if (colorXformHelper->applyDstTF()) {
            body.appendf("color.r = %s(color.r);", dstTFFuncName.c_str());
            body.appendf("color.g = %s(color.g);", dstTFFuncName.c_str());
            body.appendf("color.b = %s(color.b);", dstTFFuncName.c_str());
        }
        if (colorXformHelper->applyPremul()) {
            body.append("color.rgb *= color.a;");
        }
        body.append("return half4(color);");
        SkString colorXformFuncName = this->getMangledFunctionName("color_xform");
        this->emitFunction(SkSLType::kHalf4, colorXformFuncName.c_str(),
                           {gColorXformArgs, std::size(gColorXformArgs)}, body.c_str());
        out->appendf("%s(%s)", colorXformFuncName.c_str(), srcColor);
    }
}

appendDecls()

void GrGLSLShaderBuilder::appendDecls ( const VarArray &  vars, SkString *  out  ) const

protected

Definition at line 267 of file GrGLSLShaderBuilder.cpp.

                                                                               {
    for (const auto& v : vars.items()) {
        v.appendDecl(fProgramBuilder->shaderCaps(), out);
        out->append(";\n");
    }
}

appendFunctionDecl()

void GrGLSLShaderBuilder::appendFunctionDecl ( SkSLType  returnType, const char *  mangledName, SkSpan< const GrShaderVar >  args  )

protected

Definition at line 54 of file GrGLSLShaderBuilder.cpp.

                                                                             {
    this->functions().appendf("%s %s(", SkSLTypeString(returnType), mangledName);
    for (size_t i = 0; i < args.size(); ++i) {
        if (i > 0) {
            this->functions().append(", ");
        }
        args[i].appendDecl(fProgramBuilder->shaderCaps(), &this->functions());
    }
 
    this->functions().append(")");
}

appendInputLoad()

void GrGLSLShaderBuilder::appendInputLoad

(

SamplerHandle

samplerHandle

)

Appends a load of an input attachment into the shader code.

Definition at line 133 of file GrGLSLShaderBuilder.cpp.

                                                                     {
    const char* input = fProgramBuilder->inputSamplerVariable(samplerHandle);
    SkString load;
    load.appendf("subpassLoad(%s)", input);
    append_texture_swizzle(&load, fProgramBuilder->inputSamplerSwizzle(samplerHandle));
    this->codeAppend(load.c_str());
}

appendTextureLookup() [1/2]

void GrGLSLShaderBuilder::appendTextureLookup	(	SamplerHandle	samplerHandle,
		const char *	coordName,
		GrGLSLColorSpaceXformHelper *	colorXformHelper = nullptr
	)

Version of above that appends the result to the shader code instead.

Definition at line 109 of file GrGLSLShaderBuilder.cpp.

                                                                                             {
    SkString lookup;
    this->appendTextureLookup(&lookup, samplerHandle, coordName);
    this->appendColorGamutXform(lookup.c_str(), colorXformHelper);
}

appendTextureLookup() [2/2]

void GrGLSLShaderBuilder::appendTextureLookup	(	SkString *	out,
		SamplerHandle	samplerHandle,
		const char *	coordName
	)		const

Appends a 2D texture sample with projection if necessary. The vec length and swizzle order of the result depends on the GrProcessor::TextureSampler associated with the SamplerHandle.

Definition at line 101 of file GrGLSLShaderBuilder.cpp.

                                                                           {
    const char* sampler = fProgramBuilder->samplerVariable(samplerHandle);
    out->appendf("sample(%s, %s)", sampler, coordName);
    append_texture_swizzle(out, fProgramBuilder->samplerSwizzle(samplerHandle));
}

appendTextureLookupAndBlend()

void GrGLSLShaderBuilder::appendTextureLookupAndBlend	(	const char *	dst,
		SkBlendMode	mode,
		SamplerHandle	samplerHandle,
		const char *	coordName,
		GrGLSLColorSpaceXformHelper *	colorXformHelper = nullptr
	)

Does the work of appendTextureLookup and blends the result by dst, treating the texture lookup as the src input to the blend. The dst is assumed to be half4 and the result is always a half4. If dst is nullptr we use half4(1) as the blend dst.

Definition at line 117 of file GrGLSLShaderBuilder.cpp.

                                                       {
    if (!dst) {
        dst = "half4(1)";
    }
    SkString lookup;
    this->codeAppendf("%s(", skgpu::BlendFuncName(mode));
    this->appendTextureLookup(&lookup, samplerHandle, coordName);
    this->appendColorGamutXform(lookup.c_str(), colorXformHelper);
    this->codeAppendf(", %s)", dst);
}

code() [1/3]

SkString & GrGLSLShaderBuilder::code ( )

inlineprotected

Definition at line 248 of file GrGLSLShaderBuilder.h.

{ return fShaderStrings[fCodeIndex]; }

code() [2/3]

this GrGLSLShaderBuilder::code

(

)

code() [3/3]

this GrGLSLShaderBuilder::code

(

)

codeAppend() [1/2]

void GrGLSLShaderBuilder::codeAppend ( const char *  str )

inline

Definition at line 120 of file GrGLSLShaderBuilder.h.

{ this->code().append(str); }

codeAppend() [2/2]

void GrGLSLShaderBuilder::codeAppend ( const char *  str, size_t  length  )

inline

Definition at line 122 of file GrGLSLShaderBuilder.h.

{ this->code().append(str, length); }

codeAppendf()

void GrGLSLShaderBuilder::codeAppendf	(	const char	format[],
			...
	)

Called by GrGLSLProcessors to add code to one of the shaders.

codePrependf()

void GrGLSLShaderBuilder::codePrependf	(	const char	format[],
			...
	)

compileAndAppendLayoutQualifiers()

void GrGLSLShaderBuilder::compileAndAppendLayoutQualifiers ( )

protected

Definition at line 280 of file GrGLSLShaderBuilder.cpp.

                                                           {
    static const char* interfaceQualifierNames[] = {
        "in",
        "out"
    };
 
    for (int interface = 0; interface <= kLastInterfaceQualifier; ++interface) {
        const TArray<SkString>& params = fLayoutParams[interface];
        if (params.empty()) {
            continue;
        }
        this->layoutQualifiers().appendf("layout(%s", params[0].c_str());
        for (int i = 1; i < params.size(); ++i) {
            this->layoutQualifiers().appendf(", %s", params[i].c_str());
        }
        this->layoutQualifiers().appendf(") %s;\n", interfaceQualifierNames[interface]);
    }
 
    static_assert(0 == GrGLSLShaderBuilder::kIn_InterfaceQualifier);
    static_assert(1 == GrGLSLShaderBuilder::kOut_InterfaceQualifier);
    static_assert(std::size(interfaceQualifierNames) == kLastInterfaceQualifier + 1);
}

declAppend()

void GrGLSLShaderBuilder::declAppend

(

const GrShaderVar &

var

)

Appends a variable declaration to one of the shaders

Definition at line 39 of file GrGLSLShaderBuilder.cpp.

                                                           {
    SkString tempDecl;
    var.appendDecl(fProgramBuilder->shaderCaps(), &tempDecl);
    this->codeAppendf("%s;", tempDecl.c_str());
}

declareGlobal()

void GrGLSLShaderBuilder::declareGlobal

(

const GrShaderVar &

v

)

Definition at line 45 of file GrGLSLShaderBuilder.cpp.

                                                            {
    v.appendDecl(this->getProgramBuilder()->shaderCaps(), &this->definitions());
    this->definitions().append(";");
}

defineConstant() [1/3]

void GrGLSLShaderBuilder::defineConstant ( const char *  name, float  value  )

inline

Definition at line 85 of file GrGLSLShaderBuilder.h.

                                                       {
        this->definitions().appendf("const float %s = %f;\n", name, value);
    }

defineConstant() [2/3]

void GrGLSLShaderBuilder::defineConstant ( const char *  name, int  value  )

inline

Definition at line 81 of file GrGLSLShaderBuilder.h.

                                                     {
        this->definitions().appendf("const int %s = %i;\n", name, value);
    }

defineConstant() [3/3]

void GrGLSLShaderBuilder::defineConstant ( const char *  type, const char *  name, const char *  value  )

inline

Adds a constant declaration to the top of the shader.

Definition at line 77 of file GrGLSLShaderBuilder.h.

                                                                               {
        this->definitions().appendf("const %s %s = %s;\n", type, name, value);
    }

defineConstantf()

void GrGLSLShaderBuilder::defineConstantf	(	const char *	type,
		const char *	name,
		const char *	fmt,
			...
	)

definitionAppend()

void GrGLSLShaderBuilder::definitionAppend ( const char *  str )

inline

Definition at line 99 of file GrGLSLShaderBuilder.h.

{ this->definitions().append(str); }

definitions() [1/3]

SkString & GrGLSLShaderBuilder::definitions ( )

inlineprotected

Definition at line 240 of file GrGLSLShaderBuilder.h.

{ return fShaderStrings[kDefinitions]; }

definitions() [2/3]

this GrGLSLShaderBuilder::definitions

(

)

definitions() [3/3]

this GrGLSLShaderBuilder::definitions

(

)

deleteStage()

void GrGLSLShaderBuilder::deleteStage ( )

inlineprotected

Definition at line 234 of file GrGLSLShaderBuilder.h.

                       {
        fShaderStrings.pop_back();
        fCodeIndex--;
    }

emitFunction() [1/2]

void GrGLSLShaderBuilder::emitFunction	(	const char *	declaration,
		const char *	body
	)

Definition at line 78 of file GrGLSLShaderBuilder.cpp.

                                                                                {
    this->functions().appendf("%s {\n"
                              "%s"
                              "}\n\n", declaration, body);
}

emitFunction() [2/2]

void GrGLSLShaderBuilder::emitFunction	(	SkSLType	returnType,
		const char *	mangledName,
		SkSpan< const GrShaderVar >	args,
		const char *	body
	)

Emits a helper function outside of main() in the fragment shader.

Definition at line 68 of file GrGLSLShaderBuilder.cpp.

                                                         {
    this->appendFunctionDecl(returnType, mangledName, args);
    this->functions().appendf(" {\n"
                              "%s"
                              "}\n\n", body);
}

emitFunctionPrototype() [1/2]

void GrGLSLShaderBuilder::emitFunctionPrototype

(

const char *

declaration

)

Definition at line 91 of file GrGLSLShaderBuilder.cpp.

                                                                       {
    this->functions().appendf("%s\n", declaration);
}

emitFunctionPrototype() [2/2]

void GrGLSLShaderBuilder::emitFunctionPrototype	(	SkSLType	returnType,
		const char *	mangledName,
		SkSpan< const GrShaderVar >	args
	)

Emits a prototype for a helper function outside of main() in the fragment shader.

Definition at line 84 of file GrGLSLShaderBuilder.cpp.

                                                                                {
    this->appendFunctionDecl(returnType, mangledName, args);
    this->functions().append(";\n");
}

extensions()

SkString & GrGLSLShaderBuilder::extensions ( )

inlineprotected

Definition at line 239 of file GrGLSLShaderBuilder.h.

{ return fShaderStrings[kExtensions]; }

finalize()

void GrGLSLShaderBuilder::finalize

(

uint32_t

visibility

)

Combines the various parts of the shader to create a single finalized shader string.

Definition at line 303 of file GrGLSLShaderBuilder.cpp.

                                                      {
    SkASSERT(!fFinalized);
    this->compileAndAppendLayoutQualifiers();
    SkASSERT(visibility);
    fProgramBuilder->appendUniformDecls((GrShaderFlags) visibility, &this->uniforms());
    this->appendDecls(fInputs, &this->inputs());
    this->appendDecls(fOutputs, &this->outputs());
    this->onFinalize();
    // append the 'footer' to code
    this->code().append("}");
 
    for (int i = 0; i <= fCodeIndex; i++) {
        fCompilerString.append(fShaderStrings[i].c_str(), fShaderStrings[i].size());
    }
 
    fFinalized = true;
}

functions()

SkString & GrGLSLShaderBuilder::functions ( )

inlineprotected

Definition at line 246 of file GrGLSLShaderBuilder.h.

{ return fShaderStrings[kFunctions]; }

getMangledFunctionName()

SkString GrGLSLShaderBuilder::getMangledFunctionName

(

const char *

baseName

)

Generates a mangled name for a helper function in the fragment shader. Will give consistent results if called more than once.

Definition at line 50 of file GrGLSLShaderBuilder.cpp.

                                                                         {
    return fProgramBuilder->nameVariable(/*prefix=*/'\0', baseName);
}

getProgramBuilder()

GrGLSLProgramBuilder * GrGLSLShaderBuilder::getProgramBuilder ( )

inline

Get parent builder for adding uniforms.

Definition at line 165 of file GrGLSLShaderBuilder.h.

{ return fProgramBuilder; }

inputs()

SkString & GrGLSLShaderBuilder::inputs ( )

inlineprotected

Definition at line 244 of file GrGLSLShaderBuilder.h.

{ return fShaderStrings[kInputs]; }

layoutQualifiers()

SkString & GrGLSLShaderBuilder::layoutQualifiers ( )

inlineprotected

Definition at line 242 of file GrGLSLShaderBuilder.h.

{ return fShaderStrings[kLayoutQualifiers]; }

main()

SkString & GrGLSLShaderBuilder::main ( )

inlineprotected

Definition at line 247 of file GrGLSLShaderBuilder.h.

{ return fShaderStrings[kMain]; }

newTmpVarName()

SkString GrGLSLShaderBuilder::newTmpVarName ( const char *  suffix )

inline

Definition at line 105 of file GrGLSLShaderBuilder.h.

                                               {
        int tmpIdx = fTmpVariableCounter++;
        return SkStringPrintf("_tmp_%d_%s", tmpIdx, suffix);
    }

nextStage()

void GrGLSLShaderBuilder::nextStage ( )

inlineprotected

Definition at line 229 of file GrGLSLShaderBuilder.h.

                     {
        fShaderStrings.push_back();
        fCodeIndex++;
    }

onFinalize()

virtual void GrGLSLShaderBuilder::onFinalize ( )

protectedpure virtual

Implemented in GrGLSLFragmentShaderBuilder, and GrGLSLVertexBuilder.

outputs()

SkString & GrGLSLShaderBuilder::outputs ( )

inlineprotected

Definition at line 245 of file GrGLSLShaderBuilder.h.

{ return fShaderStrings[kOutputs]; }

precisionQualifier()

SkString & GrGLSLShaderBuilder::precisionQualifier ( )

inlineprotected

Definition at line 241 of file GrGLSLShaderBuilder.h.

{ return fShaderStrings[kPrecisionQualifier]; }

uniforms()

SkString & GrGLSLShaderBuilder::uniforms ( )

inlineprotected

Definition at line 243 of file GrGLSLShaderBuilder.h.

{ return fShaderStrings[kUniforms]; }

va_end() [1/3]

GrGLSLShaderBuilder::va_end

(

args

)

va_end() [2/3]

GrGLSLShaderBuilder::va_end

(

args

)

va_end() [3/3]

GrGLSLShaderBuilder::va_end

(

args

)

va_start() [1/3]

GrGLSLShaderBuilder::va_start	(	args	,
		fmt
	)

va_start() [2/3]

void GrGLSLShaderBuilder::va_start	(	args	,
		format
	)

va_start() [3/3]

void GrGLSLShaderBuilder::va_start	(	args	,
		format
	)

Friends And Related Symbol Documentation

GrD3DPipelineStateBuilder

friend class GrD3DPipelineStateBuilder

friend

Definition at line 288 of file GrGLSLShaderBuilder.h.

GrDawnProgramBuilder

friend class GrDawnProgramBuilder

friend

Definition at line 289 of file GrGLSLShaderBuilder.h.

GrGLPathProgramBuilder

friend class GrGLPathProgramBuilder

friend

Definition at line 291 of file GrGLSLShaderBuilder.h.

GrGLProgramBuilder

friend class GrGLProgramBuilder

friend

Definition at line 287 of file GrGLSLShaderBuilder.h.

GrGLSLProgramBuilder

friend class GrGLSLProgramBuilder

friend

Definition at line 286 of file GrGLSLShaderBuilder.h.

GrGLSLVaryingHandler

friend class GrGLSLVaryingHandler

friend

Definition at line 290 of file GrGLSLShaderBuilder.h.

GrMtlPipelineStateBuilder

friend class GrMtlPipelineStateBuilder

friend

Definition at line 293 of file GrGLSLShaderBuilder.h.

GrVkPipelineStateBuilder

friend class GrVkPipelineStateBuilder

friend

Definition at line 292 of file GrGLSLShaderBuilder.h.

Member Data Documentation

args [1/2]

this GrGLSLShaderBuilder::args

Initial value:

{
        this->definitions().appendf("const %s %s = ", type, name)

Definition at line 92 of file GrGLSLShaderBuilder.h.

args [2/2]

this GrGLSLShaderBuilder::args

Definition at line 94 of file GrGLSLShaderBuilder.h.

fCode

SkString GrGLSLShaderBuilder::fCode

protected

Definition at line 270 of file GrGLSLShaderBuilder.h.

fCodeIndex

int GrGLSLShaderBuilder::fCodeIndex

protected

Definition at line 280 of file GrGLSLShaderBuilder.h.

fCompilerString

std::string GrGLSLShaderBuilder::fCompilerString

protected

Definition at line 268 of file GrGLSLShaderBuilder.h.

fDeclarations

SkSL::StatementArray GrGLSLShaderBuilder::fDeclarations

protected

Definition at line 274 of file GrGLSLShaderBuilder.h.

fExtensions

SkString GrGLSLShaderBuilder::fExtensions

protected

Definition at line 272 of file GrGLSLShaderBuilder.h.

fFeaturesAddedMask

uint32_t GrGLSLShaderBuilder::fFeaturesAddedMask

protected

Definition at line 278 of file GrGLSLShaderBuilder.h.

fFinalized

bool GrGLSLShaderBuilder::fFinalized

protected

Definition at line 281 of file GrGLSLShaderBuilder.h.

fFunctions

SkString GrGLSLShaderBuilder::fFunctions

protected

Definition at line 271 of file GrGLSLShaderBuilder.h.

fInputs

VarArray GrGLSLShaderBuilder::fInputs

protected

Definition at line 276 of file GrGLSLShaderBuilder.h.

fLayoutParams

skia_private::STArray<1, SkString> GrGLSLShaderBuilder::fLayoutParams[kLastInterfaceQualifier+1]

protected

Definition at line 279 of file GrGLSLShaderBuilder.h.

fOutputs

VarArray GrGLSLShaderBuilder::fOutputs

protected

Definition at line 277 of file GrGLSLShaderBuilder.h.

fProgramBuilder

GrGLSLProgramBuilder* GrGLSLShaderBuilder::fProgramBuilder

protected

Definition at line 267 of file GrGLSLShaderBuilder.h.

fShaderStrings

skia_private::STArray<kPrealloc, SkString> GrGLSLShaderBuilder::fShaderStrings

protected

Definition at line 269 of file GrGLSLShaderBuilder.h.

fTmpVariableCounter

int GrGLSLShaderBuilder::fTmpVariableCounter

protected

Definition at line 284 of file GrGLSLShaderBuilder.h.

n

GrGLSLShaderBuilder::n

Definition at line 96 of file GrGLSLShaderBuilder.h.

---

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

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