GrGLProgramBuilder Class Reference

#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 ()
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)

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

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.

{ 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;
}

---

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