playcanvas/build/playcanvas.dbg/src/scene/shader-lib/programs/lit.js

PlayCanvas WebGL game engine

import { ChunkBuilder } from '../chunk-builder.js';
import { LitShader } from './lit-shader.js';
import { LitOptionsUtils } from './lit-options-utils.js';
import { ShaderGenerator } from './shader-generator.js';
import { SHADERTAG_MATERIAL, SHADERLANGUAGE_GLSL } from '../../../platform/graphics/constants.js';
import { ShaderUtils } from '../../../platform/graphics/shader-utils.js';

function _extends() {
    _extends = Object.assign || function(target) {
        for(var i = 1; i < arguments.length; i++){
            var source = arguments[i];
            for(var key in source){
                if (Object.prototype.hasOwnProperty.call(source, key)) {
                    target[key] = source[key];
                }
            }
        }
        return target;
    };
    return _extends.apply(this, arguments);
}
/**
 * @import { GraphicsDevice } from '../../../platform/graphics/graphics-device.js'
 * @import { LitMaterialOptions } from '../../materials/lit-material-options.js'
 */ var dummyUvs = [
    0,
    1,
    2,
    3,
    4,
    5,
    6,
    7
];
class ShaderGeneratorLit extends ShaderGenerator {
    generateKey(options) {
        var definesHash = ShaderGenerator.definesHash(options.defines);
        var key = "lit_" + definesHash + "_" + dummyUvs.map((dummy, index)=>{
            return options.usedUvs[index] ? '1' : '0';
        }).join('') + options.shaderChunk + LitOptionsUtils.generateKey(options.litOptions);
        return key;
    }
    /**
     * @param {GraphicsDevice} device - The graphics device.
     * @param {LitMaterialOptions} options - The options to be passed to the backend.
     * @returns {object} Returns the created shader definition.
     */ createShaderDefinition(device, options) {
        var litShader = new LitShader(device, options.litOptions);
        var decl = new ChunkBuilder();
        var code = new ChunkBuilder();
        // global texture bias for standard textures
        decl.append('uniform float textureBias;');
        decl.append(litShader.chunks.litShaderArgsPS);
        code.append(options.shaderChunk);
        var definitionOptions = {
            name: 'LitShader',
            shaderLanguage: SHADERLANGUAGE_GLSL,
            tag: litShader.shaderPassInfo.isForward ? SHADERTAG_MATERIAL : undefined
        };
        var usedUvSets = options.usedUvs || [
            true
        ];
        var mapTransforms = [];
        litShader.generateVertexShader(usedUvSets, usedUvSets, mapTransforms);
        litShader.generateFragmentShader(decl.code, code.code, 'vUv0');
        var includes = new Map(Object.entries(_extends({}, Object.getPrototypeOf(litShader.chunks), litShader.chunks, options.litOptions.chunks)));
        var vDefines = litShader.vDefines;
        options.defines.forEach((value, key)=>vDefines.set(key, value));
        var fDefines = litShader.fDefines;
        options.defines.forEach((value, key)=>fDefines.set(key, value));
        definitionOptions.attributes = litShader.attributes;
        definitionOptions.vertexCode = litShader.vshader;
        definitionOptions.vertexIncludes = includes;
        definitionOptions.vertexDefines = vDefines;
        definitionOptions.fragmentCode = litShader.fshader;
        definitionOptions.fragmentIncludes = includes;
        definitionOptions.fragmentDefines = fDefines;
        return ShaderUtils.createDefinition(device, definitionOptions);
    }
}
var lit = new ShaderGeneratorLit();

export { lit };