#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 123 of file SkSLModuleLoader.cpp.

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

◆ ~ModuleLoader()

SkSL::ModuleLoader::~ModuleLoader ( )

Definition at line 127 of file SkSLModuleLoader.cpp.

                            {
    fModuleLoader.fMutex.release();
}

Member Function Documentation

◆ addPublicTypeAliases()

void SkSL::ModuleLoader::addPublicTypeAliases ( const SkSL::Module * module )

Definition at line 199 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.fUVec2.get());
    symbols->addWithoutOwnershipOrDie(types.fUVec3.get());
    symbols->addWithoutOwnershipOrDie(types.fUVec4.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 191 of file SkSLModuleLoader.cpp.

                                               {
    return fModuleLoader.fBuiltinTypes;
}

◆ Get()

ModuleLoader SkSL::ModuleLoader::Get ( )

static

Definition at line 118 of file SkSLModuleLoader.cpp.

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

◆ loadComputeModule()

const Module * SkSL::ModuleLoader::loadComputeModule ( SkSL::Compiler * compiler )

Definition at line 308 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 286 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 275 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 334 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 319 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 365 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 350 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 253 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 241 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 264 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 297 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 195 of file SkSLModuleLoader.cpp.

                                       {
    return fModuleLoader.fRootModule.get();
}

◆ unloadModules()

void SkSL::ModuleLoader::unloadModules ( )

Definition at line 131 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

Classes

Public Member Functions

Static Public Member Functions