@lampdotdev/lamp 0.0.0-stage → 0.35.0

package/Resources/WebLibraries/three/addons/lights/SunShadowNode.js

@@ -0,0 +1,312 @@
+import {
+	Compatibility,
+	DepthTexture,
+	GreaterEqualCompare,
+	LessEqualCompare,
+	LinearFilter,
+	NearestFilter,
+	PCFShadowMap,
+	ShadowNode,
+	Vector2,
+	VSMShadowMap
+} from 'three/webgpu';
+import { Fn, If, float, mix, normalWorld, positionView, reference, renderGroup, shadowPositionWorld, smoothstep, texture, uniform, vec4 } from 'three/tsl';
+
+let _vsmWarned = false;
+
+/**
+ * Represents the cascaded shadow map of a {@link SunLight}.
+ *
+ * The two cascade cameras are fitted by {@link SunLightShadow} and rendered
+ * into the viewports of a single shadow map atlas. Each fragment walks the
+ * cascades back to front, blending across the fade bands between them.
+ *
+ * @augments ShadowNode
+ * @three_import import { sunShadow } from 'three/addons/lights/SunShadowNode.js';
+ */
+class SunShadowNode extends ShadowNode {
+
+	static get type() {
+
+		return 'SunShadowNode';
+
+	}
+
+	/**
+	 * Constructs a new sun shadow node.
+	 *
+	 * @param {SunLight} light - The shadow casting sun light.
+	 * @param {?SunLightShadow} [shadow=null] - An optional sun light shadow.
+	 */
+	constructor( light, shadow = null ) {
+
+		super( light, shadow );
+
+		/**
+		 * The size of the shadow map atlas.
+		 *
+		 * @type {Vector2}
+		 * @private
+		 */
+		this._atlasSize = new Vector2();
+
+		const lightShadow = this.shadow;
+
+		/**
+		 * Shadow filters read their texel offsets from `mapSize`, so they must
+		 * be given the atlas size rather than the cascade map size. This proxy
+		 * stands in for the shadow when the filter function is set up.
+		 *
+		 * @type {Object}
+		 * @private
+		 */
+		this._filterShadow = {
+
+			mapSize: this._atlasSize,
+
+			get radius() {
+
+				return lightShadow.radius;
+
+			}
+
+		};
+
+	}
+
+	/**
+	 * Overwrites the default implementation to size the render target as the cascade atlas.
+	 *
+	 * @param {SunLightShadow} shadow - The light shadow object.
+	 * @param {NodeBuilder} builder - A reference to the current node builder.
+	 * @return {Object} An object containing the shadow map and depth texture.
+	 */
+	setupRenderTarget( shadow, builder ) {
+
+		const frameExtents = shadow.getFrameExtents();
+		const width = shadow.mapSize.width * frameExtents.x;
+		const height = shadow.mapSize.height * frameExtents.y;
+
+		const depthTexture = new DepthTexture( width, height );
+		depthTexture.name = 'SunShadowDepthTexture';
+		depthTexture.compareFunction = builder.renderer.reversedDepthBuffer ? GreaterEqualCompare : LessEqualCompare;
+
+		const shadowMap = builder.createRenderTarget( width, height );
+		shadowMap.texture.name = 'SunShadowMap';
+		shadowMap.texture.type = shadow.mapType;
+		shadowMap.depthTexture = depthTexture;
+
+		return { shadowMap, depthTexture };
+
+	}
+
+	/**
+	 * Builds the per-fragment cascade blending.
+	 *
+	 * @private
+	 * @param {NodeBuilder} builder - A reference to the current node builder.
+	 * @param {Function} filterFn - The shadow filtering function.
+	 * @return {Node<float>} The shadow value node.
+	 */
+	_setupCascades( builder, filterFn ) {
+
+		// Full node updates refresh resized atlas bindings, even for stationary objects.
+
+		builder.observer.hasNode = true;
+
+		const { shadow, shadowMap } = this;
+		const depthTexture = shadowMap.depthTexture;
+
+		const shadowIntensity = reference( 'intensity', 'float', shadow ).setGroup( renderGroup );
+		const normalBias = reference( 'normalBias', 'float', shadow ).setGroup( renderGroup );
+
+		// evaluated outside the cascade branches so nodes shared with the rest of
+		// the shader, like the world normal, are not trapped in a branch scope
+
+		const shadowPosition = vec4( shadowPositionWorld.add( normalWorld.mul( normalBias ) ), 1 ).toVar();
+		const viewDepth = positionView.z.negate().toVar();
+
+		const shadowValue = float( 1 ).toVar( 'shadowValue' );
+
+		// walk the cascades back to front so each fade band can blend with the shadow behind it
+
+		for ( let i = shadow.getViewportCount() - 1; i >= 0; i -- ) {
+
+			const shadowMatrix = uniform( 'mat4' ).setGroup( renderGroup ).onRenderUpdate( () => shadow.getMatrix( i ) );
+
+			// ( begin, end, fade start ) view depths of the cascade
+
+			const cascade = uniform( 'vec4' ).setGroup( renderGroup ).onRenderUpdate( () => shadow._cascadeData[ i ] );
+
+			If( viewDepth.greaterThanEqual( cascade.x ).and( viewDepth.lessThan( cascade.y ) ), () => {
+
+				const shadowCoord = this.setupShadowCoord( builder, shadowMatrix.mul( shadowPosition ) );
+
+				const cascadeShadow = this.setupShadowFilter( builder, {
+					filterFn,
+					shadowTexture: shadowMap.texture,
+					depthTexture,
+					shadowCoord,
+					shadow: this._filterShadow,
+					depthLayer: this.depthLayer
+				} );
+
+				shadowValue.assign( mix( cascadeShadow, shadowValue, smoothstep( cascade.z, cascade.y, viewDepth ) ) );
+
+			} );
+
+		}
+
+		return mix( 1, shadowValue, shadowIntensity );
+
+	}
+
+	/**
+	 * Sets up the atlas render target and shadow output node.
+	 *
+	 * @param {NodeBuilder} builder - A reference to the current node builder.
+	 * @return {Node<float>} The shadow output node.
+	 */
+	setupShadow( builder ) {
+
+		const { renderer, camera } = builder;
+		const { light, shadow } = this;
+
+		let shadowMapType = renderer.shadowMap.type;
+
+		if ( shadowMapType === VSMShadowMap ) {
+
+			// the cascade atlas cannot be blurred as one map
+
+			if ( _vsmWarned === false ) {
+
+				console.warn( 'THREE.SunShadowNode: VSM is not supported, falling back to PCF.' );
+				_vsmWarned = true;
+
+			}
+
+			shadowMapType = PCFShadowMap;
+
+		}
+
+		const filterFn = shadow.filterNode || this.getShadowFilterFn( shadowMapType ) || null;
+
+		if ( filterFn === null ) {
+
+			throw new Error( 'THREE.SunShadowNode: Shadow map type not supported.' );
+
+		}
+
+		const { depthTexture, shadowMap } = this.setupRenderTarget( shadow, builder );
+		const hasTextureCompare = renderer.hasCompatibility( Compatibility.TEXTURE_COMPARE );
+
+		if ( shadowMapType === PCFShadowMap && hasTextureCompare ) {
+
+			depthTexture.minFilter = LinearFilter;
+			depthTexture.magFilter = LinearFilter;
+
+		} else {
+
+			depthTexture.minFilter = NearestFilter;
+			depthTexture.magFilter = NearestFilter;
+
+		}
+
+		this.shadowMap = shadowMap;
+		shadow.map = shadowMap;
+
+		this._atlasSize.set( shadowMap.width, shadowMap.height );
+
+		// the cascade cameras inherit the coordinate system and depth mode from the shadow camera
+
+		shadow.camera.coordinateSystem = camera.coordinateSystem;
+		shadow.camera._reversedDepth = renderer.reversedDepthBuffer;
+
+		// rebuild the cascade statements for each shader so their variables
+		// and branches belong to that shader's scope
+
+		const node = Fn( ( builder ) => this._setupCascades( builder, filterFn ) )().toVar();
+
+		const inspectName = `${ light.type } Shadow [ ${ light.name || 'ID: ' + light.id } ]`;
+
+		// the cascade cameras are orthographic, so the stored depth is linear already
+
+		return node.toInspector( `${ inspectName } / Depth`, () => texture( depthTexture ).r.oneMinus() );
+
+	}
+
+	/**
+	 * Renders the two cascades into the viewports of the shadow map atlas.
+	 *
+	 * @param {NodeFrame} frame - A reference to the current node frame.
+	 */
+	renderShadow( frame ) {
+
+		const { shadow, shadowMap, light } = this;
+		const { renderer, scene, camera } = frame;
+
+		shadow.updateMatrices( light, camera );
+
+		const tileWidth = shadow.mapSize.width;
+		const tileHeight = shadow.mapSize.height;
+		const frameExtents = shadow.getFrameExtents();
+		const width = tileWidth * frameExtents.x;
+		const height = tileHeight * frameExtents.y;
+
+		shadowMap.setSize( width, height );
+		this._atlasSize.set( width, height );
+
+		const currentSceneName = scene.name;
+
+		scene.name = `Shadow Map [ ${ light.name || 'ID: ' + light.id } ]`;
+
+		// clear once, the cascades share the atlas
+
+		renderer.autoClear = false;
+		renderer.clear();
+
+		const cascadeCount = shadow.getViewportCount();
+
+		for ( let i = 0; i < cascadeCount; i ++ ) {
+
+			const viewport = shadow.getViewport( i );
+
+			// viewports are measured from the top: flip the rows so the shadow
+			// matrices, which bake their offsets bottom-up, sample the correct tile
+
+			shadowMap.viewport.set(
+				tileWidth * viewport.x,
+				shadowMap.height - tileHeight * ( viewport.y + viewport.w ),
+				tileWidth * viewport.z,
+				tileHeight * viewport.w
+			);
+
+			renderer.render( scene, shadow.getCamera( i ) );
+
+		}
+
+		scene.name = currentSceneName;
+
+	}
+
+	/**
+	 * Overwritten as a no-op since VSM is not supported for cascaded shadow maps.
+	 *
+	 * @param {Renderer} renderer - A reference to the current renderer.
+	 */
+	vsmPass( /*renderer*/ ) { }
+
+}
+
+export { SunShadowNode };
+
+/**
+ * TSL function for creating an instance of `SunShadowNode`.
+ *
+ * @tsl
+ * @function
+ * @param {SunLight} light - The shadow casting sun light.
+ * @param {?SunLightShadow} [shadow=null] - An optional sun light shadow.
+ * @return {SunShadowNode} The created sun shadow node.
+ */
+export const sunShadow = ( light, shadow ) => new SunShadowNode( light, shadow );

package/Resources/WebLibraries/three/addons/lines/Line2.js

@@ -0,0 +1,56 @@
+import { LineSegments2 } from './LineSegments2.js';
+import { LineGeometry } from './LineGeometry.js';
+import { LineMaterial } from './LineMaterial.js';
+
+/**
+ * A polyline drawn between vertices.
+ *
+ * This adds functionality beyond {@link Line}, like arbitrary line width and changing width to
+ * be in world units.It extends {@link LineSegments2}, simplifying constructing segments from a
+ * chain of points.
+ *
+ * This module can only be used with {@link WebGLRenderer}. When using {@link WebGPURenderer},
+ * import the class from `lines/webgpu/Line2.js`.
+ *
+ * ```js
+ * const geometry = new LineGeometry();
+ * geometry.setPositions( positions );
+ * geometry.setColors( colors );
+ *
+ * const material = new LineMaterial( { linewidth: 5, vertexColors: true } };
+ *
+ * const line = new Line2( geometry, material );
+ * scene.add( line );
+ * ```
+ *
+ * @augments LineSegments2
+ * @three_import import { Line2 } from 'three/addons/lines/Line2.js';
+ */
+class Line2 extends LineSegments2 {
+
+	/**
+	 * Constructs a new wide line.
+	 *
+	 * @param {LineGeometry} [geometry] - The line geometry.
+	 * @param {LineMaterial} [material] - The line material.
+	 */
+	constructor( geometry = new LineGeometry(), material = new LineMaterial( { color: Math.random() * 0xffffff } ) ) {
+
+		super( geometry, material );
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isLine2 = true;
+
+		this.type = 'Line2';
+
+	}
+
+}
+
+export { Line2 };

package/Resources/WebLibraries/three/addons/lines/LineGeometry.js

@@ -0,0 +1,157 @@
+import { LineSegmentsGeometry } from './LineSegmentsGeometry.js';
+
+/**
+ * A chain of vertices, forming a polyline.
+ *
+ * This is used in {@link Line2} to describe the shape.
+ *
+ * ```js
+ * const points = [
+ * 	new THREE.Vector3( - 10, 0, 0 ),
+ * 	new THREE.Vector3( 0, 5, 0 ),
+ * 	new THREE.Vector3( 10, 0, 0 ),
+ * ];
+ *
+ * const geometry = new LineGeometry();
+ * geometry.setFromPoints( points );
+ * ```
+ *
+ * @augments LineSegmentsGeometry
+ * @three_import import { LineLineGeometry2 } from 'three/addons/lines/LineGeometry.js';
+ */
+class LineGeometry extends LineSegmentsGeometry {
+
+	/**
+	 * Constructs a new line geometry.
+	 */
+	constructor() {
+
+		super();
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isLineGeometry = true;
+
+		this.type = 'LineGeometry';
+
+	}
+
+	/**
+	 * Sets the given line positions for this geometry.
+	 *
+	 * @param {Float32Array|Array<number>} array - The position data to set.
+	 * @return {LineGeometry} A reference to this geometry.
+	 */
+	setPositions( array ) {
+
+		// converts [ x1, y1, z1,  x2, y2, z2, ... ] to pairs format
+
+		const length = array.length - 3;
+		const points = new Float32Array( 2 * length );
+
+		for ( let i = 0; i < length; i += 3 ) {
+
+			points[ 2 * i ] = array[ i ];
+			points[ 2 * i + 1 ] = array[ i + 1 ];
+			points[ 2 * i + 2 ] = array[ i + 2 ];
+
+			points[ 2 * i + 3 ] = array[ i + 3 ];
+			points[ 2 * i + 4 ] = array[ i + 4 ];
+			points[ 2 * i + 5 ] = array[ i + 5 ];
+
+		}
+
+		super.setPositions( points );
+
+		return this;
+
+	}
+
+	/**
+	 * Sets the given line colors for this geometry.
+	 *
+	 * @param {Float32Array|Array<number>} array - The position data to set.
+	 * @return {LineGeometry} A reference to this geometry.
+	 */
+	setColors( array ) {
+
+		// converts [ r1, g1, b1,  r2, g2, b2, ... ] to pairs format
+
+		const length = array.length - 3;
+		const colors = new Float32Array( 2 * length );
+
+		for ( let i = 0; i < length; i += 3 ) {
+
+			colors[ 2 * i ] = array[ i ];
+			colors[ 2 * i + 1 ] = array[ i + 1 ];
+			colors[ 2 * i + 2 ] = array[ i + 2 ];
+
+			colors[ 2 * i + 3 ] = array[ i + 3 ];
+			colors[ 2 * i + 4 ] = array[ i + 4 ];
+			colors[ 2 * i + 5 ] = array[ i + 5 ];
+
+		}
+
+		super.setColors( colors );
+
+		return this;
+
+	}
+
+	/**
+	 * Setups this line segments geometry from the given sequence of points.
+	 *
+	 * @param {Array<Vector3|Vector2>} points - An array of points in 2D or 3D space.
+	 * @return {LineGeometry} A reference to this geometry.
+	 */
+	setFromPoints( points ) {
+
+		// converts a vector3 or vector2 array to pairs format
+
+		const length = points.length - 1;
+		const positions = new Float32Array( 6 * length );
+
+		for ( let i = 0; i < length; i ++ ) {
+
+			positions[ 6 * i ] = points[ i ].x;
+			positions[ 6 * i + 1 ] = points[ i ].y;
+			positions[ 6 * i + 2 ] = points[ i ].z || 0;
+
+			positions[ 6 * i + 3 ] = points[ i + 1 ].x;
+			positions[ 6 * i + 4 ] = points[ i + 1 ].y;
+			positions[ 6 * i + 5 ] = points[ i + 1 ].z || 0;
+
+		}
+
+		super.setPositions( positions );
+
+		return this;
+
+	}
+
+	/**
+	 * Setups this line segments geometry from the given line.
+	 *
+	 * @param {Line} line - The line that should be used as a data source for this geometry.
+	 * @return {LineGeometry} A reference to this geometry.
+	 */
+	fromLine( line ) {
+
+		const geometry = line.geometry;
+
+		this.setPositions( geometry.attributes.position.array ); // assumes non-indexed
+
+		// set colors, maybe
+
+		return this;
+
+	}
+
+}
+
+export { LineGeometry };