@lampdotdev/lamp 0.0.0-stage → 0.35.0

package/Resources/WebLibraries/three/addons/helpers/LightProbeGridHelperWebGL.js

@@ -0,0 +1,221 @@
+import {
+	InstancedBufferAttribute,
+	InstancedMesh,
+	Matrix4,
+	ShaderMaterial,
+	SphereGeometry,
+	Vector3
+} from 'three';
+
+/**
+ * Visualizes an {@link LightProbeGridWebGL} by rendering a sphere at each
+ * probe position, shaded with the probe's L2 spherical harmonics.
+ *
+ * Uses a single `InstancedMesh` draw call for all probes.
+ *
+ * ```js
+ * const helper = new LightProbeGridHelperWebGL( probes );
+ * scene.add( helper );
+ * ```
+ *
+ * @augments InstancedMesh
+ * @three_import import { LightProbeGridHelperWebGL } from 'three/addons/helpers/LightProbeGridHelperWebGL.js';
+ */
+class LightProbeGridHelperWebGL extends InstancedMesh {
+
+	/**
+	 * Constructs a new irradiance probe grid helper.
+	 *
+	 * @param {LightProbeGridWebGL} probes - The probe grid to visualize.
+	 * @param {number} [sphereSize=0.12] - The radius of each probe sphere.
+	 */
+	constructor( probes, sphereSize = 0.12 ) {
+
+		const geometry = new SphereGeometry( sphereSize, 16, 16 );
+
+		const material = new ShaderMaterial( {
+
+			uniforms: {
+
+				probesSH: { value: null },
+				probesResolution: { value: new Vector3() },
+
+			},
+
+			vertexShader: /* glsl */`
+
+				attribute vec3 instanceUVW;
+
+				varying vec3 vWorldNormal;
+				varying vec3 vUVW;
+
+				void main() {
+
+					vUVW = instanceUVW;
+					vWorldNormal = normalize( mat3( modelMatrix ) * normal );
+					gl_Position = projectionMatrix * modelViewMatrix * instanceMatrix * vec4( position, 1.0 );
+
+				}
+
+			`,
+
+			fragmentShader: /* glsl */`
+
+				precision highp sampler3D;
+
+				uniform sampler3D probesSH;
+				uniform vec3 probesResolution;
+
+				varying vec3 vWorldNormal;
+				varying vec3 vUVW;
+
+				void main() {
+
+					// Atlas UV mapping — must match lightprobes_pars_fragment.glsl.js
+					float nz          = probesResolution.z;
+					float paddedSlices = nz + 2.0;
+					float atlasDepth  = 7.0 * paddedSlices;
+					float uvZBase     = vUVW.z * nz + 1.0;
+
+					vec4 s0 = texture( probesSH, vec3( vUVW.xy, ( uvZBase                       ) / atlasDepth ) );
+					vec4 s1 = texture( probesSH, vec3( vUVW.xy, ( uvZBase +       paddedSlices   ) / atlasDepth ) );
+					vec4 s2 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 2.0 * paddedSlices   ) / atlasDepth ) );
+					vec4 s3 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 3.0 * paddedSlices   ) / atlasDepth ) );
+					vec4 s4 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 4.0 * paddedSlices   ) / atlasDepth ) );
+					vec4 s5 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 5.0 * paddedSlices   ) / atlasDepth ) );
+					vec4 s6 = texture( probesSH, vec3( vUVW.xy, ( uvZBase + 6.0 * paddedSlices   ) / atlasDepth ) );
+
+					// Unpack 9 vec3 SH L2 coefficients
+
+					vec3 c0 = s0.xyz;
+					vec3 c1 = vec3( s0.w, s1.xy );
+					vec3 c2 = vec3( s1.zw, s2.x );
+					vec3 c3 = s2.yzw;
+					vec3 c4 = s3.xyz;
+					vec3 c5 = vec3( s3.w, s4.xy );
+					vec3 c6 = vec3( s4.zw, s5.x );
+					vec3 c7 = s5.yzw;
+					vec3 c8 = s6.xyz;
+
+					vec3 n = normalize( vWorldNormal );
+
+					float x = n.x, y = n.y, z = n.z;
+
+					// band 0
+					vec3 result = c0 * 0.886227;
+
+					// band 1,
+					result += c1 * 2.0 * 0.511664 * y;
+					result += c2 * 2.0 * 0.511664 * z;
+					result += c3 * 2.0 * 0.511664 * x;
+
+					// band 2,
+					result += c4 * 2.0 * 0.429043 * x * y;
+					result += c5 * 2.0 * 0.429043 * y * z;
+					result += c6 * ( 0.743125 * z * z - 0.247708 );
+					result += c7 * 2.0 * 0.429043 * x * z;
+					result += c8 * 0.429043 * ( x * x - y * y );
+
+					gl_FragColor = vec4( max( result, vec3( 0.0 ) ), 1.0 );
+
+					#include <tonemapping_fragment>
+					#include <colorspace_fragment>
+
+				}
+
+			`
+
+		} );
+
+		const res = probes.resolution;
+		const count = res.x * res.y * res.z;
+
+		super( geometry, material, count );
+
+		/**
+		 * The probe grid to visualize.
+		 *
+		 * @type {LightProbeGridWebGL}
+		 */
+		this.probes = probes;
+
+		this.type = 'LightProbeGridHelperWebGL';
+
+		this.update();
+
+	}
+
+	/**
+	 * Rebuilds instance matrices and UVW attributes from the current probe grid.
+	 * Call this after changing `probes` or after re-baking.
+	 */
+	update() {
+
+		const probes = this.probes;
+		const res = probes.resolution;
+		const count = res.x * res.y * res.z;
+
+		// Resize instance matrix buffer if needed
+
+		if ( this.instanceMatrix.count !== count ) {
+
+			this.instanceMatrix = new InstancedBufferAttribute( new Float32Array( count * 16 ), 16 );
+
+		}
+
+		this.count = count;
+
+		const uvwArray = new Float32Array( count * 3 );
+		const matrix = new Matrix4();
+		const probePos = new Vector3();
+
+		let i = 0;
+
+		for ( let iz = 0; iz < res.z; iz ++ ) {
+
+			for ( let iy = 0; iy < res.y; iy ++ ) {
+
+				for ( let ix = 0; ix < res.x; ix ++ ) {
+
+					// Remap to texel centers (must match lightprobes_pars_fragment.glsl.js)
+					uvwArray[ i * 3 ] = ( ix + 0.5 ) / res.x;
+					uvwArray[ i * 3 + 1 ] = ( iy + 0.5 ) / res.y;
+					uvwArray[ i * 3 + 2 ] = ( iz + 0.5 ) / res.z;
+
+					probes.getProbePosition( ix, iy, iz, probePos );
+					matrix.makeTranslation( probePos.x, probePos.y, probePos.z );
+					this.setMatrixAt( i, matrix );
+
+					i ++;
+
+				}
+
+			}
+
+		}
+
+		this.instanceMatrix.needsUpdate = true;
+
+		this.geometry.setAttribute( 'instanceUVW', new InstancedBufferAttribute( uvwArray, 3 ) );
+
+		// Update texture uniforms
+
+		this.material.uniforms.probesSH.value = probes.texture;
+		this.material.uniforms.probesResolution.value.copy( probes.resolution );
+
+	}
+
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever this instance is no longer used in your app.
+	 */
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+}
+
+export { LightProbeGridHelperWebGL };

package/Resources/WebLibraries/three/addons/helpers/LightProbeHelper.js

@@ -0,0 +1,166 @@
+import {
+	Mesh,
+	ShaderMaterial,
+	SphereGeometry
+} from 'three';
+
+/**
+ * Renders a sphere to visualize a light probe in the scene.
+ *
+ * This helper can only be used with {@link WebGLRenderer}.
+ * When using {@link WebGPURenderer}, import from `LightProbeHelperGPU.js`.
+ *
+ * ```js
+ * const helper = new LightProbeHelper( lightProbe );
+ * scene.add( helper );
+ * ```
+ *
+ * @augments Mesh
+ * @three_import import { LightProbeHelper } from 'three/addons/helpers/LightProbeHelper.js';
+ */
+class LightProbeHelper extends Mesh {
+
+	/**
+	 * Constructs a new light probe helper.
+	 *
+	 * @param {LightProbe} lightProbe - The light probe to visualize.
+	 * @param {number} [size=1] - The size of the helper.
+	 */
+	constructor( lightProbe, size = 1 ) {
+
+		const material = new ShaderMaterial( {
+
+			type: 'LightProbeHelperMaterial',
+
+			uniforms: {
+
+				sh: { value: lightProbe.sh.coefficients }, // by reference
+
+				intensity: { value: lightProbe.intensity }
+
+			},
+
+			vertexShader: /* glsl */`
+
+				varying vec3 vNormal;
+
+				void main() {
+
+					vNormal = normalize( normalMatrix * normal );
+
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}
+
+			`,
+
+			fragmentShader: /* glsl */`
+
+				#define RECIPROCAL_PI 0.318309886
+
+
+				vec3 transformNormalByInverseViewMatrix( in vec3 normal, in mat4 viewMatrix ) {
+
+					// upper-left 3x3 of view matrix is assumed to be orthogonal
+
+					return normalize( ( vec4( normal, 0.0 ) * viewMatrix ).xyz );
+
+				}
+
+				// source: https://graphics.stanford.edu/papers/envmap/envmap.pdf,
+				vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
+
+					// normal is assumed to have unit length,
+
+					float x = normal.x, y = normal.y, z = normal.z;
+
+					// band 0,
+					vec3 result = shCoefficients[ 0 ] * 0.886227;
+
+					// band 1,
+					result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
+					result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
+					result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
+
+					// band 2,
+					result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
+					result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
+					result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
+					result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
+					result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
+					return result;
+
+				}
+
+				uniform vec3 sh[ 9 ]; // sh coefficients
+
+				uniform float intensity; // light probe intensity
+
+				varying vec3 vNormal;
+
+				void main() {
+
+					vec3 normal = normalize( vNormal );
+
+					vec3 worldNormal = transformNormalByInverseViewMatrix( normal, viewMatrix );
+
+					vec3 irradiance = shGetIrradianceAt( worldNormal, sh );
+
+					vec3 outgoingLight = RECIPROCAL_PI * irradiance * intensity;
+
+					gl_FragColor = linearToOutputTexel( vec4( outgoingLight, 1.0 ) );
+
+				}
+
+			`,
+
+		} );
+
+		const geometry = new SphereGeometry( 1, 32, 16 );
+
+		super( geometry, material );
+
+		/**
+		 * The light probe to visualize.
+		 *
+		 * @type {LightProbe}
+		 */
+		this.lightProbe = lightProbe;
+
+		/**
+		 * The size of the helper.
+		 *
+		 * @type {number}
+		 * @default 1
+		 */
+		this.size = size;
+		this.type = 'LightProbeHelper';
+
+		this.onBeforeRender();
+
+	}
+
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever this instance is no longer used in your app.
+	 */
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+	onBeforeRender() {
+
+		this.position.copy( this.lightProbe.position );
+
+		this.scale.set( 1, 1, 1 ).multiplyScalar( this.size );
+
+		this.material.uniforms.intensity.value = this.lightProbe.intensity;
+
+	}
+
+}
+
+export { LightProbeHelper };

package/Resources/WebLibraries/three/addons/helpers/LightProbeHelperGPU.js

@@ -0,0 +1,102 @@
+import {
+	Mesh,
+	NodeMaterial,
+	SphereGeometry
+} from 'three/webgpu';
+import { float, Fn, getShIrradianceAt, normalWorld, uniformArray, uniform, vec4 } from 'three/tsl';
+
+/**
+ * Renders a sphere to visualize a light probe in the scene.
+ *
+ * This helper can only be used with {@link WebGPURenderer}.
+ * When using {@link WebGLRenderer}, import from `LightProbeHelper.js`.
+ *
+ * ```js
+ * const helper = new LightProbeHelper( lightProbe );
+ * scene.add( helper );
+ * ```
+ *
+ * @private
+ * @augments Mesh
+ * @three_import import { LightProbeHelper } from 'three/addons/helpers/LightProbeHelperGPU.js';
+ */
+class LightProbeHelper extends Mesh {
+
+	/**
+	 * Constructs a new light probe helper.
+	 *
+	 * @param {LightProbe} lightProbe - The light probe to visualize.
+	 * @param {number} [size=1] - The size of the helper.
+	 */
+	constructor( lightProbe, size = 1 ) {
+
+		const sh = uniformArray( lightProbe.sh.coefficients );
+		const intensity = uniform( lightProbe.intensity );
+
+		const RECIPROCAL_PI = float( 1 / Math.PI );
+
+		const fragmentNode = Fn( () => {
+
+			const irradiance = getShIrradianceAt( normalWorld, sh );
+
+			const outgoingLight = RECIPROCAL_PI.mul( irradiance ).mul( intensity );
+
+			return vec4( outgoingLight, 1.0 );
+
+		} )();
+
+		const material = new NodeMaterial();
+		material.fragmentNode = fragmentNode;
+
+		const geometry = new SphereGeometry( 1, 32, 16 );
+
+		super( geometry, material );
+
+		/**
+		 * The light probe to visualize.
+		 *
+		 * @type {LightProbe}
+		 */
+		this.lightProbe = lightProbe;
+
+		/**
+		 * The size of the helper.
+		 *
+		 * @type {number}
+		 * @default 1
+		 */
+		this.size = size;
+		this.type = 'LightProbeHelper';
+
+		this._intensity = intensity;
+		this._sh = sh;
+
+		this.onBeforeRender();
+
+	}
+
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever this instance is no longer used in your app.
+	 */
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+	onBeforeRender() {
+
+		this.position.copy( this.lightProbe.position );
+
+		this.scale.set( 1, 1, 1 ).multiplyScalar( this.size );
+
+		this._intensity.value = this.lightProbe.intensity;
+		this._sh.array = this.lightProbe.sh.coefficients;
+
+	}
+
+}
+
+export { LightProbeHelper };

package/Resources/WebLibraries/three/addons/helpers/OctreeHelper.js

@@ -0,0 +1,109 @@
+import {
+	LineSegments,
+	BufferGeometry,
+	Float32BufferAttribute,
+	LineBasicMaterial
+} from 'three';
+
+/**
+ * A helper for visualizing an Octree.
+ *
+ * ```js
+ * const helper = new OctreeHelper( octree );
+ * scene.add( helper );
+ * ```
+ *
+ * @augments LineSegments
+ * @three_import import { OctreeHelper } from 'three/addons/helpers/OctreeHelper.js';
+ */
+class OctreeHelper extends LineSegments {
+
+	/**
+	 * Constructs a new Octree helper.
+	 *
+	 * @param {Octree} octree - The octree to visualize.
+	 * @param {number|Color|string} [color=0xffff00] - The helper's color.
+	 */
+	constructor( octree, color = 0xffff00 ) {
+
+		super( new BufferGeometry(), new LineBasicMaterial( { color: color, toneMapped: false } ) );
+
+		/**
+		 * The octree to visualize.
+		 *
+		 * @type {Octree}
+		 */
+		this.octree = octree;
+
+		/**
+		 * The helper's color.
+		 *
+		 * @type {number|Color|string}
+		 */
+		this.color = color;
+
+		this.type = 'OctreeHelper';
+
+		this.update();
+
+	}
+
+	/**
+	 * Updates the helper. This method must be called whenever the Octree's
+	 * structure is changed.
+	 */
+	update() {
+
+		const vertices = [];
+
+		function traverse( tree ) {
+
+			for ( let i = 0; i < tree.length; i ++ ) {
+
+				const min = tree[ i ].box.min;
+				const max = tree[ i ].box.max;
+
+				vertices.push( max.x, max.y, max.z ); vertices.push( min.x, max.y, max.z ); // 0, 1
+				vertices.push( min.x, max.y, max.z ); vertices.push( min.x, min.y, max.z ); // 1, 2
+				vertices.push( min.x, min.y, max.z ); vertices.push( max.x, min.y, max.z ); // 2, 3
+				vertices.push( max.x, min.y, max.z ); vertices.push( max.x, max.y, max.z ); // 3, 0
+
+				vertices.push( max.x, max.y, min.z ); vertices.push( min.x, max.y, min.z ); // 4, 5
+				vertices.push( min.x, max.y, min.z ); vertices.push( min.x, min.y, min.z ); // 5, 6
+				vertices.push( min.x, min.y, min.z ); vertices.push( max.x, min.y, min.z ); // 6, 7
+				vertices.push( max.x, min.y, min.z ); vertices.push( max.x, max.y, min.z ); // 7, 4
+
+				vertices.push( max.x, max.y, max.z ); vertices.push( max.x, max.y, min.z ); // 0, 4
+				vertices.push( min.x, max.y, max.z ); vertices.push( min.x, max.y, min.z ); // 1, 5
+				vertices.push( min.x, min.y, max.z ); vertices.push( min.x, min.y, min.z ); // 2, 6
+				vertices.push( max.x, min.y, max.z ); vertices.push( max.x, min.y, min.z ); // 3, 7
+
+				traverse( tree[ i ].subTrees );
+
+			}
+
+		}
+
+		traverse( this.octree.subTrees );
+
+		this.geometry.dispose();
+
+		this.geometry = new BufferGeometry();
+		this.geometry.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+
+	}
+
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever this instance is no longer used in your app.
+	 */
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+}
+
+export { OctreeHelper };