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

package/Resources/WebLibraries/three/addons/tsl/shadows/TileShadowNodeHelper.js

@@ -0,0 +1,212 @@
+import { Group, NodeMaterial, Mesh, PlaneGeometry, DoubleSide, CameraHelper } from 'three/webgpu';
+import { Fn, vec4, vec3, texture, uv, positionLocal, vec2, float, int, screenSize } from 'three/tsl';
+
+/**
+ * Helper class to manage and display debug visuals for TileShadowNode.
+ *
+ * @augments Group
+ * @three_import import { TileShadowNodeHelper } from 'three/addons/tsl/shadows/TileShadowNodeHelper.js';
+ */
+class TileShadowNodeHelper extends Group {
+
+	/**
+	 * @param {TileShadowNode} tileShadowNode The TileShadowNode instance to debug.
+	 */
+	constructor( tileShadowNode ) {
+
+		super();
+
+		if ( ! tileShadowNode ) {
+
+			throw new Error( 'THREE.TileShadowNode instance is required for TileShadowNodeHelper.' );
+
+		}
+
+		this.tileShadowNode = tileShadowNode;
+		this.config = tileShadowNode.config;
+		this.tiles = tileShadowNode.tiles;
+		this._debugMeshes = [];
+		this._shadowCamHelpers = [];
+
+		this.initialized = false;
+
+	}
+
+	/**
+	 * Initializes the debug displays (planes and camera helpers).
+	 * Should be called after TileShadowNode has initialized its lights and shadow nodes.
+	 */
+	init() {
+
+		if ( this.tileShadowNode._shadowNodes.length !== this.tiles.length ) {
+
+			console.error( 'Cannot initialize TileShadowNodeHelper: Shadow nodes not ready or mismatch count.' );
+			return;
+
+		}
+
+		const tilesX = this.config.tilesX;
+		const tilesY = this.config.tilesY;
+
+		// Clear previous helpers if any (e.g., during a re-init)
+		this.dispose();
+
+		// Create a display for each shadow map tile
+		for ( let i = 0; i < this.tiles.length; i ++ ) {
+
+			// Create display plane
+			const display = new Mesh( new PlaneGeometry( 1, 1 ), new NodeMaterial() );
+			display.renderOrder = 9999999; // Ensure they appear on top
+			display.material.transparent = true;
+			display.frustumCulled = false;
+			display.side = DoubleSide;
+			display.material.depthTest = false; // Disable depth testing
+			display.material.depthWrite = false; // Disable depth writing
+
+			const col = i % tilesX;
+			const row = Math.floor( i / tilesX );
+
+			// Vertex shader logic for positioning the debug quad
+			display.material.vertexNode = Fn( () => {
+
+				const aspectRatio = screenSize.x.div( screenSize.y );
+				const maxTiles = Math.max( tilesX, tilesY );
+				const displaySize = float( 0.8 / maxTiles ); // Size adapts to number of tiles
+				const margin = float( 0.01 );
+				const cornerOffset = float( 0.05 );
+
+				// Position tiles left-to-right, top-to-bottom
+				const xBase = float( - 1.0 ).add( cornerOffset ).add(
+					displaySize.div( 2 ).div( aspectRatio )
+				).add( float( col ).mul( displaySize.div( aspectRatio ).add( margin ) ) );
+
+				const yBase = float( 1.0 ).sub( cornerOffset ).sub(
+					displaySize.div( 2 )
+				).sub( float( row ).mul( displaySize.add( margin ) ) );
+
+				const scaledPos = vec2(
+					positionLocal.x.mul( displaySize.div( aspectRatio ) ),
+					positionLocal.y.mul( displaySize )
+				);
+
+				const finalPos = vec2(
+					scaledPos.x.add( xBase ),
+					scaledPos.y.add( yBase )
+				);
+
+				return vec4( finalPos.x, finalPos.y, 0.0, 1.0 );
+
+			} )();
+
+			display.material.outputNode = Fn( () => {
+
+				// Ensure shadowMap and depthTexture are available
+				if ( ! this.tileShadowNode.shadowMap || ! this.tileShadowNode.shadowMap.depthTexture ) {
+
+					return vec4( 1, 0, 1, 1 ); // Magenta error color
+
+				}
+
+				const sampledDepth = texture( this.tileShadowNode.shadowMap.depthTexture )
+					.sample( uv().flipY() )
+					.depth( int( i ) ) // Sample correct layer
+					.compare( 0.9 ); // Example comparison value
+
+				// Simple tint based on index for visual distinction
+				const r = float( 0.5 + ( i % 3 ) * 0.16 );
+				const g = float( 0.5 + ( i % 2 ) * 0.25 );
+				const b = float( 0.7 + ( i % 4 ) * 0.075 );
+
+				return vec4(
+					vec3( r, g, b )
+						.mul( sampledDepth )
+						.saturate()
+						.rgb,
+					1.0
+				);
+
+			} )();
+
+			this.add( display );
+			this._debugMeshes.push( display );
+
+			if ( this.tileShadowNode._shadowNodes[ i ] && this.tileShadowNode._shadowNodes[ i ].shadow ) {
+
+				const camHelper = new CameraHelper( this.tileShadowNode._shadowNodes[ i ].shadow.camera );
+				camHelper.fog = false;
+				this.add( camHelper );
+				this._shadowCamHelpers.push( camHelper );
+
+			} else {
+
+				console.warn( `TileShadowNodeHelper: Could not create CameraHelper for tile index ${i}. Shadow node or camera missing.` );
+				this._shadowCamHelpers.push( null );
+
+			}
+
+		}
+
+		this.initialized = true;
+
+	}
+
+	/**
+	 * Updates the debug visuals (specifically camera helpers).
+	 * Should be called within TileShadowNode's update method.
+	 */
+	update() {
+
+		if ( this.initialized === false ) {
+
+			this.init();
+
+		}
+
+		for ( const helper of this._shadowCamHelpers ) {
+
+			if ( helper ) {
+
+				helper.update(); // Update CameraHelper matrices
+				helper.updateMatrixWorld( true ); // Ensure world matrix is current
+
+			}
+
+		}
+
+	}
+
+	/**
+	 * Removes all debug objects (planes and helpers) from the scene.
+	 */
+	dispose() {
+
+		if ( this.scene ) {
+
+			for ( const mesh of this._debugMeshes ) {
+
+				mesh.geometry.dispose();
+				mesh.material.dispose();
+				this.scene.remove( mesh );
+
+			}
+
+			for ( const helper of this._shadowCamHelpers ) {
+
+				if ( helper ) {
+
+					this.scene.remove( helper );
+
+				}
+
+			}
+
+		}
+
+		this._debugMeshes = [];
+		this._shadowCamHelpers = [];
+
+	}
+
+}
+
+export { TileShadowNodeHelper };

package/Resources/WebLibraries/three/addons/tsl/utils/GroundedSkybox.js

@@ -0,0 +1,62 @@
+import { Fn, If, vec3, float, min, cameraPosition, positionWorld } from 'three/tsl';
+
+/**
+ * @module GroundedSkybox
+ * @three_import import { getGroundProjectedNormal } from 'three/addons/tsl/utils/GroundedSkybox.js';
+ */
+
+/**
+ * Projects the world position onto a sphere whose bottom is clipped by a ground disk,
+ * then returns a vector usable for sampling an environment cube map.
+ *
+ * @tsl
+ * @function
+ * @param {Node<float>} radiusNode - The radius of the projection sphere. Must be large enough to ensure the scene's camera stays inside.
+ * @param {Node<float>} heightNode - The height is how far the camera that took the photo was above the ground. A larger value will magnify the downward part of the image.
+ * @return {Node<vec3>} A direction vector for sampling the environment cube map.
+ */
+export const getGroundProjectedNormal = Fn( ( [ radiusNode, heightNode ] ) => {
+
+	const p = positionWorld.sub( cameraPosition ).normalize().toConst();
+	const camPos = cameraPosition.toVar();
+	camPos.y.subAssign( heightNode );
+
+	// sphereIntersect( camPos, p, vec3( 0 ), radius )
+	const b = camPos.dot( p ).toConst();
+	const c = camPos.dot( camPos ).sub( radiusNode.mul( radiusNode ) ).toConst();
+	const h = b.mul( b ).sub( c ).toConst();
+
+	const intersection = h.greaterThanEqual( 0 ).select( h.sqrt().sub( b ), - 1 );
+
+	const projected = vec3( 0, 1, 0 ).toVar();
+
+	If( intersection.greaterThan( 0 ), () => {
+
+		// diskIntersectWithBackFaceCulling( camPos, p, diskCenter, n, radius )
+		const diskCenter = vec3( 0, heightNode.negate(), 0 ).toConst();
+		const n = vec3( 0, 1, 0 ).toConst();
+		const d = p.dot( n ).toConst();
+
+		const intersection2 = float( 1e6 ).toVar();
+
+		If( d.lessThanEqual( 0 ), () => {
+
+			const o = camPos.sub( diskCenter ).toConst();
+			const t = n.dot( o ).negate().div( d ).toConst();
+			const q = o.add( p.mul( t ) ).toConst();
+
+			If( q.dot( q ).lessThan( radiusNode.mul( radiusNode ) ), () => {
+
+				intersection2.assign( t );
+
+			} );
+
+		} );
+
+		projected.assign( camPos.add( p.mul( min( intersection, intersection2 ) ) ).div( radiusNode ) );
+
+	} );
+
+	return projected;
+
+} );

package/Resources/WebLibraries/three/addons/tsl/utils/RNoise.js

@@ -0,0 +1,51 @@
+import { float, Fn, fract, int, vec2, vec4 } from 'three/tsl';
+
+/**
+ * Returns a TSL function that samples texture-free analytic R² noise.
+ * Index 0 uses continuous screen pixels; other indices tile-shift with an R²
+ * sequence into a 64×64 period. Values are four independent R² dimensions
+ * hashed from the sample coordinates.
+ *
+ * @param {UniformNode<Vector2>} resolution
+ * @param {number} [seed=0] - Added to the coordinate hash so each pass gets an independent R² phase.
+ */
+export function bindAnalyticNoise( resolution, seed = 0 ) {
+
+	const seedOffset = int( seed );
+
+	const r4 = ( coords ) => {
+
+		const P = 1.32471795724474602596;
+
+		const t = coords.x.mul( 1 / P ).add( coords.y.mul( 1 / P ** 2 ) ).add( float( seed ) );
+
+		return vec4(
+			fract( t.mul( P ).mul( 1 / P ) ),
+			fract( t.mul( P * 2 ).mul( 1 / P ** 2 ) ),
+			fract( t.mul( P * 3 ).mul( 0.4198754210 ) ), // this is not 1 / P ** 3, however this magic constant gives better noise
+			fract( t.mul( P * 4 ).mul( 1 / P ** 3 ) )
+		);
+
+	};
+
+	return Fn( ( [ uvCoord, sampleIndex ] ) => {
+
+		const index = int( sampleIndex ).add( seedOffset );
+		const noise = vec4().toVar();
+
+		const tileSize = float( 32 );
+
+		const screenPixel = uvCoord.mul( resolution ).floor();
+		const offset = fract( vec2(
+			float( index ).mul( 0.7548776662 ),
+			float( index ).mul( 0.5698402910 )
+		) ).mul( tileSize ).floor();
+		const coords = screenPixel.add( offset ).mod( tileSize );
+
+		noise.assign( r4( coords ) );
+
+		return noise;
+
+	} );
+
+}

package/Resources/WebLibraries/three/addons/tsl/utils/Raymarching.js

@@ -0,0 +1,70 @@
+import { varying, vec4, modelWorldMatrixInverse, cameraPosition, positionGeometry, float, Fn, Loop, max, min, vec2, vec3 } from 'three/tsl';
+
+/**
+ * @module Raymarching
+ * @three_import import { RaymarchingBox } from 'three/addons/tsl/utils/Raymarching.js';
+ */
+
+const hitBox = /*@__PURE__*/ Fn( ( { orig, dir } ) => {
+
+	const box_min = vec3( - 0.5 );
+	const box_max = vec3( 0.5 );
+
+	const inv_dir = dir.reciprocal();
+
+	const tmin_tmp = box_min.sub( orig ).mul( inv_dir );
+	const tmax_tmp = box_max.sub( orig ).mul( inv_dir );
+
+	const tmin = min( tmin_tmp, tmax_tmp );
+	const tmax = max( tmin_tmp, tmax_tmp );
+
+	const t0 = max( tmin.x, max( tmin.y, tmin.z ) );
+	const t1 = min( tmax.x, min( tmax.y, tmax.z ) );
+
+	return vec2( t0, t1 );
+
+}, { orig: 'vec3', dir: 'vec3', return: 'vec2' } );
+
+/**
+ * TSL function for performing raymarching in a box-area using the specified number of steps
+ * and a callback function.
+ *
+ * ```js
+ * RaymarchingBox( count, ( { positionRay } ) => {
+ *
+ * } );
+ * ```
+ *
+ * @tsl
+ * @function
+ * @param {number|Node} steps - The number of steps for raymarching.
+ * @param {Function|FunctionNode} callback - The callback function to execute at each step.
+ */
+export const RaymarchingBox = ( steps, callback ) => {
+
+	const vOrigin = varying( vec3( modelWorldMatrixInverse.mul( vec4( cameraPosition, 1.0 ) ) ) );
+	const vDirection = varying( positionGeometry.sub( vOrigin ) );
+
+	const rayDir = vDirection.normalize();
+	const bounds = vec2( hitBox( { orig: vOrigin, dir: rayDir } ) ).toVar();
+
+	bounds.x.greaterThan( bounds.y ).discard();
+
+	bounds.assign( vec2( max( bounds.x, 0.0 ), bounds.y ) );
+
+	const inc = vec3( rayDir.abs().reciprocal() ).toVar();
+	const stepSize = float( min( inc.x, min( inc.y, inc.z ) ) ).toVar();
+
+	stepSize.divAssign( float( steps ) );
+
+	const positionRay = vec3( vOrigin.add( bounds.x.mul( rayDir ) ) ).toVar();
+
+	Loop( { type: 'float', start: bounds.x, end: bounds.y, update: stepSize }, () => {
+
+		callback( { positionRay, stepSize } );
+
+		positionRay.addAssign( rayDir.mul( stepSize ) );
+
+	} );
+
+};

package/Resources/WebLibraries/three/addons/tsl/utils/SoftParticles.js

@@ -0,0 +1,53 @@
+import { Fn, float, positionView, viewportDepthTexture, perspectiveDepthToViewZ, cameraNear, cameraFar } from 'three/tsl';
+
+/**
+ * @module SoftParticles
+ * @three_import import { softParticles } from 'three/addons/tsl/utils/SoftParticles.js';
+ */
+
+/**
+ * A symmetric contrast curve, as described in the "Soft Particles" white paper
+ * (NVIDIA, Tristan Lorach).
+ *
+ * @tsl
+ * @function
+ * @private
+ * @param {Node<float>} value - The value to remap, expected in the `[0, 1]` range.
+ * @param {Node<float>} power - The contrast power. `1` is linear, higher values sharpen the transition.
+ * @return {Node<float>} The remapped value.
+ */
+const contrastCurve = /*@__PURE__*/ Fn( ( [ value, power ] ) => {
+
+	const aboveHalf = value.greaterThan( 0.5 ).toConst();
+	const folded = aboveHalf.select( value.oneMinus(), value ).toConst();
+	const output = folded.mul( 2 ).saturate().pow( power ).mul( 0.5 ).toConst();
+
+	return aboveHalf.select( output.oneMinus(), output );
+
+}, { value: 'float', power: 'float', return: 'float' } );
+
+/**
+ * Computes an opacity node for soft particles, based on the "Soft Particles" white
+ * paper (NVIDIA, Tristan Lorach).
+ *
+ * @tsl
+ * @function
+ * @param {Object} [parameters={}] - The configuration parameters.
+ * @param {Node<float>} [parameters.opacity=float(1)] - The sprite's base opacity, which the soft fade is multiplied with.
+ * @param {Node<float>|number} [parameters.distance=1] - The world-space distance over which the sprite fades out against the scene.
+ * @param {Node<float>|number} [parameters.contrast=2] - The contrast power of the fade curve. `1` is linear, higher values sharpen the transition.
+ * @param {Node<float>} [parameters.viewportDepth=viewportDepthTexture()] - The opaque scene depth the particles fade against.
+ * @return {Node<float>} The opacity node to assign to `material.opacityNode`.
+ */
+export function softParticles( { opacity = float( 1 ), distance = 1, contrast = 2, viewportDepth = viewportDepthTexture() } = {} ) {
+
+	// Read the opaque scene depth captured before the particle pass and convert both
+	// the scene depth and the particle's depth to view space, so the gap between them
+	// can be measured in world units.
+	const sceneViewZ = perspectiveDepthToViewZ( viewportDepth, cameraNear, cameraFar ).toConst();
+	const depthDelta = positionView.z.sub( sceneViewZ ).div( distance ).saturate();
+
+	// Fade out as the particle approaches the scene; stay opaque when well in front of it.
+	return opacity.mul( contrastCurve( depthDelta, contrast ) );
+
+}