#include <GrGLProgramBuilder.h>

Inheritance diagram for GrGLProgramBuilder:

Public Member Functions
const GrCaps *	caps () const override

GrGLGpu *	gpu () const

Public Member Functions inherited from GrGLSLProgramBuilder
virtual	~GrGLSLProgramBuilder ()

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 void	finalizeFragmentSecondaryColor (GrShaderVar &outputColor)

Static Public Member Functions
static sk_sp< GrGLProgram >	CreateProgram (GrDirectContext , const GrProgramDesc &, const GrProgramInfo &, const GrGLPrecompiledProgram =nullptr)

static bool	PrecompileProgram (GrDirectContext , GrGLPrecompiledProgram , const SkData &)

Private Member Functions
GrGLSLUniformHandler *	uniformHandler () override

const GrGLSLUniformHandler *	uniformHandler () const override

GrGLSLVaryingHandler *	varyingHandler () override

Additional Inherited Members
Public Types inherited from GrGLSLProgramBuilder
using	UniformHandle = GrGLSLUniformHandler::UniformHandle

using	SamplerHandle = GrGLSLUniformHandler::SamplerHandle

Public Attributes inherited from GrGLSLProgramBuilder
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 inherited from GrGLSLProgramBuilder
static const int	kVarsPerBlock = 8

Protected Member Functions inherited from GrGLSLProgramBuilder
	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 37 of file GrGLProgramBuilder.h.

Member Function Documentation

◆ caps()

const GrCaps * GrGLProgramBuilder::caps ( ) const

overridevirtual

Implements GrGLSLProgramBuilder.

Definition at line 93 of file GrGLProgramBuilder.cpp.

                                             {
    return fGpu->caps();
}

◆ CreateProgram()

sk_sp< GrGLProgram > GrGLProgramBuilder::CreateProgram	(	GrDirectContext *	dContext,
		const GrProgramDesc &	desc,
		const GrProgramInfo &	programInfo,
		const GrGLPrecompiledProgram *	precompiledProgram = `nullptr`
	)

static

Generates a shader program.

The program implements what is specified in the stages given as input. After successful generation, the builder result objects are available to be used. If a GL program has already been created, the program ID and interface can be supplied to skip the shader compilation.

Returns: the created program if generation was successful.

Definition at line 51 of file GrGLProgramBuilder.cpp.

                                                                                                 {
    TRACE_EVENT0_ALWAYS("skia.shaders", "shader_compile");
    GrAutoLocaleSetter als("C");
 
    GrGLGpu* glGpu = static_cast<GrGLGpu*>(dContext->priv().getGpu());
 
    // create a builder.  This will be handed off to effects so they can use it to add
    // uniforms, varyings, textures, etc
    GrGLProgramBuilder builder(glGpu, desc, programInfo);
 
    auto persistentCache = dContext->priv().getPersistentCache();
    if (persistentCache && !precompiledProgram) {
        sk_sp<SkData> key = SkData::MakeWithoutCopy(desc.asKey(), desc.keyLength());
        builder.fCached = persistentCache->load(*key);
        // the eventual end goal is to completely skip emitAndInstallProcs on a cache hit, but it's
        // doing necessary setup in addition to generating the SkSL code. Currently we are only able
        // to skip the SkSL->GLSL step on a cache hit.
    }
    if (!builder.emitAndInstallProcs()) {
        return nullptr;
    }
    return builder.finalize(precompiledProgram);
}

◆ gpu()

GrGLGpu * GrGLProgramBuilder::gpu ( ) const

inline

Definition at line 57 of file GrGLProgramBuilder.h.

57{ return fGpu; }

◆ PrecompileProgram()

bool GrGLProgramBuilder::PrecompileProgram	(	GrDirectContext *	dContext,
		GrGLPrecompiledProgram *	precompiledProgram,
		const SkData &	cachedData
	)

static

Definition at line 453 of file GrGLProgramBuilder.cpp.

                                                                     {
    SkReadBuffer reader(cachedData.data(), cachedData.size());
    SkFourByteTag shaderType = GrPersistentCacheUtils::GetType(&reader);
    if (shaderType != kSKSL_Tag) {
        // TODO: Support GLSL, and maybe even program binaries, too?
        return false;
    }
 
    GrGLGpu* glGpu = static_cast<GrGLGpu*>(dContext->priv().getGpu());
 
    const GrGLInterface* gl = glGpu->glInterface();
    auto errorHandler = dContext->priv().getShaderErrorHandler();
 
    SkSL::ProgramSettings settings;
    settings.fSharpenTextures = true;
    GrPersistentCacheUtils::ShaderMetadata meta;
    meta.fSettings = &settings;
 
    std::string shaders[kGrShaderTypeCount];
    SkSL::Program::Interface interface;
    if (!GrPersistentCacheUtils::UnpackCachedShaders(&reader, shaders, &interface, 1, &meta)) {
        return false;
    }
 
    GrGLuint programID;
    GR_GL_CALL_RET(gl, programID, CreateProgram());
    if (0 == programID) {
        return false;
    }
 
    SkTDArray<GrGLuint> shadersToDelete;
 
    auto compileShader = [&](SkSL::ProgramKind kind, const std::string& sksl, GrGLenum type) {
        std::string glsl;
        SkSL::Program::Interface unusedInterface;
        if (!skgpu::SkSLToGLSL(glGpu->caps()->shaderCaps(),
                               sksl,
                               kind,
                               settings,
                               &glsl,
                               &unusedInterface,
                               errorHandler)) {
            return false;
        }
 
        if (GrGLuint shaderID = GrGLCompileAndAttachShader(glGpu->glContext(),
                                                           programID,
                                                           type,
                                                           glsl,
                                                           /*shaderWasCached=*/false,
                                                           glGpu->pipelineBuilder()->stats(),
                                                           errorHandler)) {
            shadersToDelete.push_back(shaderID);
            return true;
        } else {
            return false;
        }
    };
 
    if (!compileShader(SkSL::ProgramKind::kFragment,
                       shaders[kFragment_GrShaderType],
                       GR_GL_FRAGMENT_SHADER) ||
        !compileShader(SkSL::ProgramKind::kVertex,
                       shaders[kVertex_GrShaderType],
                       GR_GL_VERTEX_SHADER)) {
        cleanup_program(glGpu, programID, shadersToDelete);
        return false;
    }
 
    for (int i = 0; i < meta.fAttributeNames.size(); ++i) {
        GR_GL_CALL(glGpu->glInterface(), BindAttribLocation(programID, i,
                                                          meta.fAttributeNames[i].c_str()));
    }
 
    const GrGLCaps& caps = glGpu->glCaps();
    if (caps.bindFragDataLocationSupport()) {
        SkASSERT(caps.shaderCaps()->mustDeclareFragmentShaderOutput());
        GR_GL_CALL(glGpu->glInterface(),
                   BindFragDataLocation(programID, 0,
                                        GrGLSLFragmentShaderBuilder::DeclaredColorOutputName()));
 
        if (meta.fHasSecondaryColorOutput) {
            GR_GL_CALL(glGpu->glInterface(),
                       BindFragDataLocationIndexed(programID, 0, 1,
                                  GrGLSLFragmentShaderBuilder::DeclaredSecondaryColorOutputName()));
        }
    }
 
    GR_GL_CALL(glGpu->glInterface(), LinkProgram(programID));
    GrGLint linked = GR_GL_INIT_ZERO;
    GR_GL_CALL(glGpu->glInterface(), GetProgramiv(programID, GR_GL_LINK_STATUS, &linked));
    if (!linked) {
        cleanup_program(glGpu, programID, shadersToDelete);
        return false;
    }
 
    cleanup_shaders(glGpu, shadersToDelete);
 
    precompiledProgram->fProgramID = programID;
    precompiledProgram->fInterface = interface;
    return true;
}

◆ uniformHandler() [1/2]

const GrGLSLUniformHandler * GrGLProgramBuilder::uniformHandler ( ) const

inlineoverrideprivatevirtual

Implements GrGLSLProgramBuilder.

Definition at line 86 of file GrGLProgramBuilder.h.

86{ return &fUniformHandler; }

◆ uniformHandler() [2/2]

GrGLSLUniformHandler * GrGLProgramBuilder::uniformHandler ( )

inlineoverrideprivatevirtual

Implements GrGLSLProgramBuilder.

Definition at line 85 of file GrGLProgramBuilder.h.

85{ return &fUniformHandler; }

◆ varyingHandler()

GrGLSLVaryingHandler * GrGLProgramBuilder::varyingHandler ( )

inlineoverrideprivatevirtual

Implements GrGLSLProgramBuilder.

Definition at line 87 of file GrGLProgramBuilder.h.

87{ return &fVaryingHandler; }

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

third_party/skia/src/gpu/ganesh/gl/builders/GrGLProgramBuilder.h
third_party/skia/src/gpu/ganesh/gl/builders/GrGLProgramBuilder.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ caps()

◆ CreateProgram()

◆ gpu()

◆ PrecompileProgram()

◆ uniformHandler() [1/2]

◆ uniformHandler() [2/2]

◆ varyingHandler()