@lampdotdev/lamp 0.0.0-stage → 0.36.2-nightly.16

package/Resources/WebLibraries/three/addons/tsl/lighting/DynamicLightsNode.js

@@ -0,0 +1,201 @@
+import { AmbientLight, DirectionalLight, HemisphereLight, LightsNode, NodeUtils, PointLight, SpotLight } from 'three/webgpu';
+
+import AmbientLightDataNode from './data/AmbientLightDataNode.js';
+import DirectionalLightDataNode from './data/DirectionalLightDataNode.js';
+import PointLightDataNode from './data/PointLightDataNode.js';
+import SpotLightDataNode from './data/SpotLightDataNode.js';
+import HemisphereLightDataNode from './data/HemisphereLightDataNode.js';
+
+const _hashData = [];
+
+const _lightClassToType = new Map( [
+	[ AmbientLight, 'AmbientLight' ],
+	[ DirectionalLight, 'DirectionalLight' ],
+	[ PointLight, 'PointLight' ],
+	[ SpotLight, 'SpotLight' ],
+	[ HemisphereLight, 'HemisphereLight' ]
+] );
+
+const _lightTypeToDataNode = {
+	AmbientLight: AmbientLightDataNode,
+	DirectionalLight: DirectionalLightDataNode,
+	PointLight: PointLightDataNode,
+	SpotLight: SpotLightDataNode,
+	HemisphereLight: HemisphereLightDataNode
+};
+
+const _lightTypeToMaxProp = {
+	DirectionalLight: 'maxDirectionalLights',
+	PointLight: 'maxPointLights',
+	SpotLight: 'maxSpotLights',
+	HemisphereLight: 'maxHemisphereLights'
+};
+
+const isSpecialSpotLight = ( light ) => {
+
+	return light.isSpotLight === true && ( light.map !== null || light.colorNode !== undefined );
+
+};
+
+const canBatchLight = ( light ) => {
+
+	return light.isNode !== true &&
+		light.castShadow !== true &&
+		isSpecialSpotLight( light ) === false &&
+		_lightClassToType.has( light.constructor );
+
+};
+
+/**
+ * A custom version of `LightsNode` that batches supported analytic lights into
+ * uniform arrays and loops.
+ *
+ * Unsupported lights, node lights, shadow-casting lights, and projected spot
+ * lights keep the default per-light path.
+ *
+ * @augments LightsNode
+ * @three_import import { DynamicLightsNode } from 'three/addons/tsl/lighting/DynamicLightsNode.js';
+ */
+class DynamicLightsNode extends LightsNode {
+
+	static get type() {
+
+		return 'DynamicLightsNode';
+
+	}
+
+	/**
+	 * Constructs a new dynamic lights node.
+	 *
+	 * @param {Object} [options={}] - Dynamic lighting configuration.
+	 * @param {number} [options.maxDirectionalLights=8] - Maximum number of batched directional lights.
+	 * @param {number} [options.maxPointLights=16] - Maximum number of batched point lights.
+	 * @param {number} [options.maxSpotLights=16] - Maximum number of batched spot lights.
+	 * @param {number} [options.maxHemisphereLights=4] - Maximum number of batched hemisphere lights.
+	 */
+	constructor( options = {} ) {
+
+		super();
+
+		this.maxDirectionalLights = options.maxDirectionalLights !== undefined ? options.maxDirectionalLights : 8;
+		this.maxPointLights = options.maxPointLights !== undefined ? options.maxPointLights : 16;
+		this.maxSpotLights = options.maxSpotLights !== undefined ? options.maxSpotLights : 16;
+		this.maxHemisphereLights = options.maxHemisphereLights !== undefined ? options.maxHemisphereLights : 4;
+
+		this._builtinLights = [];
+		this._dataNodes = new Map();
+
+	}
+
+	customCacheKey() {
+
+		_hashData.push( super.customCacheKey() );
+
+		for ( const typeName of [ ...this._dataNodes.keys() ].sort() ) {
+
+			_hashData.push( NodeUtils.hashString( typeName ) );
+
+		}
+
+		const cacheKey = NodeUtils.hashArray( _hashData );
+
+		_hashData.length = 0;
+
+		return cacheKey;
+
+	}
+
+	setupLightsNode( builder ) {
+
+		const lightNodes = super.setupLightsNode( builder );
+
+		for ( const dataNode of this._dataNodes.values() ) {
+
+			lightNodes.push( dataNode );
+
+		}
+
+		return lightNodes;
+
+	}
+
+	setLights( lights ) {
+
+		const builtinLights = this._builtinLights;
+		const lightsByType = new Map();
+
+		builtinLights.length = 0;
+
+		for ( const light of lights ) {
+
+			if ( canBatchLight( light ) === false ) {
+
+				builtinLights.push( light );
+				continue;
+
+			}
+
+			const typeName = _lightClassToType.get( light.constructor );
+			const typeLights = lightsByType.get( typeName );
+
+			if ( typeLights === undefined ) {
+
+				lightsByType.set( typeName, [ light ] );
+
+			} else {
+
+				typeLights.push( light );
+
+			}
+
+		}
+
+		for ( const typeName of lightsByType.keys() ) {
+
+			if ( this._dataNodes.has( typeName ) === false ) {
+
+				const DataNodeClass = _lightTypeToDataNode[ typeName ];
+				const maxProp = _lightTypeToMaxProp[ typeName ];
+				const maxCount = maxProp !== undefined ? this[ maxProp ] : undefined;
+
+				this._dataNodes.set( typeName, maxCount !== undefined ? new DataNodeClass( maxCount ) : new DataNodeClass() );
+
+			}
+
+		}
+
+		for ( const [ typeName, dataNode ] of this._dataNodes ) {
+
+			dataNode.setLights( lightsByType.get( typeName ) || [] );
+
+		}
+
+		return super.setLights( lights );
+
+	}
+
+	getBuiltinLights() {
+
+		return this._builtinLights;
+
+	}
+
+	get hasLights() {
+
+		return super.hasLights || this._dataNodes.size > 0;
+
+	}
+
+}
+
+export default DynamicLightsNode;
+
+/**
+ * TSL function that creates a dynamic lights node.
+ *
+ * @tsl
+ * @function
+ * @param {Object} [options={}] - Dynamic lighting configuration.
+ * @return {DynamicLightsNode} The created dynamic lights node.
+ */
+export const dynamicLights = ( options = {} ) => new DynamicLightsNode( options );

package/Resources/WebLibraries/three/addons/tsl/lighting/LightProbeGridNode.js

@@ -0,0 +1,183 @@
+import { AnalyticLightNode, NodeUpdateType, Vector3 } from 'three/webgpu';
+import { INFINITY, If, array, getShIrradianceAt, normalWorld, positionWorld, renderGroup, texture3D, uniform, vec3 } from 'three/tsl';
+
+// Padding texels at each boundary of every atlas sub-volume.
+export const ATLAS_PADDING = 1;
+
+/**
+ * Samples the packed SH atlas and evaluates L2 irradiance for the given normal.
+ *
+ * The atlas stores the seven RGBA sub-volumes stacked along Z, each occupying
+ * `( nz + 2 )` slices: one padding slice (a copy of the nearest edge slice) at
+ * each end to prevent color bleeding when the hardware trilinear filter reads
+ * across a sub-volume boundary.
+ *
+ * @private
+ * @param {Texture3DNode} atlas - The atlas texture node.
+ * @param {Node<vec3>} uvw - The probe-grid sample coordinate (texel centers).
+ * @param {Node<vec3>} res - The probe resolution.
+ * @param {Node<vec3>} normal - The world-space normal.
+ * @return {Node<vec3>} The non-negative irradiance.
+ */
+function evaluateGridIrradiance( atlas, uvw, res, normal ) {
+
+	const nz = res.z;
+	const paddedSlices = nz.add( 2.0 * ATLAS_PADDING );
+	const atlasDepth = paddedSlices.mul( 7.0 );
+	const uvZBase = uvw.z.mul( nz ).add( ATLAS_PADDING );
+
+	const slice = ( t ) => atlas.sample( vec3( uvw.xy, uvZBase.add( paddedSlices.mul( t ) ).div( atlasDepth ) ) );
+
+	const s0 = slice( 0 ), s1 = slice( 1 ), s2 = slice( 2 ), s3 = slice( 3 );
+	const s4 = slice( 4 ), s5 = slice( 5 ), s6 = slice( 6 );
+
+	// Unpack 9 vec3 L2 SH coefficients and evaluate irradiance.
+
+	const sh = array( [
+		s0.xyz,
+		vec3( s0.w, s1.xy ),
+		vec3( s1.zw, s2.x ),
+		s2.yzw,
+		s3.xyz,
+		vec3( s3.w, s4.xy ),
+		vec3( s4.zw, s5.x ),
+		s5.yzw,
+		s6.xyz
+	] );
+
+	return getShIrradianceAt( normal, sh ).max( vec3( 0.0 ) );
+
+}
+
+/**
+ * Evaluates the irradiance of a light probe grid at the given world-space position and normal.
+ *
+ * @private
+ * @param {LightProbeGrid} light - The light probe grid.
+ * @param {Node<vec3>} min - The minimum of the grid bounds.
+ * @param {Node<vec3>} max - The maximum of the grid bounds.
+ * @param {Node<vec3>} res - The probe resolution.
+ * @param {Node<float>} intensity - The intensity.
+ * @param {Node<vec3>} position - The world-space position.
+ * @param {Node<vec3>} normal - The world-space normal.
+ * @return {Node<vec3>} The irradiance.
+ */
+function getGridIrradiance( light, min, max, res, intensity, position, normal ) {
+
+	const range = max.sub( min );
+	const spacing = range.div( res );
+
+	// Offset along the normal by half a probe spacing. The bounds hold one cell per
+	// probe, so they map directly to the probe grid; clamp to the outermost texel centers.
+
+	const samplePos = position.add( normal.mul( spacing ).mul( 0.5 ) );
+	const halfTexel = vec3( 0.5 ).div( res );
+	const uvw = samplePos.sub( min ).div( range ).clamp( halfTexel, halfTexel.oneMinus() );
+
+	return evaluateGridIrradiance( texture3D( light.texture ), uvw, res, normal ).mul( intensity );
+
+}
+
+/**
+ * Returns the irradiance of a baked {@link LightProbeGrid} at the given world-space
+ * position and normal. Use this to evaluate the grid outside of the lighting context,
+ * e.g. when baking light maps with {@link LightMapper}.
+ *
+ * @param {LightProbeGrid} light - The baked light probe grid.
+ * @param {Node<vec3>} position - The world-space position.
+ * @param {Node<vec3>} normal - The world-space normal.
+ * @return {Node<vec3>} The irradiance.
+ */
+export function lightProbeGridIrradiance( light, position, normal ) {
+
+	const box = light.boundingBox;
+
+	return getGridIrradiance( light, uniform( box.min ), uniform( box.max ), uniform( light.resolution ), uniform( light.intensity ), position, normal );
+
+}
+
+/**
+ * The light node that applies a {@link LightProbeGrid} to the scene. It samples
+ * the baked L2 spherical-harmonic atlas at the surface position and adds the
+ * resulting irradiance to the lighting context, so every standard node material
+ * picks up the grid automatically (same role as the WebGL `lights_fragment_begin`
+ * integration).
+ *
+ * @private
+ * @augments AnalyticLightNode
+ */
+class LightProbeGridNode extends AnalyticLightNode {
+
+	static get type() {
+
+		return 'LightProbeGridNode';
+
+	}
+
+	constructor( light = null ) {
+
+		super( light );
+
+		// Bounce grid intensity changes between bake passes within a frame.
+
+		this._min = uniform( new Vector3() );
+		this._max = uniform( new Vector3() );
+		this._resolution = uniform( new Vector3() );
+		this._intensity = uniform( 1 ).setGroup( renderGroup );
+		this._priority = uniform( 0 ).setGroup( renderGroup );
+
+		this.updateType = NodeUpdateType.RENDER;
+
+	}
+
+	update( /* frame */ ) {
+
+		const light = this.light;
+
+		this._min.value.copy( light.boundingBox.min );
+		this._max.value.copy( light.boundingBox.max );
+		this._resolution.value.copy( light.resolution );
+		this._intensity.value = light.intensity;
+		this._priority.value = light.priority;
+
+	}
+
+	setup( builder ) {
+
+		const light = this.light;
+
+		const min = this._min;
+		const max = this._max;
+		const res = this._resolution;
+
+		const spacing = max.sub( min ).div( res );
+		const samplePos = positionWorld.add( normalWorld.mul( spacing ).mul( 0.5 ) );
+
+		// Grow the bounds by 1% of a cell, so fragments on the bounds aren't left out by
+		// precision errors or samples outside of the triangle.
+
+		const margin = spacing.mul( 0.01 );
+		const inside = samplePos.greaterThanEqual( min.sub( margin ) ).all().and( samplePos.lessThanEqual( max.add( margin ) ).all() );
+
+		builder.context.lightProbeIrradiance ||= vec3().toVar( 'lightProbeIrradiance' );
+		builder.context.lightProbePriority ||= INFINITY.negate().toVar( 'lightProbePriority' );
+
+		const prioritized = this._priority.greaterThanEqual( builder.context.lightProbePriority );
+
+		If( inside.and( prioritized ), () => {
+
+			const irradiance = getGridIrradiance( light, min, max, res, this._intensity, positionWorld, normalWorld ).toConst();
+
+			// fragments can be located in multiple grids but only the one with the highest priority defines the irradiance,
+			// on ties the most recently created grid wins, see #34798
+
+			builder.context.lightProbeIrradiance.assign( irradiance );
+			builder.context.lightProbePriority.assign( this._priority );
+
+		} );
+
+	}
+
+}
+
+export { LightProbeGridNode };

package/Resources/WebLibraries/three/addons/tsl/lighting/data/AmbientLightDataNode.js

@@ -0,0 +1,67 @@
+import { Color, Node } from 'three/webgpu';
+import { NodeUpdateType, renderGroup, uniform } from 'three/tsl';
+
+/**
+ * Batched data node for ambient lights in dynamic lighting mode.
+ *
+ * @augments Node
+ */
+class AmbientLightDataNode extends Node {
+
+	static get type() {
+
+		return 'AmbientLightDataNode';
+
+	}
+
+	constructor() {
+
+		super();
+
+		this._color = new Color();
+		this._lights = [];
+
+		this.colorNode = uniform( this._color ).setGroup( renderGroup );
+		this.updateType = NodeUpdateType.RENDER;
+
+	}
+
+	isCacheable( /*builder*/ ) {
+
+		return false;
+
+	}
+
+	setLights( lights ) {
+
+		this._lights = lights;
+
+		return this;
+
+	}
+
+	update() {
+
+		this._color.setScalar( 0 );
+
+		for ( let i = 0; i < this._lights.length; i ++ ) {
+
+			const light = this._lights[ i ];
+
+			this._color.r += light.color.r * light.intensity;
+			this._color.g += light.color.g * light.intensity;
+			this._color.b += light.color.b * light.intensity;
+
+		}
+
+	}
+
+	setup( builder ) {
+
+		builder.context.irradiance.addAssign( this.colorNode );
+
+	}
+
+}
+
+export default AmbientLightDataNode;

package/Resources/WebLibraries/three/addons/tsl/lighting/data/DirectionalLightDataNode.js

@@ -0,0 +1,117 @@
+import { Color, Node, Vector3 } from 'three/webgpu';
+import { Loop, NodeUpdateType, renderGroup, uniform, uniformArray, vec3 } from 'three/tsl';
+
+const _lightPosition = /*@__PURE__*/ new Vector3();
+const _targetPosition = /*@__PURE__*/ new Vector3();
+
+const warn = ( message ) => {
+
+	console.warn( `THREE.DirectionalLightDataNode: ${ message }` );
+
+};
+
+/**
+ * Batched data node for directional lights in dynamic lighting mode.
+ *
+ * @augments Node
+ */
+class DirectionalLightDataNode extends Node {
+
+	static get type() {
+
+		return 'DirectionalLightDataNode';
+
+	}
+
+	constructor( maxCount = 8 ) {
+
+		super();
+
+		this.maxCount = maxCount;
+		this._lights = [];
+		this._colors = [];
+		this._directions = [];
+
+		for ( let i = 0; i < maxCount; i ++ ) {
+
+			this._colors.push( new Color() );
+			this._directions.push( new Vector3() );
+
+		}
+
+		this.colorsNode = uniformArray( this._colors, 'color' ).setGroup( renderGroup );
+		this.directionsNode = uniformArray( this._directions, 'vec3' ).setGroup( renderGroup );
+		this.countNode = uniform( 0, 'int' ).setGroup( renderGroup );
+		this.updateType = NodeUpdateType.RENDER;
+
+	}
+
+	isCacheable( /*builder*/ ) {
+
+		return false;
+
+	}
+
+	setLights( lights ) {
+
+		if ( lights.length > this.maxCount ) {
+
+			warn( `${ lights.length } lights exceed the configured max of ${ this.maxCount }. Excess lights are ignored.` );
+
+		}
+
+		this._lights = lights;
+
+		return this;
+
+	}
+
+	update( { camera } ) {
+
+		const count = Math.min( this._lights.length, this.maxCount );
+
+		this.countNode.value = count;
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			const light = this._lights[ i ];
+
+			this._colors[ i ].copy( light.color ).multiplyScalar( light.intensity );
+
+			_lightPosition.setFromMatrixPosition( light.matrixWorld );
+			_targetPosition.setFromMatrixPosition( light.target.matrixWorld );
+
+			this._directions[ i ].subVectors( _lightPosition, _targetPosition ).transformDirection( camera.matrixWorldInverse );
+
+		}
+
+	}
+
+	setup( builder ) {
+
+		const { lightingModel, reflectedLight } = builder.context;
+		const dynDiffuse = vec3( 0 ).toVar( 'dynDirectionalDiffuse' );
+		const dynSpecular = vec3( 0 ).toVar( 'dynDirectionalSpecular' );
+
+		Loop( this.countNode, ( { i } ) => {
+
+			const lightColor = this.colorsNode.element( i ).toVar();
+			const lightDirection = this.directionsNode.element( i ).normalize().toVar();
+
+			lightingModel.direct( {
+				lightDirection,
+				lightColor,
+				lightNode: { light: {}, shadowNode: null },
+				reflectedLight: { directDiffuse: dynDiffuse, directSpecular: dynSpecular }
+			}, builder );
+
+		} );
+
+		reflectedLight.directDiffuse.addAssign( dynDiffuse );
+		reflectedLight.directSpecular.addAssign( dynSpecular );
+
+	}
+
+}
+
+export default DirectionalLightDataNode;

package/Resources/WebLibraries/three/addons/tsl/lighting/data/HemisphereLightDataNode.js

@@ -0,0 +1,105 @@
+import { Color, Node, Vector3 } from 'three/webgpu';
+import { Loop, NodeUpdateType, mix, normalWorld, renderGroup, uniform, uniformArray } from 'three/tsl';
+
+const warn = ( message ) => {
+
+	console.warn( `THREE.HemisphereLightDataNode: ${ message }` );
+
+};
+
+/**
+ * Batched data node for hemisphere lights in dynamic lighting mode.
+ *
+ * @augments Node
+ */
+class HemisphereLightDataNode extends Node {
+
+	static get type() {
+
+		return 'HemisphereLightDataNode';
+
+	}
+
+	constructor( maxCount = 4 ) {
+
+		super();
+
+		this.maxCount = maxCount;
+		this._lights = [];
+		this._skyColors = [];
+		this._groundColors = [];
+		this._directions = [];
+
+		for ( let i = 0; i < maxCount; i ++ ) {
+
+			this._skyColors.push( new Color() );
+			this._groundColors.push( new Color() );
+			this._directions.push( new Vector3() );
+
+		}
+
+		this.skyColorsNode = uniformArray( this._skyColors, 'color' ).setGroup( renderGroup );
+		this.groundColorsNode = uniformArray( this._groundColors, 'color' ).setGroup( renderGroup );
+		this.directionsNode = uniformArray( this._directions, 'vec3' ).setGroup( renderGroup );
+		this.countNode = uniform( 0, 'int' ).setGroup( renderGroup );
+		this.updateType = NodeUpdateType.RENDER;
+
+	}
+
+	isCacheable( /*builder*/ ) {
+
+		return false;
+
+	}
+
+	setLights( lights ) {
+
+		if ( lights.length > this.maxCount ) {
+
+			warn( `${ lights.length } lights exceed the configured max of ${ this.maxCount }. Excess lights are ignored.` );
+
+		}
+
+		this._lights = lights;
+
+		return this;
+
+	}
+
+	update() {
+
+		const count = Math.min( this._lights.length, this.maxCount );
+
+		this.countNode.value = count;
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			const light = this._lights[ i ];
+
+			this._skyColors[ i ].copy( light.color ).multiplyScalar( light.intensity );
+			this._groundColors[ i ].copy( light.groundColor ).multiplyScalar( light.intensity );
+			this._directions[ i ].setFromMatrixPosition( light.matrixWorld ).normalize();
+
+		}
+
+	}
+
+	setup( builder ) {
+
+		Loop( this.countNode, ( { i } ) => {
+
+			const skyColor = this.skyColorsNode.element( i );
+			const groundColor = this.groundColorsNode.element( i );
+			const lightDirection = this.directionsNode.element( i );
+			const hemiDiffuseWeight = normalWorld.dot( lightDirection ).mul( 0.5 ).add( 0.5 );
+			const irradiance = mix( groundColor, skyColor, hemiDiffuseWeight );
+
+			builder.context.irradiance.addAssign( irradiance );
+
+		} );
+
+	}
+
+}
+
+export default HemisphereLightDataNode;