@animech-public/playcanvas/build/playcanvas.dbg/src/scene/shader-lib/programs/basic.js

PlayCanvas WebGL game engine

import { SEMANTIC_POSITION, SEMANTIC_BLENDWEIGHT, SEMANTIC_BLENDINDICES, SEMANTIC_COLOR, SEMANTIC_TEXCOORD0 } from '../../../platform/graphics/constants.js';
import { ShaderUtils } from '../../../platform/graphics/shader-utils.js';
import { shaderChunks } from '../chunks/chunks.js';
import { ShaderPass } from '../../shader-pass.js';
import { ShaderGenerator } from './shader-generator.js';

const vShader = `

    #include "shaderPassDefines"
    #include "transformDeclVS"

    #ifdef SKIN
        #include "skinCode"
    #endif

    #include "transformVS"

    #ifdef VERTEX_COLORS
        attribute vec4 vertex_color;
        varying vec4 vColor;
    #endif

    #ifdef DIFFUSE_MAP
        attribute vec2 vertex_texCoord0;
        varying vec2 vUv0;
    #endif

    #ifdef DEPTH_PASS
        varying float vDepth;
        
        #ifndef VIEWMATRIX
        #define VIEWMATRIX
            uniform mat4 matrix_view;
        #endif

        #ifndef CAMERAPLANES
        #define CAMERAPLANES
            uniform vec4 camera_params;
        #endif
    #endif

    void main(void) {
        gl_Position = getPosition();

        #ifdef DEPTH_PASS
            vDepth = -(matrix_view * vec4(getWorldPosition(),1.0)).z * camera_params.x;
        #endif        

        #ifdef VERTEX_COLORS
            vColor = vertex_color;
        #endif

        #ifdef DIFFUSE_MAP
            vUv0 = vertex_texCoord0;
        #endif
    }
`;
const fShader = `

    #include "shaderPassDefines"

    #ifdef VERTEX_COLORS
        varying vec4 vColor;
    #else
        uniform vec4 uColor;
    #endif

    #ifdef DIFFUSE_MAP
        varying vec2 vUv0;
        uniform sampler2D texture_diffuseMap;
    #endif

    #ifdef FOG
        #include "fogCode"
    #endif

    #ifdef ALPHA_TEST
        #include "alphaTestPS"
    #endif

    #ifdef DEPTH_PASS
        varying float vDepth;
        #include "packDepthPS"
    #endif

    void main(void) {

        #ifdef VERTEX_COLORS
            gl_FragColor = vColor;
        #else
            gl_FragColor = uColor;
        #endif

        #ifdef DIFFUSE_MAP
            gl_FragColor *= texture2D(texture_diffuseMap, vUv0);
        #endif

        #ifdef ALPHA_TEST
            alphaTest(gl_FragColor.a);
        #endif

        #ifndef PICK_PASS

            #ifdef DEPTH_PASS
                gl_FragColor = packFloat(vDepth);
            #else
                #ifdef FOG
                    glFragColor.rgb = addFog(gl_FragColor.rgb);
                #endif
            #endif
        #endif
    }
`;
class ShaderGeneratorBasic extends ShaderGenerator {
  generateKey(options) {
    let key = 'basic';
    if (options.fog) key += '_fog';
    if (options.alphaTest) key += '_atst';
    if (options.vertexColors) key += '_vcol';
    if (options.diffuseMap) key += '_diff';
    if (options.skin) key += '_skin';
    if (options.screenSpace) key += '_ss';
    if (options.useInstancing) key += '_inst';
    if (options.useMorphPosition) key += '_morphp';
    if (options.useMorphNormal) key += '_morphn';
    if (options.useMorphTextureBased) key += '_morpht';
    key += `_${options.pass}`;
    return key;
  }
  createAttributesDefinition(definitionOptions, options) {
    // GENERATE ATTRIBUTES
    const attributes = {
      vertex_position: SEMANTIC_POSITION
    };
    if (options.skin) {
      attributes.vertex_boneWeights = SEMANTIC_BLENDWEIGHT;
      attributes.vertex_boneIndices = SEMANTIC_BLENDINDICES;
    }
    if (options.vertexColors) {
      attributes.vertex_color = SEMANTIC_COLOR;
    }
    if (options.diffuseMap) {
      attributes.vertex_texCoord0 = SEMANTIC_TEXCOORD0;
    }
    definitionOptions.attributes = attributes;
  }
  createVertexDefinition(device, definitionOptions, options, shaderPassInfo) {
    const includes = new Map();
    const defines = new Map();
    includes.set('shaderPassDefines', shaderPassInfo.shaderDefines);
    includes.set('transformDeclVS', shaderChunks.transformDeclVS);
    includes.set('transformVS', shaderChunks.transformVS);
    includes.set('skinCode', ShaderGenerator.skinCode(device));
    if (options.skin) defines.set('SKIN', true);
    if (options.vertexColors) defines.set('VERTEX_COLORS', true);
    if (options.diffuseMap) defines.set('DIFFUSE_MAP', true);
    definitionOptions.vertexCode = vShader;
    definitionOptions.vertexIncludes = includes;
    definitionOptions.vertexDefines = defines;
  }
  createFragmentDefinition(definitionOptions, options, shaderPassInfo) {
    const includes = new Map();
    const defines = new Map();
    includes.set('shaderPassDefines', shaderPassInfo.shaderDefines);
    includes.set('fogCode', ShaderGenerator.fogCode(options.fog));
    includes.set('alphaTestPS', shaderChunks.alphaTestPS);
    includes.set('packDepthPS', shaderChunks.packDepthPS);
    if (options.vertexColors) defines.set('VERTEX_COLORS', true);
    if (options.diffuseMap) defines.set('DIFFUSE_MAP', true);
    if (options.fog) defines.set('FOG', true);
    if (options.alphaTest) defines.set('ALPHA_TEST', true);
    definitionOptions.fragmentCode = fShader;
    definitionOptions.fragmentIncludes = includes;
    definitionOptions.fragmentDefines = defines;
  }
  createShaderDefinition(device, options) {
    const definitionOptions = {
      name: 'BasicShader'
    };
    const shaderPassInfo = ShaderPass.get(device).getByIndex(options.pass);
    this.createAttributesDefinition(definitionOptions, options);
    this.createVertexDefinition(device, definitionOptions, options, shaderPassInfo);
    this.createFragmentDefinition(definitionOptions, options, shaderPassInfo);
    return ShaderUtils.createDefinition(device, definitionOptions);
  }
}
const basic = new ShaderGeneratorBasic();

export { basic };