SkSL::ModuleLoader Class Reference

#include <SkSLModuleLoader.h>

Classes
struct	Impl

Public Member Functions
	ModuleLoader (ModuleLoader::Impl &)
	~ModuleLoader ()
const BuiltinTypes &	builtinTypes ()
const Module *	rootModule ()
const Module *	loadSharedModule (SkSL::Compiler *compiler)
const Module *	loadGPUModule (SkSL::Compiler *compiler)
const Module *	loadVertexModule (SkSL::Compiler *compiler)
const Module *	loadFragmentModule (SkSL::Compiler *compiler)
const Module *	loadComputeModule (SkSL::Compiler *compiler)
const Module *	loadGraphiteVertexModule (SkSL::Compiler *compiler)
const Module *	loadGraphiteFragmentModule (SkSL::Compiler *compiler)
const Module *	loadGraphiteVertexES2Module (SkSL::Compiler *compiler)
const Module *	loadGraphiteFragmentES2Module (SkSL::Compiler *compiler)
const Module *	loadPublicModule (SkSL::Compiler *compiler)
const Module *	loadPrivateRTShaderModule (SkSL::Compiler *compiler)
void	addPublicTypeAliases (const SkSL::Module *module)
void	unloadModules ()

Static Public Member Functions
static ModuleLoader	Get ()

Detailed Description

Definition at line 22 of file SkSLModuleLoader.h.

Constructor & Destructor Documentation

ModuleLoader()

SkSL::ModuleLoader::ModuleLoader

(

ModuleLoader::Impl &

m

)

Definition at line 181 of file SkSLModuleLoader.cpp.

                                              : fModuleLoader(m) {
    fModuleLoader.fMutex.acquire();
}

~ModuleLoader()

SkSL::ModuleLoader::~ModuleLoader

(

)

Definition at line 185 of file SkSLModuleLoader.cpp.

                            {
    fModuleLoader.fMutex.release();
}

Member Function Documentation

addPublicTypeAliases()

void SkSL::ModuleLoader::addPublicTypeAliases

(

const SkSL::Module *

module

)

Definition at line 257 of file SkSLModuleLoader.cpp.

                                                                {
    const SkSL::BuiltinTypes& types = this->builtinTypes();
    SymbolTable* symbols = module->fSymbols.get();
 
    // Add some aliases to the runtime effect modules so that it's friendlier, and more like GLSL.
    symbols->addWithoutOwnershipOrDie(types.fVec2.get());
    symbols->addWithoutOwnershipOrDie(types.fVec3.get());
    symbols->addWithoutOwnershipOrDie(types.fVec4.get());
 
    symbols->addWithoutOwnershipOrDie(types.fIVec2.get());
    symbols->addWithoutOwnershipOrDie(types.fIVec3.get());
    symbols->addWithoutOwnershipOrDie(types.fIVec4.get());
 
    symbols->addWithoutOwnershipOrDie(types.fBVec2.get());
    symbols->addWithoutOwnershipOrDie(types.fBVec3.get());
    symbols->addWithoutOwnershipOrDie(types.fBVec4.get());
 
    symbols->addWithoutOwnershipOrDie(types.fMat2.get());
    symbols->addWithoutOwnershipOrDie(types.fMat3.get());
    symbols->addWithoutOwnershipOrDie(types.fMat4.get());
 
    symbols->addWithoutOwnershipOrDie(types.fMat2x2.get());
    symbols->addWithoutOwnershipOrDie(types.fMat2x3.get());
    symbols->addWithoutOwnershipOrDie(types.fMat2x4.get());
    symbols->addWithoutOwnershipOrDie(types.fMat3x2.get());
    symbols->addWithoutOwnershipOrDie(types.fMat3x3.get());
    symbols->addWithoutOwnershipOrDie(types.fMat3x4.get());
    symbols->addWithoutOwnershipOrDie(types.fMat4x2.get());
    symbols->addWithoutOwnershipOrDie(types.fMat4x3.get());
    symbols->addWithoutOwnershipOrDie(types.fMat4x4.get());
 
    // Hide all the private symbols by aliasing them all to "invalid". This will prevent code from
    // using built-in names like `sampler2D` as variable names.
    for (BuiltinTypePtr privateType : kPrivateTypes) {
        symbols->inject(Type::MakeAliasType((types.*privateType)->name(), *types.fInvalid));
    }
}

builtinTypes()

const BuiltinTypes & SkSL::ModuleLoader::builtinTypes

(

)

Definition at line 249 of file SkSLModuleLoader.cpp.

                                               {
    return fModuleLoader.fBuiltinTypes;
}

Get()

ModuleLoader SkSL::ModuleLoader::Get ( )

static

Definition at line 176 of file SkSLModuleLoader.cpp.

                               {
    static SkNoDestructor<ModuleLoader::Impl> sModuleLoaderImpl;
    return ModuleLoader(*sModuleLoaderImpl);
}

loadComputeModule()

const Module * SkSL::ModuleLoader::loadComputeModule

(

SkSL::Compiler *

compiler

)

Definition at line 362 of file SkSLModuleLoader.cpp.

                                                                    {
    if (!fModuleLoader.fComputeModule) {
        const Module* gpuModule = this->loadGPUModule(compiler);
        fModuleLoader.fComputeModule = compile_and_shrink(compiler,
                                                          ProgramKind::kCompute,
                                                          MODULE_DATA(sksl_compute),
                                                          gpuModule);
    }
    return fModuleLoader.fComputeModule.get();
}

loadFragmentModule()

const Module * SkSL::ModuleLoader::loadFragmentModule

(

SkSL::Compiler *

compiler

)

Definition at line 340 of file SkSLModuleLoader.cpp.

                                                                     {
    if (!fModuleLoader.fFragmentModule) {
        const Module* gpuModule = this->loadGPUModule(compiler);
        fModuleLoader.fFragmentModule = compile_and_shrink(compiler,
                                                           ProgramKind::kFragment,
                                                           MODULE_DATA(sksl_frag),
                                                           gpuModule);
    }
    return fModuleLoader.fFragmentModule.get();
}

loadGPUModule()

const Module * SkSL::ModuleLoader::loadGPUModule

(

SkSL::Compiler *

compiler

)

Definition at line 329 of file SkSLModuleLoader.cpp.

                                                                {
    if (!fModuleLoader.fGPUModule) {
        const Module* sharedModule = this->loadSharedModule(compiler);
        fModuleLoader.fGPUModule = compile_and_shrink(compiler,
                                                      ProgramKind::kFragment,
                                                      MODULE_DATA(sksl_gpu),
                                                      sharedModule);
    }
    return fModuleLoader.fGPUModule.get();
}

loadGraphiteFragmentES2Module()

const Module * SkSL::ModuleLoader::loadGraphiteFragmentES2Module

(

SkSL::Compiler *

compiler

)

Definition at line 388 of file SkSLModuleLoader.cpp.

                                                                                {
#if defined(SK_GRAPHITE)
    if (!fModuleLoader.fGraphiteFragmentES2Module) {
        const Module* fragmentModule = this->loadFragmentModule(compiler);
        fModuleLoader.fGraphiteFragmentES2Module =
                compile_and_shrink(compiler,
                                   ProgramKind::kGraphiteFragmentES2,
                                   MODULE_DATA(sksl_graphite_frag_es2),
                                   fragmentModule);
    }
    return fModuleLoader.fGraphiteFragmentES2Module.get();
#else
    return this->loadFragmentModule(compiler);
#endif
}

loadGraphiteFragmentModule()

const Module * SkSL::ModuleLoader::loadGraphiteFragmentModule

(

SkSL::Compiler *

compiler

)

Definition at line 373 of file SkSLModuleLoader.cpp.

                                                                             {
#if defined(SK_GRAPHITE)
    if (!fModuleLoader.fGraphiteFragmentModule) {
        const Module* fragmentModule = this->loadFragmentModule(compiler);
        fModuleLoader.fGraphiteFragmentModule = compile_and_shrink(compiler,
                                                                   ProgramKind::kGraphiteFragment,
                                                                   MODULE_DATA(sksl_graphite_frag),
                                                                   fragmentModule);
    }
    return fModuleLoader.fGraphiteFragmentModule.get();
#else
    return this->loadFragmentModule(compiler);
#endif
}

loadGraphiteVertexES2Module()

const Module * SkSL::ModuleLoader::loadGraphiteVertexES2Module

(

SkSL::Compiler *

compiler

)

Definition at line 419 of file SkSLModuleLoader.cpp.

                                                                              {
#if defined(SK_GRAPHITE)
    if (!fModuleLoader.fGraphiteVertexES2Module) {
        const Module* vertexModule = this->loadVertexModule(compiler);
        fModuleLoader.fGraphiteVertexES2Module =
                compile_and_shrink(compiler,
                                   ProgramKind::kGraphiteVertexES2,
                                   MODULE_DATA(sksl_graphite_vert_es2),
                                   vertexModule);
    }
    return fModuleLoader.fGraphiteVertexES2Module.get();
#else
    return this->loadVertexModule(compiler);
#endif
}

loadGraphiteVertexModule()

const Module * SkSL::ModuleLoader::loadGraphiteVertexModule

(

SkSL::Compiler *

compiler

)

Definition at line 404 of file SkSLModuleLoader.cpp.

                                                                           {
#if defined(SK_GRAPHITE)
    if (!fModuleLoader.fGraphiteVertexModule) {
        const Module* vertexModule = this->loadVertexModule(compiler);
        fModuleLoader.fGraphiteVertexModule = compile_and_shrink(compiler,
                                                                 ProgramKind::kGraphiteVertex,
                                                                 MODULE_DATA(sksl_graphite_vert),
                                                                 vertexModule);
    }
    return fModuleLoader.fGraphiteVertexModule.get();
#else
    return this->loadVertexModule(compiler);
#endif
}

loadPrivateRTShaderModule()

const Module * SkSL::ModuleLoader::loadPrivateRTShaderModule

(

SkSL::Compiler *

compiler

)

Definition at line 307 of file SkSLModuleLoader.cpp.

                                                                            {
    if (!fModuleLoader.fRuntimeShaderModule) {
        const Module* publicModule = this->loadPublicModule(compiler);
        fModuleLoader.fRuntimeShaderModule = compile_and_shrink(compiler,
                                                                ProgramKind::kFragment,
                                                                MODULE_DATA(sksl_rt_shader),
                                                                publicModule);
    }
    return fModuleLoader.fRuntimeShaderModule.get();
}

loadPublicModule()

const Module * SkSL::ModuleLoader::loadPublicModule

(

SkSL::Compiler *

compiler

)

Definition at line 295 of file SkSLModuleLoader.cpp.

                                                                   {
    if (!fModuleLoader.fPublicModule) {
        const Module* sharedModule = this->loadSharedModule(compiler);
        fModuleLoader.fPublicModule = compile_and_shrink(compiler,
                                                         ProgramKind::kFragment,
                                                         MODULE_DATA(sksl_public),
                                                         sharedModule);
        this->addPublicTypeAliases(fModuleLoader.fPublicModule.get());
    }
    return fModuleLoader.fPublicModule.get();
}

loadSharedModule()

const Module * SkSL::ModuleLoader::loadSharedModule

(

SkSL::Compiler *

compiler

)

Definition at line 318 of file SkSLModuleLoader.cpp.

                                                                   {
    if (!fModuleLoader.fSharedModule) {
        const Module* rootModule = this->rootModule();
        fModuleLoader.fSharedModule = compile_and_shrink(compiler,
                                                         ProgramKind::kFragment,
                                                         MODULE_DATA(sksl_shared),
                                                         rootModule);
    }
    return fModuleLoader.fSharedModule.get();
}

loadVertexModule()

const Module * SkSL::ModuleLoader::loadVertexModule

(

SkSL::Compiler *

compiler

)

Definition at line 351 of file SkSLModuleLoader.cpp.

                                                                   {
    if (!fModuleLoader.fVertexModule) {
        const Module* gpuModule = this->loadGPUModule(compiler);
        fModuleLoader.fVertexModule = compile_and_shrink(compiler,
                                                         ProgramKind::kVertex,
                                                         MODULE_DATA(sksl_vert),
                                                         gpuModule);
    }
    return fModuleLoader.fVertexModule.get();
}

rootModule()

const Module * SkSL::ModuleLoader::rootModule

(

)

Definition at line 253 of file SkSLModuleLoader.cpp.

                                       {
    return fModuleLoader.fRootModule.get();
}

unloadModules()

void SkSL::ModuleLoader::unloadModules

(

)

Definition at line 189 of file SkSLModuleLoader.cpp.

                                 {
    fModuleLoader.fSharedModule           = nullptr;
    fModuleLoader.fGPUModule              = nullptr;
    fModuleLoader.fVertexModule           = nullptr;
    fModuleLoader.fFragmentModule         = nullptr;
    fModuleLoader.fComputeModule          = nullptr;
    fModuleLoader.fGraphiteVertexModule   = nullptr;
    fModuleLoader.fGraphiteFragmentModule = nullptr;
    fModuleLoader.fPublicModule           = nullptr;
    fModuleLoader.fRuntimeShaderModule    = nullptr;
}

---

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

• third_party/skia/src/sksl/SkSLModuleLoader.h
• third_party/skia/src/sksl/SkSLModuleLoader.cpp