rayzee 6.0.1 → 6.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "6.0.1",
+  "version": "6.2.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",
@@ -30,7 +30,7 @@
   "author": "Atul Mourya",
   "license": "MIT",
   "scripts": {
-    "build": "vite build",
+    "build": "vite build && node scripts/update-size-badge.mjs",
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {

package/src/EngineDefaults.js

@@ -20,6 +20,9 @@ export const ENGINE_DEFAULTS = {
 	environmentIntensity: 1,
 	backgroundIntensity: 1,
 	environmentRotation: 270.0,
+	groundProjectionEnabled: false,
+	groundProjectionRadius: 100,
+	groundProjectionHeight: 15,
 	globalIlluminationIntensity: 1,
 
 	// Environment Mode System

package/src/PathTracerApp.js

@@ -1,7 +1,7 @@
-import { WebGPURenderer, RectAreaLightNode, LinearSRGBColorSpace, SRGBColorSpace } from 'three/webgpu';
+import { WebGPURenderer, RectAreaLightNode, SRGBColorSpace } from 'three/webgpu';
 import { texture as _tslTexture, cubeTexture as _tslCubeTexture } from 'three/tsl';
 import {
-	ACESFilmicToneMapping, Scene, EventDispatcher, TimestampQuery
+	ACESFilmicToneMapping, Scene, EventDispatcher
 } from 'three';
 import { RectAreaLightTexturesLib } from 'three/addons/lights/RectAreaLightTexturesLib.js';
 import { SceneHelpers } from './SceneHelpers.js';
@@ -30,6 +30,8 @@ import { SceneProcessor } from './Processor/SceneProcessor.js';
 import { RenderSettings } from './RenderSettings.js';
 import { CameraManager } from './managers/CameraManager.js';
 import { LightManager } from './managers/LightManager.js';
+import { GoboManager } from './managers/GoboManager.js';
+import { IESManager } from './managers/IESManager.js';
 import { DenoisingManager } from './managers/DenoisingManager.js';
 import { OverlayManager } from './managers/OverlayManager.js';
 import { AnimationManager } from './managers/AnimationManager.js';
@@ -118,6 +120,10 @@ export class PathTracerApp extends EventDispatcher {
 		this.cameraManager = null;
 		/** @type {LightManager} */
 		this.lightManager = null;
+		/** @type {GoboManager} */
+		this.goboManager = null;
+		/** @type {IESManager} */
+		this.iesManager = null;
 		/** @type {DenoisingManager} */
 		this.denoisingManager = null;
 		/** @type {OverlayManager} */
@@ -331,9 +337,6 @@ export class PathTracerApp extends EventDispatcher {
 		this._renderHelperOverlay();
 		this.dispatchEvent( { type: EngineEvents.FRAME } );
 
-		this.renderer.resolveTimestampsAsync?.( TimestampQuery.RENDER );
-		this.renderer.resolveTimestampsAsync?.( TimestampQuery.COMPUTE );
-
 	}
 
 	/**
@@ -427,6 +430,8 @@ export class PathTracerApp extends EventDispatcher {
 		this.transformManager?.dispose();
 		this.overlayManager?.dispose();
 		this.lightManager?.dispose();
+		this.goboManager?.dispose();
+		this.iesManager?.dispose();
 		this.denoisingManager?.dispose();
 		this.interactionManager?.dispose();
 		this.cameraManager?.dispose();
@@ -1208,7 +1213,6 @@ export class PathTracerApp extends EventDispatcher {
 
 		RectAreaLightNode.setLTC( RectAreaLightTexturesLib.init() );
 
-		this.renderer.workingColorSpace = SRGBColorSpace;
 		this.renderer.outputColorSpace = SRGBColorSpace;
 		this.renderer.toneMapping = ACESFilmicToneMapping;
 		this.renderer.toneMappingExposure = 1.0;
@@ -1288,6 +1292,12 @@ export class PathTracerApp extends EventDispatcher {
 		this.lightManager = new LightManager( this.scene, this._sceneHelpers, this.stages.pathTracer, {
 			onReset: () => this.reset(),
 		} );
+		this.goboManager = new GoboManager( this.stages.pathTracer, {
+			onReset: () => this.reset(),
+		} );
+		this.iesManager = new IESManager( this.stages.pathTracer, {
+			onReset: () => this.reset(),
+		} );
 		this._setupDenoisingManager();
 		this._setupOverlayManager();
 
@@ -1438,7 +1448,7 @@ export class PathTracerApp extends EventDispatcher {
 		if ( animations.length > 0 ) {
 
 			const mixerRoot = this.assetLoader?.targetModel || this.meshScene;
-			this.animationManager.init( this.meshScene, mixerRoot, this._sdf.meshes, animations, this._sdf.triangleCount );
+			this.animationManager.init( this.meshScene, mixerRoot, this._sdf.meshes, animations );
 			this.animationManager.onFinished = () => {
 
 				this._animRefitInFlight = false;
@@ -1448,7 +1458,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
-		this.transformManager?.setMeshData( this._sdf.meshes, this._sdf.triangleCount );
+		this.transformManager?.setMeshData( this._sdf.meshes );
 
 	}
 

package/src/Pipeline/RenderStage.js

@@ -188,6 +188,7 @@ export class RenderStage {
 	 * @param {PipelineContext} context - Shared pipeline context
 	 * @returns {boolean} True if stage should execute
 	 */
+	// eslint-disable-next-line no-unused-vars
 	shouldExecute( context ) {
 
 		// Default: always execute
@@ -203,6 +204,7 @@ export class RenderStage {
 	 * @param {THREE.RenderTarget} [writeBuffer] - Optional output buffer
 	 * @throws {Error} If not implemented
 	 */
+	// eslint-disable-next-line no-unused-vars
 	render( context, writeBuffer ) {
 
 		throw new Error( `render() must be implemented in ${this.name}` );
@@ -223,6 +225,7 @@ export class RenderStage {
 	 * @param {number} width - New width
 	 * @param {number} height - New height
 	 */
+	// eslint-disable-next-line no-unused-vars
 	setSize( width, height ) {
 		// Override if needed
 	}

package/src/Processor/IESParser.js

@@ -0,0 +1,340 @@
+/**
+ * IESParser.js
+ * Parser for IESNA LM-63 photometric data files (.ies).
+ *
+ * Returns the candela grid (one row per vertical angle), the angle lists,
+ * and the peak candela for normalisation.
+ *
+ * Reference: IESNA LM-63-2002 standard.
+ */
+
+/**
+ * @typedef {Object} IESProfile
+ * @property {number[]} verticalAngles    - degrees, length V
+ * @property {number[]} horizontalAngles  - degrees, length H
+ * @property {Float32Array[]} candela     - row-major [V][H], H values per row
+ * @property {number} maxCandela          - peak intensity across the grid
+ * @property {number} lumens              - lumens per lamp
+ * @property {number} photometricType     - 1 = C (most common), 2 = B, 3 = A
+ * @property {string} [name]              - optional source-file basename
+ */
+
+/**
+ * Parses an IES file's text content into a numeric profile.
+ * @param {string} text  - raw .ies file contents
+ * @param {string} [name]  - optional identifier used in error messages
+ * @returns {IESProfile}
+ */
+export function parseIES( text, name = 'ies' ) {
+
+	// Strip the header (everything up to and including the TILT line).
+	const tiltIdx = text.search( /TILT\s*=/i );
+	if ( tiltIdx < 0 ) throw new Error( `IES (${name}): missing TILT line` );
+
+	const headerEnd = text.indexOf( '\n', tiltIdx );
+	if ( headerEnd < 0 ) throw new Error( `IES (${name}): truncated TILT line` );
+
+	const tiltMatch = text.slice( tiltIdx, headerEnd ).match( /TILT\s*=\s*(\w+)/i );
+	const tilt = tiltMatch ? tiltMatch[ 1 ].toUpperCase() : 'NONE';
+
+	let body = text.slice( headerEnd );
+
+	// TILT=INCLUDE has an inline tilt-data block we need to skip. The block has:
+	//   <lampToLuminaireGeometry>
+	//   <numTiltAngles>
+	//   <tiltAngles ...>
+	//   <multipliers ...>
+	if ( tilt === 'INCLUDE' ) {
+
+		const tokens = tokenize( body );
+		// First token = geometry (1, 2, or 3)
+		// Second token = number of pairs
+		const numPairs = Number( tokens[ 1 ] );
+		// Skip: geometry + count + 2 * numPairs values
+		const skip = 2 + 2 * numPairs;
+		body = remainderAfterTokens( body, skip );
+
+	}
+
+	const tokens = tokenize( body );
+	let i = 0;
+	const next = () => Number( tokens[ i ++ ] );
+
+	const lampCount = next();
+	const lumens = next();
+	const multiplier = next();
+	const numVertAngles = next();
+	const numHorizAngles = next();
+	const photometricType = next();
+	/* const unitsType = */ next();
+	/* width   */ next();
+	/* length  */ next();
+	/* height  */ next();
+	const ballastFactor = next();
+	/* futureUse */ next();
+	/* inputWatts */ next();
+
+	if ( ! Number.isFinite( numVertAngles ) || numVertAngles <= 0 ) {
+
+		throw new Error( `IES (${name}): invalid vertical angle count ${numVertAngles}` );
+
+	}
+
+	if ( ! Number.isFinite( numHorizAngles ) || numHorizAngles <= 0 ) {
+
+		throw new Error( `IES (${name}): invalid horizontal angle count ${numHorizAngles}` );
+
+	}
+
+	const verticalAngles = new Array( numVertAngles );
+	for ( let v = 0; v < numVertAngles; v ++ ) verticalAngles[ v ] = next();
+
+	const horizontalAngles = new Array( numHorizAngles );
+	for ( let h = 0; h < numHorizAngles; h ++ ) horizontalAngles[ h ] = next();
+
+	// Candela grid: in LM-63 the order is [horizontal][vertical] — for each
+	// horizontal plane, all vertical samples are listed before the next plane.
+	// We store as candela[v][h] for direct (theta, phi) lookups in the shader.
+	const candela = new Array( numVertAngles );
+	for ( let v = 0; v < numVertAngles; v ++ ) candela[ v ] = new Float32Array( numHorizAngles );
+
+	const scale = multiplier * ballastFactor;
+	let peak = 0;
+
+	for ( let h = 0; h < numHorizAngles; h ++ ) {
+
+		for ( let v = 0; v < numVertAngles; v ++ ) {
+
+			const cd = next() * scale;
+			candela[ v ][ h ] = cd;
+			if ( cd > peak ) peak = cd;
+
+		}
+
+	}
+
+	return {
+		verticalAngles,
+		horizontalAngles,
+		candela,
+		maxCandela: peak,
+		lumens: lumens * lampCount,
+		photometricType,
+		name,
+	};
+
+}
+
+/**
+ * Resample an IESProfile onto a fixed-size 2D grid suitable for a
+ * DataArrayTexture layer. Values are normalised to [0,1] by `maxCandela`
+ * so the shader gets a pure shape multiplier; absolute intensity scaling
+ * stays in `light.intensity`.
+ *
+ * UV convention:
+ *   U = horizontal angle / 360  (0..1)
+ *   V = vertical angle / 180    (0..1, 0 = bulb axis, 1 = opposite axis)
+ *
+ * Profiles that are rotationally symmetric (single horizontal sample, or all
+ * H angles identical) replicate the row across the U axis so the shader can
+ * sample uniformly without a symmetry flag.
+ *
+ * @param {IESProfile} profile
+ * @param {number} width   - texture width in samples (horizontal/U axis)
+ * @param {number} height  - texture height in samples (vertical/V axis)
+ * @returns {Uint8Array}  width*height bytes, R channel only
+ */
+export function resampleIESToGrid( profile, width, height ) {
+
+	const data = new Uint8Array( width * height );
+	const { verticalAngles: vA, horizontalAngles: hA, candela, maxCandela } = profile;
+
+	if ( maxCandela <= 0 ) return data; // dead profile → zeros
+
+	const vMaxDeg = vA[ vA.length - 1 ];
+	const hMaxDeg = hA[ hA.length - 1 ];
+	const hMin = hA[ 0 ];
+	const rotationallySymmetric = hA.length === 1 || hMaxDeg === hMin;
+
+	for ( let py = 0; py < height; py ++ ) {
+
+		// V coordinate → vertical angle in degrees. Texture covers [0, vMaxDeg].
+		const tV = ( py + 0.5 ) / height;
+		const vDeg = tV * vMaxDeg;
+		const v0 = lowerBoundIdx( vA, vDeg );
+		const v1 = Math.min( v0 + 1, vA.length - 1 );
+		const vSpan = vA[ v1 ] - vA[ v0 ];
+		const vt = vSpan > 0 ? ( vDeg - vA[ v0 ] ) / vSpan : 0;
+
+		for ( let px = 0; px < width; px ++ ) {
+
+			let cd;
+
+			if ( rotationallySymmetric ) {
+
+				// Single column → just bilerp on V axis.
+				cd = lerp( candela[ v0 ][ 0 ], candela[ v1 ][ 0 ], vt );
+
+			} else {
+
+				const tH = ( px + 0.5 ) / width;
+				const hDeg = hMin + tH * ( hMaxDeg - hMin );
+				const h0 = lowerBoundIdx( hA, hDeg );
+				const h1 = Math.min( h0 + 1, hA.length - 1 );
+				const hSpan = hA[ h1 ] - hA[ h0 ];
+				const ht = hSpan > 0 ? ( hDeg - hA[ h0 ] ) / hSpan : 0;
+
+				const c00 = candela[ v0 ][ h0 ];
+				const c10 = candela[ v0 ][ h1 ];
+				const c01 = candela[ v1 ][ h0 ];
+				const c11 = candela[ v1 ][ h1 ];
+				cd = lerp( lerp( c00, c10, ht ), lerp( c01, c11, ht ), vt );
+
+			}
+
+			const norm = Math.min( 1, Math.max( 0, cd / maxCandela ) );
+			data[ py * width + px ] = Math.round( norm * 255 );
+
+		}
+
+	}
+
+	return data;
+
+}
+
+/**
+ * Estimate a sensible spot-light cone half-angle from an IES profile.
+ *
+ * Returns the smallest vertical angle (radians) where the average candela
+ * across the horizontal samples drops below `threshold * maxCandela`. The
+ * resulting cone snugly bounds the profile's meaningful emission.
+ *
+ * @param {IESProfile} profile
+ * @param {number} [threshold=0.1] - intensity ratio considered "off"
+ * @returns {number} suggested half-angle in radians, clamped to [5°, 89°]
+ */
+export function deriveIESBeamAngle( profile, threshold = 0.1 ) {
+
+	const { verticalAngles: vA, horizontalAngles: hA, candela, maxCandela } = profile;
+	const fallback = Math.PI / 4;
+	if ( maxCandela <= 0 || ! vA?.length ) return fallback;
+
+	const cutoff = maxCandela * threshold;
+	const hCount = hA.length;
+
+	// Scan from on-axis outward — works correctly for monotonically falling
+	// beams (the common case). For peaks-off-axis profiles (rare) this just
+	// picks the first low-intensity ring outside the centre.
+	let crossingDeg = vA[ vA.length - 1 ];
+	let everAboveCutoff = false;
+	for ( let v = 0; v < vA.length; v ++ ) {
+
+		let avg = 0;
+		for ( let h = 0; h < hCount; h ++ ) avg += candela[ v ][ h ];
+		avg /= hCount;
+
+		if ( avg >= cutoff ) everAboveCutoff = true;
+		if ( everAboveCutoff && avg < cutoff ) {
+
+			crossingDeg = vA[ v ];
+			break;
+
+		}
+
+	}
+
+	const rad = crossingDeg * Math.PI / 180;
+	// Clamp to [5°, 89°] so it stays useful for both very tight and diffuse profiles.
+	return Math.min( Math.max( rad, 5 * Math.PI / 180 ), 89 * Math.PI / 180 );
+
+}
+
+/**
+ * Estimate a sensible penumbra factor [0,1] from an IES profile, matching
+ * the three.js spot-light convention (0 = sharp edge, 1 = entire cone is the
+ * transition band).
+ *
+ * Penumbra = 1 - (innerAngle / outerAngle), where:
+ *   outerAngle = `cutoff * maxCandela` crossing (use the value from deriveIESBeamAngle)
+ *   innerAngle = where the candela average first drops below `peakRatio * maxCandela`
+ *
+ * For tightly-clamped beams (innerAngle ≈ outerAngle) this returns near-zero;
+ * for soft profiles with a long tail it returns a high value.
+ *
+ * @param {IESProfile} profile
+ * @param {number} outerAngleRad - the cone half-angle returned by deriveIESBeamAngle
+ * @param {number} [peakRatio=0.7] - intensity ratio considered "still hot"
+ * @returns {number} penumbra in [0,1]
+ */
+export function deriveIESPenumbra( profile, outerAngleRad, peakRatio = 0.7 ) {
+
+	const { verticalAngles: vA, horizontalAngles: hA, candela, maxCandela } = profile;
+	if ( maxCandela <= 0 || ! vA?.length || outerAngleRad <= 0 ) return 0;
+
+	const hotCutoff = maxCandela * peakRatio;
+	const hCount = hA.length;
+	let innerDeg = 0;
+
+	for ( let v = 0; v < vA.length; v ++ ) {
+
+		let avg = 0;
+		for ( let h = 0; h < hCount; h ++ ) avg += candela[ v ][ h ];
+		avg /= hCount;
+		if ( avg >= hotCutoff ) innerDeg = vA[ v ]; else break;
+
+	}
+
+	const outerDeg = outerAngleRad * 180 / Math.PI;
+	const penumbra = outerDeg > 0 ? 1 - ( innerDeg / outerDeg ) : 0;
+	return Math.min( Math.max( penumbra, 0 ), 1 );
+
+}
+
+// ── helpers ─────────────────────────────────────────────────────────
+
+function tokenize( text ) {
+
+	return text.split( /\s+/ ).filter( s => s.length > 0 );
+
+}
+
+function remainderAfterTokens( text, count ) {
+
+	const re = /\S+/g;
+	let m;
+	let n = 0;
+	while ( ( m = re.exec( text ) ) !== null ) {
+
+		n ++;
+		if ( n === count ) return text.slice( re.lastIndex );
+
+	}
+
+	return '';
+
+}
+
+function lowerBoundIdx( arr, x ) {
+
+	if ( x <= arr[ 0 ] ) return 0;
+	if ( x >= arr[ arr.length - 1 ] ) return arr.length - 1;
+
+	let lo = 0;
+	let hi = arr.length - 1;
+	while ( hi - lo > 1 ) {
+
+		const mid = ( lo + hi ) >> 1;
+		if ( arr[ mid ] <= x ) lo = mid; else hi = mid;
+
+	}
+
+	return lo;
+
+}
+
+function lerp( a, b, t ) {
+
+	return a + ( b - a ) * t;
+
+}

package/src/Processor/LightSerializer.js

@@ -90,13 +90,24 @@ export class LightSerializer {
 		// Get angle parameter from light (default to 0 for sharp shadows)
 		const angle = light.userData.angle || light.angle || 0.0; // In radians
 
+		// Optional projection mask. Sign of intensity carries the inverted flag.
+		const gobo = light.userData?.gobo;
+		const goboIndex = ( gobo && Number.isInteger( gobo.index ) ) ? gobo.index : - 1;
+		const rawIntensity = ( gobo && typeof gobo.intensity === 'number' ) ? gobo.intensity : 1.0;
+		const goboIntensity = ( gobo && gobo.inverted ) ? - Math.abs( rawIntensity ) : Math.abs( rawIntensity );
+		const goboScale = ( gobo && typeof gobo.scale === 'number' ) ? gobo.scale : 5.0;
+
 		// Store in cache with importance
 		this.directionalLightCache.push( {
 			data: [
 				direction.x, direction.y, direction.z, // direction toward light (3)
 				light.color.r, light.color.g, light.color.b, // color (3)
 				light.intensity, // intensity (1)
-				angle // angular diameter in radians (1)
+				angle, // angular diameter in radians (1)
+				goboIndex, // gobo layer index, -1 = none (1)
+				goboIntensity, // signed gobo strength (1)
+				goboScale, // world units per gobo tile (1)
+				0.0, // reserved (1) — padding to keep stride at 12
 			],
 			importance: importance,
 			light: light
@@ -176,6 +187,17 @@ export class LightSerializer {
 		// Calculate importance for sorting
 		const importance = this.calculateLightImportance( light, 'spot' );
 
+		// Optional projection mask ("gobo"). Sign of goboIntensity carries inverted flag.
+		const gobo = light.userData?.gobo;
+		const goboIndex = ( gobo && Number.isInteger( gobo.index ) ) ? gobo.index : - 1;
+		const rawGoboIntensity = ( gobo && typeof gobo.intensity === 'number' ) ? gobo.intensity : 1.0;
+		const goboIntensity = ( gobo && gobo.inverted ) ? - Math.abs( rawGoboIntensity ) : Math.abs( rawGoboIntensity );
+
+		// Optional IES photometric profile. Stored on light.userData.ies by IESManager.
+		const ies = light.userData?.ies;
+		const iesIndex = ( ies && Number.isInteger( ies.index ) ) ? ies.index : - 1;
+		const iesIntensity = ( ies && typeof ies.intensity === 'number' ) ? ies.intensity : 1.0;
+
 		// Store in cache with importance
 		this.spotLightCache.push( {
 			data: [
@@ -186,7 +208,13 @@ export class LightSerializer {
 				light.angle || Math.PI / 4, // cone half-angle in radians (1)
 				light.penumbra || 0.0, // penumbra [0,1] (1)
 				light.distance || 0.0, // cutoff distance (0 = infinite) (1)
-				light.decay !== undefined ? light.decay : 2.0 // decay exponent (1)
+				light.decay !== undefined ? light.decay : 2.0, // decay exponent (1)
+				goboIndex, // gobo layer index, -1 = none (1)
+				goboIntensity, // signed gobo strength (1)
+				iesIndex, // IES profile index, -1 = none (1)
+				iesIntensity, // IES blend [0,1] (1)
+				0.0, // reserved (1)
+				0.0, // reserved (1) — keeps stride at 20 (vec4 aligned)
 			],
 			importance: importance,
 			light: light
@@ -261,10 +289,10 @@ export class LightSerializer {
 	updateShaderUniforms( material ) {
 
 		// Divide flat array lengths by per-light stride to get actual light counts
-		const directionalCount = Math.floor( this.lightData.directional.length / 8 );
+		const directionalCount = Math.floor( this.lightData.directional.length / 12 );
 		const areaCount = Math.floor( this.lightData.rectArea.length / 13 );
 		const pointCount = Math.floor( this.lightData.point.length / 9 );
-		const spotCount = Math.floor( this.lightData.spot.length / 14 );
+		const spotCount = Math.floor( this.lightData.spot.length / 20 );
 
 		// Update light counts in shader defines
 		material.defines.MAX_DIRECTIONAL_LIGHTS = directionalCount;

package/src/Processor/SceneProcessor.js

@@ -1,5 +1,4 @@
 // SceneProcessor.js - Processes scene geometry into GPU-ready data (BVH, textures, materials)
-import { Color } from "three";
 import { BVHBuilder } from './BVHBuilder.js';
 import { BVHRefitter } from './BVHRefitter.js';
 import { buildBVHParallel, shouldUseParallelBuild } from './ParallelBVHBuilder.js';

package/src/Processor/ShaderBuilder.js

@@ -17,6 +17,7 @@ import { TextureNode } from 'three/webgpu';
 import { LinearFilter, DataArrayTexture } from 'three';
 import { pathTracerMain } from '../TSL/PathTracer.js';
 import { setShadowAlbedoMaps, setAlphaShadowsUniform } from '../TSL/LightsDirect.js';
+import { setGoboMapsTexture, setIESProfilesTexture } from '../TSL/LightsCore.js';
 import { BuildTimer } from './BuildTimer.js';
 
 const WG_SIZE = 8;
@@ -126,11 +127,38 @@ export class ShaderBuilder {
 		if ( mat.roughnessMaps && nodes.roughnessMapsTex ) nodes.roughnessMapsTex.value = mat.roughnessMaps;
 		if ( mat.emissiveMaps && nodes.emissiveMapsTex ) nodes.emissiveMapsTex.value = mat.emissiveMaps;
 		if ( mat.displacementMaps && nodes.displacementMapsTex ) nodes.displacementMapsTex.value = mat.displacementMaps;
+		if ( stage.goboMaps && nodes.goboMapsTex ) nodes.goboMapsTex.value = stage.goboMaps;
+		if ( stage.iesProfiles && nodes.iesProfilesTex ) nodes.iesProfilesTex.value = stage.iesProfiles;
 
 		console.log( 'ShaderBuilder: Scene textures updated in-place' );
 
 	}
 
+	/**
+	 * Swap the spot light gobo texture in-place. The TSL graph closes over the
+	 * texture node, so we only need to update the underlying .value.
+	 * @param {DataArrayTexture | null} tex
+	 */
+	updateGoboMaps( tex ) {
+
+		const nodes = this._sceneTextureNodes;
+		if ( ! nodes || ! nodes.goboMapsTex ) return;
+		if ( tex ) nodes.goboMapsTex.value = tex;
+
+	}
+
+	/**
+	 * Swap the spot light IES profile texture in-place.
+	 * @param {DataArrayTexture | null} tex
+	 */
+	updateIESProfiles( tex ) {
+
+		const nodes = this._sceneTextureNodes;
+		if ( ! nodes || ! nodes.iesProfilesTex ) return;
+		if ( tex ) nodes.iesProfilesTex.value = tex;
+
+	}
+
 	getSceneTextureNodes() {
 
 		return this._sceneTextureNodes;
@@ -276,6 +304,14 @@ export class ShaderBuilder {
 		const emissiveMapsTex = mat.emissiveMaps ? texture( mat.emissiveMaps ) : createArrayPlaceholder();
 		const displacementMapsTex = mat.displacementMaps ? texture( mat.displacementMaps ) : createArrayPlaceholder();
 
+		// Spot light gobo array — placeholder until GoboManager populates it.
+		const goboMapsTex = stage.goboMaps ? texture( stage.goboMaps ) : createArrayPlaceholder();
+		setGoboMapsTexture( goboMapsTex );
+
+		// Spot light IES profiles array — placeholder until IESManager populates it.
+		const iesProfilesTex = stage.iesProfiles ? texture( stage.iesProfiles ) : createArrayPlaceholder();
+		setIESProfilesTexture( iesProfilesTex );
+
 		// Set albedo texture array for alpha-aware shadow rays (module-level in LightsDirect.js).
 		// Always pass the texture node (real or placeholder) so alpha-cutout code is emitted
 		// into the shader at graph construction time. Runtime albedoMapIndex >= 0 guards sampling.
@@ -286,6 +322,7 @@ export class ShaderBuilder {
 			envTex, adaptiveSamplingTex, envCDFStorage,
 			albedoMapsTex, normalMapsTex, bumpMapsTex,
 			metalnessMapsTex, roughnessMapsTex, emissiveMapsTex, displacementMapsTex,
+			goboMapsTex, iesProfilesTex,
 		};
 
 		this._sceneTextureNodes = result;
@@ -369,6 +406,9 @@ export class ShaderBuilder {
 					envResolution: stage.envResolution,
 					enableEnvironmentLight: stage.enableEnvironment,
 					useEnvMapIS: stage.useEnvMapIS,
+					groundProjectionEnabled: stage.groundProjectionEnabled,
+					groundProjectionRadius: stage.groundProjectionRadius,
+					groundProjectionHeight: stage.groundProjectionHeight,
 					maxBounceCount: stage.maxBounces,
 					transmissiveBounces: stage.transmissiveBounces,
 					showBackground: stage.showBackground,
@@ -376,7 +416,6 @@ export class ShaderBuilder {
 					backgroundIntensity: stage.backgroundIntensity,
 					fireflyThreshold: stage.fireflyThreshold,
 					globalIlluminationIntensity: stage.globalIlluminationIntensity,
-					totalTriangleCount: stage.totalTriangleCount,
 					enableEmissiveTriangleSampling: stage.enableEmissiveTriangleSampling,
 					emissiveTriangleBuffer: lightBufferStorage,
 					emissiveTriangleCount: stage.emissiveTriangleCount,

package/src/Processor/Workers/TexturesWorker.js

@@ -113,7 +113,7 @@ async function processTexturesInChunks( textures, maxTextureSize, method ) {
 
 		chunkBuffer = new Uint8Array( chunkBufferSize );
 
-	} catch ( error ) {
+	} catch {
 
 		console.warn( 'Failed to allocate chunk buffer, reducing dimensions' );
 		const reducedDimensions = calculateReducedDimensions( textures, maxTextureSize );

package/src/RenderSettings.js

@@ -22,6 +22,9 @@ const SETTING_ROUTES = {
 	backgroundIntensity: { uniform: 'backgroundIntensity', reset: true },
 	showBackground: { uniform: 'showBackground', reset: true },
 	enableEnvironment: { uniform: 'enableEnvironment', reset: true },
+	groundProjectionEnabled: { uniform: 'groundProjectionEnabled', reset: true },
+	groundProjectionRadius: { uniform: 'groundProjectionRadius', reset: true },
+	groundProjectionHeight: { uniform: 'groundProjectionHeight', reset: true },
 	globalIlluminationIntensity: { uniform: 'globalIlluminationIntensity', reset: true },
 	enableDOF: { uniform: 'enableDOF', reset: true },
 	focusDistance: { uniform: 'focusDistance', reset: false },