playcanvas/build/playcanvas/src/scene/gsplat/gsplat-material.js

PlayCanvas WebGL game engine

import { CULLFACE_NONE, SEMANTIC_POSITION, SEMANTIC_ATTR13 } from '../../platform/graphics/constants.js';
import { ShaderProcessorOptions } from '../../platform/graphics/shader-processor-options.js';
import { DITHER_NONE, BLEND_NONE, BLEND_NORMAL, tonemapNames, gammaNames } from '../constants.js';
import { ShaderMaterial } from '../materials/shader-material.js';
import { getProgramLibrary } from '../shader-lib/get-program-library.js';
import { getMaterialShaderDefines } from '../shader-lib/utils.js';
import { ShaderUtils } from '../../platform/graphics/shader-utils.js';
import { shaderChunks } from '../shader-lib/chunks/chunks.js';
import { ShaderGenerator } from '../shader-lib/programs/shader-generator.js';
import { ShaderPass } from '../shader-pass.js';
import { hashCode } from '../../core/hash.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);
}
var defaultChunks = new Map(Object.entries(shaderChunks));
class GSplatShaderGenerator {
		generateKey(options) {
				var { pass, gamma, toneMapping, vertex, fragment, dither, defines, chunks } = options;
				return "splat-" + pass + "-" + gamma + "-" + toneMapping + "-" + hashCode(vertex) + "-" + hashCode(fragment) + "-" + dither + "-" + ShaderGenerator.definesHash(defines) + "-" + (chunks && Object.keys(chunks).sort().join(':'));
		}
		createShaderDefinition(device, options) {
				var shaderPassInfo = ShaderPass.get(device).getByIndex(options.pass);
				var shaderPassDefines = shaderPassInfo.shaderDefines;
				var defineMap = new Map();
				var _tonemapNames_options_toneMapping;
				defineMap.set('TONEMAP', (_tonemapNames_options_toneMapping = tonemapNames[options.toneMapping]) != null ? _tonemapNames_options_toneMapping : true);
				var _gammaNames_options_gamma;
				defineMap.set('GAMMA', (_gammaNames_options_gamma = gammaNames[options.gamma]) != null ? _gammaNames_options_gamma : true);
				defineMap.set("DITHER_" + options.dither.toUpperCase(), true);
				options.defines.forEach((value, key)=>{
						defineMap.set(key, value);
				});
				var defines = "" + shaderPassDefines + "\n";
				var _options_vertex;
				var vs = defines + ((_options_vertex = options.vertex) != null ? _options_vertex : shaderChunks.gsplatVS);
				var _options_fragment;
				var fs = defines + ((_options_fragment = options.fragment) != null ? _options_fragment : shaderChunks.gsplatPS);
				var includes = options.chunks ? new Map(Object.entries(_extends({}, shaderChunks, options.chunks))) : defaultChunks;
				return ShaderUtils.createDefinition(device, {
						name: 'SplatShader',
						attributes: {
								vertex_position: SEMANTIC_POSITION,
								vertex_id_attrib: SEMANTIC_ATTR13
						},
						vertexCode: vs,
						vertexDefines: defineMap,
						vertexIncludes: includes,
						fragmentCode: fs,
						fragmentDefines: defineMap,
						fragmentIncludes: includes
				});
		}
}
var gsplat = new GSplatShaderGenerator();
var createGSplatMaterial = (options)=>{
		if (options === undefined) options = {};
		var _options_dither;
		var ditherEnum = (_options_dither = options.dither) != null ? _options_dither : DITHER_NONE;
		var dither = ditherEnum !== DITHER_NONE;
		var material = new ShaderMaterial();
		material.name = 'splatMaterial';
		material.cull = CULLFACE_NONE;
		material.blendType = dither ? BLEND_NONE : BLEND_NORMAL;
		material.depthWrite = dither;
		material.getShaderVariant = function createGSplatMaterial(params) {
				var { cameraShaderParams } = params;
				var programOptions = {
						defines: getMaterialShaderDefines(material, cameraShaderParams),
						pass: params.pass,
						gamma: cameraShaderParams.shaderOutputGamma,
						toneMapping: cameraShaderParams.toneMapping,
						vertex: options.vertex,
						fragment: options.fragment,
						chunks: options.chunks,
						dither: ditherEnum
				};
				var processingOptions = new ShaderProcessorOptions(params.viewUniformFormat, params.viewBindGroupFormat);
				var library = getProgramLibrary(params.device);
				library.register('splat', gsplat);
				return library.getProgram('splat', programOptions, processingOptions);
		};
		material.update();
		return material;
};

export { createGSplatMaterial };