rayzee 6.5.0 → 7.1.0

package/src/TSL/patches.js

@@ -1,9 +1,11 @@
 /**
  * Rayzee patches for Three.js / TSL.
  *
- * Side-effect on import: installs `WebGPUBackend.createNodeBuilder` override
- * (restores r183 function-scoped `var` emission for compute shaders — prevents
- * a register-allocation regression in the path tracer's hot loop).
+ * Side-effect on import: installs two `WebGPUBackend.prototype` overrides —
+ * `createNodeBuilder` (restores r183 function-scoped `var` emission for compute
+ * shaders, preventing a register-allocation regression in the path tracer's hot
+ * loop) and `initTimestampQuery` (enlarges the stats-gl timestamp query pool so
+ * the wavefront tracer's high per-frame compute-pass count doesn't overflow it).
  *
  * Export: `struct()` — drop-in replacement for TSL's `struct()` returning
  * a proxy factory that supports GLSL-style dot-notation field access.
@@ -64,7 +66,82 @@ WebGPUBackend.prototype.createNodeBuilder = function ( object, renderer ) {
 };
 
 // ---------------------------------------------------------------------------
-// 2. TSL struct proxy — enables GLSL-style dot-notation field access
+// 2. Larger timestamp query pool (stats-gl GPU/compute timing)
+// ---------------------------------------------------------------------------
+// Three.js lazily creates each timestamp query pool with a hardcoded 2048
+// queries (= 1024 passes) — `WebGPUBackend.initTimestampQuery` / the upstream
+// `// TODO: Variable maxQueries?`. The wavefront tracer issues hundreds of
+// compute passes per frame (peak right after a maxBounces change: the survivor
+// curve is invalid, so the bounce loop runs the full `loopBound` at full
+// dispatch with no early-exit — ~560 passes / 1124 queries at production
+// settings). stats-gl resolves once per frame, but the resolve is async and
+// `mapAsync` lags several frames under that GPU load, so the counter isn't reset
+// before it overflows → "Maximum number of queries exceeded" + dropped timings.
+//
+// Two parts:
+//   a) Grow the pool to 4096 queries on first use. 4096 is the WebGPU hard cap on
+//      a query set's count ("Query count exceeds the maximum query count (4096)")
+//      — 2× the upstream default, the most a single pool can hold (~2048 passes).
+//      That alone fully covers the interactive case (~200 passes/frame); anything
+//      larger fails CreateQuerySet validation.
+//   b) When even 4096 isn't enough (production spike), degrade gracefully: skip
+//      tracking the overflow passes silently instead of `warnOnce` + an invalid
+//      descriptor. The reported compute ms briefly undercounts during the spike;
+//      rendering is never affected (timestamps don't gate compute correctness).
+const TIMESTAMP_POOL_MAX_QUERIES = 4096;
+
+// Drop-in for the pool's allocateQueriesForContext minus the warnOnce on overflow
+// — returns null silently when full so the pass is cleanly skipped (see below).
+function _allocateQueriesSilently( uid ) {
+
+	if ( ! this.trackTimestamp || this.isDisposed ) return null;
+	if ( this.currentQueryIndex + 2 > this.maxQueries ) return null; // full: skip, no warn
+	const baseOffset = this.currentQueryIndex;
+	this.currentQueryIndex += 2;
+	this.queryOffsets.set( uid, baseOffset );
+	return baseOffset;
+
+}
+
+const _origInitTimestampQuery = WebGPUBackend.prototype.initTimestampQuery;
+
+WebGPUBackend.prototype.initTimestampQuery = function ( type, uid, descriptor ) {
+
+	const poolWasMissing = this.trackTimestamp && ! this.timestampQueryPool[ type ];
+
+	_origInitTimestampQuery.call( this, type, uid, descriptor );
+
+	// (a) First use: replace the fresh 2048 pool with a 4096 one of the same class,
+	// migrating the single allocation just made (offset 0) and re-pointing this
+	// pass's descriptor. Safe — first pass of the first tracked frame, nothing in
+	// flight. Swap in the silent allocator so future overflows don't warn.
+	if ( poolWasMissing ) {
+
+		const pool = this.timestampQueryPool[ type ];
+		if ( pool && pool.maxQueries < TIMESTAMP_POOL_MAX_QUERIES && descriptor.timestampWrites ) {
+
+			const Pool = pool.constructor;
+			const bigPool = new Pool( this.device, type, TIMESTAMP_POOL_MAX_QUERIES );
+			bigPool.allocateQueriesForContext = _allocateQueriesSilently;
+			bigPool.allocateQueriesForContext( uid ); // re-take offset 0 for this pass
+			this.timestampQueryPool[ type ] = bigPool;
+			descriptor.timestampWrites.querySet = bigPool.querySet; // offsets 0/1 unchanged
+			pool.dispose(); // nothing in flight — first pass of the first tracked frame
+
+		}
+
+	}
+
+	// (b) On overflow the (silent) allocator returns null, but upstream still wrote
+	// a descriptor with a null begin index — which both collides on slot 1 and is
+	// invalid. Drop it so the pass is cleanly untimed.
+	const tw = descriptor.timestampWrites;
+	if ( tw && tw.beginningOfPassWriteIndex == null ) descriptor.timestampWrites = undefined;
+
+};
+
+// ---------------------------------------------------------------------------
+// 3. TSL struct proxy — enables GLSL-style dot-notation field access
 // ---------------------------------------------------------------------------
 // TSL structs require `.get('fieldName')` for member access, but GLSL-style
 // dot notation (`.fieldName`) is more natural and matches ported code.

package/src/index.js

@@ -44,6 +44,9 @@ export { IESManager } from './managers/IESManager.js';
 export { DenoisingManager } from './managers/DenoisingManager.js';
 export { OverlayManager } from './managers/OverlayManager.js';
 
+// VRAM accounting
+export { VRAMTracker, bufferBytes, textureBytes } from './Processor/VRAMTracker.js';
+
 // Pipeline infrastructure (for advanced consumers building custom stages)
 export { RenderPipeline } from './Pipeline/RenderPipeline.js';
 export { RenderStage, StageExecutionMode } from './Pipeline/RenderStage.js';

package/src/managers/CameraManager.js

@@ -261,7 +261,7 @@ export class CameraManager extends EventDispatcher {
 	 * @param {Object} params.assetLoader
 	 * @param {import('three').Mesh} params.floorPlane
 	 * @param {number} params.currentFocusDistance
-	 * @param {import('./PathTracer.js').PathTracer} params.pathTracer
+	 * @param {import('../Stages/PathTracer.js').PathTracer} params.pathTracer
 	 * @param {Function} params.setFocusDistance - Callback to update uniform + settings
 	 * @param {Function} params.softReset       - Callback for soft accumulation reset
 	 * @param {Function} params.hardReset       - Callback for hard accumulation reset

package/src/managers/DenoisingManager.js

@@ -41,7 +41,7 @@ export class DenoisingManager extends EventDispatcher {
 		this.pipeline = pipeline;
 
 		// Stage references — only used internally for orchestration
-		this._stages = stages; // { pathTracer, asvgf, variance, bilateralFilter, adaptiveSampling, edgeFilter, ssrc, autoExposure, compositor }
+		this._stages = stages; // { pathTracer, asvgf, variance, bilateralFilter, edgeFilter, ssrc, autoExposure, compositor }
 
 		this._getExposure = getExposure;
 		this._getSaturation = getSaturation;
@@ -231,7 +231,7 @@ export class DenoisingManager extends EventDispatcher {
 
 		// Disable all real-time denoisers first
 		if ( s.asvgf ) s.asvgf.enabled = false;
-		if ( s.variance && ! this._isAdaptiveSamplingActive() ) s.variance.enabled = false;
+		if ( s.variance ) s.variance.enabled = false;
 		if ( s.bilateralFilter ) s.bilateralFilter.enabled = false;
 		if ( s.edgeFilter ) s.edgeFilter.setFilteringEnabled( false );
 		if ( s.ssrc ) s.ssrc.enabled = false;
@@ -258,6 +258,8 @@ export class DenoisingManager extends EventDispatcher {
 
 		}
 
+		this._syncGBufferStages();
+
 	}
 
 	/**
@@ -282,6 +284,8 @@ export class DenoisingManager extends EventDispatcher {
 		// Coordinate with EdgeAware filtering
 		if ( s.edgeFilter ) s.edgeFilter.setFilteringEnabled( ! enabled );
 
+		this._syncGBufferStages();
+
 	}
 
 	/**
@@ -315,35 +319,49 @@ export class DenoisingManager extends EventDispatcher {
 	}
 
 	/**
-	 * Enables/disables adaptive sampling with proper stage and context cleanup.
-	 * @param {boolean} enabled
+	 * Gate the G-buffer stages (NormalDepth, MotionVector) on demand: they only
+	 * need to run when a real-time denoiser consumes their output. Idling them
+	 * otherwise skips MotionVector's per-frame compute + copies during preview
+	 * navigation and frees their textures. Call after any consumer toggle.
+	 *
+	 * MotionVector requires NormalDepth (reads pathtracer:normalDepth) and its
+	 * consumers (ASVGF, SSRC) are a subset of NormalDepth's, so NormalDepth is
+	 * always enabled whenever MotionVector is. Adaptive sampling / Variance / OIDN
+	 * do NOT read these signals, so they don't keep the G-buffer alive.
 	 */
-	setAdaptiveSamplingEnabled( enabled ) {
+	_syncGBufferStages() {
 
 		const s = this._stages;
+		const nd = s.normalDepth;
+		const mv = s.motionVector;
 
-		if ( s.adaptiveSampling ) {
-
-			s.adaptiveSampling.enabled = enabled;
-			s.adaptiveSampling.setHeatmapEnabled( false );
+		// motionVector:* consumed by ASVGF + SSRC
+		const motionNeeded = !! ( s.asvgf?.enabled || s.ssrc?.enabled );
+		// pathtracer:normalDepth consumed by ASVGF, SSRC, EdgeFilter, BilateralFilter
+		const normalNeeded = motionNeeded || !! ( s.edgeFilter?.enabled || s.bilateralFilter?.enabled );
 
-		}
+		if ( nd ) {
 
-		// Variance stage is shared by both ASVGF and adaptive sampling
-		if ( enabled ) {
+			// On disabled→enabled, re-arm dirty/history so the first frame recomputes
+			// (not the stale static fast-path) and seeds prev = current.
+			if ( normalNeeded && ! nd.enabled ) nd.reset();
+			nd.enabled = normalNeeded;
 
-			if ( s.variance ) s.variance.enabled = true;
+		}
 
-		} else if ( ! s.asvgf?.enabled ) {
+		if ( mv ) {
 
-			if ( s.variance ) s.variance.enabled = false;
+			// On re-enable, force a camera-history reseed (matricesInitialized survives
+			// normal resets) so the first frame reports zero motion, not a spike.
+			if ( motionNeeded && ! mv.enabled ) {
 
-		}
+				mv.matricesInitialized = false;
+				mv.isFirstFrame = true;
+				mv.frameCount = 0;
 
-		// Clean up stale variance context when disabling
-		if ( ! enabled && this.pipeline?.context && ! s.asvgf?.enabled ) {
+			}
 
-			this.pipeline.context.removeTexture( 'variance:output' );
+			mv.enabled = motionNeeded;
 
 		}
 
@@ -546,6 +564,8 @@ export class DenoisingManager extends EventDispatcher {
 
 		}
 
+		this._syncGBufferStages();
+
 	}
 
 	/** Updates SSRC stage parameters. */
@@ -569,29 +589,6 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	/**
-	 * Updates adaptive sampling parameters (with settings bridge).
-	 * @param {Object} params
-	 */
-	setAdaptiveSamplingParams( params ) {
-
-		if ( params.min !== undefined ) this._stages.pathTracer?.setUniform( 'adaptiveSamplingMin', params.min );
-		if ( params.adaptiveSamplingMax !== undefined ) this._settings?.set( 'adaptiveSamplingMax', params.adaptiveSamplingMax );
-		this._stages.adaptiveSampling?.setAdaptiveSamplingParameters( params );
-
-	}
-
-	/**
-	 * Toggle the AdaptiveSampling heatmap compute pass. When enabled, the
-	 * stage writes the heatmap to its public `heatmapTarget` RenderTarget —
-	 * the host is responsible for rendering it.
-	 */
-	toggleAdaptiveSamplingHelper( enabled ) {
-
-		this._stages.adaptiveSampling?.setHeatmapEnabled( enabled );
-
-	}
-
 	// ── OIDN ─────────────────────────────────────────────────────
 
 	/** Enables or disables Intel OIDN denoiser. */
@@ -608,27 +605,13 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	/** Enables or disables the OIDN tile helper overlay. */
-	setOIDNTileHelper( enabled ) {
-
-		this._setTileHelper( enabled );
-
-	}
-
-	/** Enables or disables the tile helper overlay. */
+	/** Enables or disables the denoise/upscale progress overlay. */
 	setTileHelperEnabled( enabled ) {
 
 		this._setTileHelper( enabled );
 
 	}
 
-	/** Enables or disables tile highlight. */
-	setTileHighlightEnabled( enabled ) {
-
-		this._setTileHelper( enabled );
-
-	}
-
 	// ── AI Upscaler ──────────────────────────────────────────────
 
 	/** Enables or disables the AI upscaler. */
@@ -665,17 +648,6 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	/**
-	 * Enables or disables adaptive sampling (convenience wrapper with settings bridge).
-	 * @param {boolean} enabled
-	 */
-	setAdaptiveSampling( enabled ) {
-
-		this._settings?.set( 'useAdaptiveSampling', enabled );
-		this.setAdaptiveSamplingEnabled( enabled );
-
-	}
-
 	/**
 	 * Switches strategy with automatic reset (convenience wrapper).
 	 * @param {'none'|'asvgf'|'ssrc'|'edgeaware'} strategy
@@ -702,7 +674,6 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-
 	_getEffectiveExposure() {
 
 		return this._stages.autoExposure?.enabled
@@ -717,12 +688,6 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	_isAdaptiveSamplingActive() {
-
-		return this._stages.adaptiveSampling?.enabled ?? false;
-
-	}
-
 	_clearDenoiserTextures() {
 
 		const ctx = this.pipeline?.context;

package/src/managers/EnvironmentManager.js

@@ -7,10 +7,8 @@
  * is mutated to preserve TSL shader graph references after compilation.
  */
 
-import { StorageInstancedBufferAttribute } from 'three/webgpu';
-import { storage } from 'three/tsl';
 import {
-	RGBAFormat, FloatType, Vector2, Vector3, Color, Matrix4, DataTexture,
+	RGBAFormat, RedFormat, FloatType, Vector2, Vector3, Color, Matrix4, DataTexture,
 } from 'three';
 import { EquirectHDRInfo } from '../Processor/EquirectHDRInfo.js';
 import { ProceduralSky } from '../Processor/ProceduralSky.js';
@@ -43,12 +41,10 @@ export class EnvironmentManager {
 		this.environmentTexture = this._envPlaceholder;
 		this.envTexSize = new Vector2();
 
-		// CDF storage buffer (marginal + conditional packed into one buffer).
-		// Layout: [ marginal (envResolution.y floats) | conditional (envResolution.x * envResolution.y floats) ]
-		// Conditional offset is the marginal length, which equals envResolution.y at runtime.
-		this.envCDFStorageAttr = null;
-		this.envCDFStorageNode = null;
-		this._initCDFStorageBuffers();
+		// Importance-sampling CDF as an R32F texture (frees a Shade storage-buffer binding — the limit is 10).
+		// Layout: (envResolution.x + 1) × envResolution.y; conditional in columns [0,W), marginal in column W.
+		this.envCDFTexture = null;
+		this._initCDFTexture();
 
 		// Environment rotation
 		this.environmentRotationMatrix = new Matrix4();
@@ -183,46 +179,42 @@ export class EnvironmentManager {
 	 * Initialize the packed CDF storage buffer with placeholder data.
 	 * Must be called before shader compilation so the node exists in the graph.
 	 *
-	 * Layout: [ marginal (size = envResolution.y) | conditional (size = envResolution.x * envResolution.y) ]
-	 * Placeholder shape is a 1x2 env map: marginal=[0,1], conditional=[0,0,1,1].
+	 * 1×1 R32F placeholder until a real env CDF is built (env IS is off meanwhile).
 	 * @private
 	 */
-	_initCDFStorageBuffers() {
+	_initCDFTexture() {
 
-		const placeholder = new Float32Array( [ 0, 1, 0, 0, 1, 1 ] );
-		this.envCDFStorageAttr = new StorageInstancedBufferAttribute( placeholder, 1 );
-		this.envCDFStorageNode = storage( this.envCDFStorageAttr, 'float', placeholder.length ).toReadOnly();
+		this.envCDFTexture = new DataTexture( new Float32Array( [ 0 ] ), 1, 1, RedFormat, FloatType );
+		this.envCDFTexture.needsUpdate = true;
 
 	}
 
 	/**
-	 * Update the packed CDF storage buffer from equirectHdrInfo.
-	 * Concatenates marginal + conditional into one buffer.
+	 * Rebuild the CDF texture from equirectHdrInfo. Packs the 2D conditional + 1D marginal into one
+	 * R32F texture of (W+1)×H: conditional[cy*W+cx] at texel (cx, cy); marginal[cy] at texel (W, cy).
 	 * @private
 	 */
-	_updateCDFStorageBuffers() {
+	_updateCDFTexture() {
 
 		const marginal = this.equirectHdrInfo.marginalData;
 		const conditional = this.equirectHdrInfo.conditionalData;
 		if ( ! marginal || ! conditional ) return;
 
-		const combined = new Float32Array( marginal.length + conditional.length );
-		combined.set( marginal, 0 );
-		combined.set( conditional, marginal.length );
+		const W = this.equirectHdrInfo.width;
+		const H = this.equirectHdrInfo.height;
+		const texW = W + 1;
+		const data = new Float32Array( texW * H );
+		for ( let cy = 0; cy < H; cy ++ ) {
 
-		this.envCDFStorageAttr = new StorageInstancedBufferAttribute( combined, 1 );
-		this.envCDFStorageNode.value = this.envCDFStorageAttr;
-		this.envCDFStorageNode.bufferCount = combined.length;
+			const dstRow = cy * texW;
+			data.set( conditional.subarray( cy * W, cy * W + W ), dstRow ); // conditional → columns [0,W)
+			data[ dstRow + W ] = marginal[ cy ]; // marginal → column W
 
-	}
-
-	/**
-	 * Get the packed CDF storage node for shader graph.
-	 * @returns {{ cdfNode: StorageNode }}
-	 */
-	getCDFStorageNodes() {
+		}
 
-		return { cdfNode: this.envCDFStorageNode };
+		this.envCDFTexture?.dispose?.();
+		this.envCDFTexture = new DataTexture( data, texW, H, RedFormat, FloatType );
+		this.envCDFTexture.needsUpdate = true;
 
 	}
 
@@ -278,7 +270,7 @@ export class EnvironmentManager {
 
 		if ( ! this.scene.environment ) {
 
-			this._updateCDFStorageBuffers();
+			this._updateCDFTexture();
 			this.uniforms.set( 'envTotalSum', 0.0 );
 			this.uniforms.set( 'envCompensationDelta', 0.0 );
 			this.uniforms.set( 'useEnvMapIS', 0 );
@@ -293,7 +285,7 @@ export class EnvironmentManager {
 
 			if ( ! textureForCDF.image ) {
 
-				this._updateCDFStorageBuffers();
+				this._updateCDFTexture();
 				this.uniforms.set( 'envTotalSum', 0.0 );
 				this.uniforms.set( 'envCompensationDelta', 0.0 );
 				this.uniforms.set( 'useEnvMapIS', 0 );
@@ -313,7 +305,7 @@ export class EnvironmentManager {
 
 			this.cdfBuildTime = performance.now() - startTime;
 
-			this._updateCDFStorageBuffers();
+			this._updateCDFTexture();
 			this.uniforms.set( 'envTotalSum', this.equirectHdrInfo.totalSum );
 			this.uniforms.set( 'envCompensationDelta', this.equirectHdrInfo.compensationDelta );
 			this.uniforms.set( 'useEnvMapIS', 1 );
@@ -377,7 +369,7 @@ export class EnvironmentManager {
 
 		} else {
 
-			this._updateCDFStorageBuffers();
+			this._updateCDFTexture();
 			this.uniforms.set( 'envTotalSum', 0.0 );
 			this.uniforms.set( 'envCompensationDelta', 0.0 );
 			this.uniforms.set( 'useEnvMapIS', 0 );
@@ -543,9 +535,8 @@ export class EnvironmentManager {
 		this.proceduralSkyRenderer = null;
 		this.simpleSkyRenderer = null;
 
-		this.envCDFStorageAttr?.dispose?.();
-		this.envCDFStorageAttr = null;
-		this.envCDFStorageNode = null;
+		this.envCDFTexture?.dispose?.();
+		this.envCDFTexture = null;
 
 		// Dispose the HDRI environment texture unless it's the shared placeholder
 		// (the placeholder is handled separately just below).

package/src/managers/OverlayManager.js

@@ -1,6 +1,5 @@
 import { TileHelper } from './helpers/TileHelper.js';
 import { OutlineHelper } from './helpers/OutlineHelper.js';
-import { EngineEvents } from '../EngineEvents.js';
 
 /**
  * OverlayManager — Unified overlay system for visual helpers.
@@ -9,7 +8,7 @@ import { EngineEvents } from '../EngineEvents.js';
  *   1. **HelperScene** — A Three.js Scene rendered on top of the WebGPU backbuffer
  *      (light gizmos, bounding boxes, outlines). Renders at display resolution.
  *   2. **HUDCanvas** — A 2D `<canvas>` element overlaid via CSS for screen-space
- *      elements (tile progress, AF points, debug labels). Completely separate
+ *      elements (AF points, debug labels). Completely separate
  *      from the WebGPU canvas, so it is never captured in saved images.
  *
  * Helpers are registered by name and implement a simple interface:
@@ -17,8 +16,8 @@ import { EngineEvents } from '../EngineEvents.js';
  *
  * @example
  *   const overlay = new OverlayManager( renderer, camera );
- *   overlay.register( 'tiles', new TileHelper() );
- *   overlay.show( 'tiles' );
+ *   overlay.register( 'outline', new OutlineHelper() );
+ *   overlay.show( 'outline' );
  *   // in animate():
  *   overlay.render();
  */
@@ -84,7 +83,7 @@ export class OverlayManager {
 	// ═══════════════════════════════════════════════════════════════
 
 	/**
-	 * Creates and wires the default overlay helpers (tile progress, outline).
+	 * Creates and wires the default overlay helpers (denoise/upscale progress, outline).
 	 * Call once during app init after pipeline and managers are ready.
 	 *
 	 * @param {Object} config
@@ -92,7 +91,7 @@ export class OverlayManager {
 	 * @param {import('three').Scene} config.meshScene
 	 * @param {import('../Pipeline/RenderPipeline.js').RenderPipeline} config.pipeline
 	 * @param {import('./DenoisingManager.js').DenoisingManager} config.denoisingManager
-	 * @param {import('three').EventDispatcher} config.app - App instance for resize/render-complete events
+	 * @param {import('three').EventDispatcher} config.app - App instance for resize events
 	 * @param {number} config.renderWidth
 	 * @param {number} config.renderHeight
 	 */
@@ -100,7 +99,7 @@ export class OverlayManager {
 
 		this.setHelperScene( helperScene );
 
-		// ── Tile helper (shared across path tracer, OIDN, upscaler) ──
+		// ── Tile helper — shows OIDN denoise + AI upscale progress ──
 		const tileHelper = new TileHelper();
 		this.register( 'tiles', tileHelper );
 
@@ -112,22 +111,8 @@ export class OverlayManager {
 
 		} );
 
-		// Path tracer tile events
-		pipeline.eventBus.on( 'tile:changed', ( e ) => {
-
-			if ( e.renderMode === 1 && e.tileBounds ) {
-
-				tileHelper.setActiveTile( e.tileBounds );
-				tileHelper.show();
-
-			}
-
-		} );
-
 		pipeline.eventBus.on( 'pipeline:reset', () => tileHelper.hide() );
-		app.addEventListener( EngineEvents.RENDER_COMPLETE, () => tileHelper.hide() );
 
-		// OIDN/upscaler tile events
 		this._wireDenoiserTileEvents( tileHelper, denoisingManager );
 
 		// ── Outline helper ──
@@ -137,7 +122,7 @@ export class OverlayManager {
 	}
 
 	/**
-	 * Wires denoiser/upscaler tile progress events to the tile helper.
+	 * Wires denoiser/upscaler tile-progress events to the tile helper.
 	 * These fire while the animation loop is stopped, so we trigger manual HUD redraws.
 	 */
 	_wireDenoiserTileEvents( tileHelper, denoisingManager ) {

package/src/managers/UniformManager.js

@@ -231,9 +231,6 @@ export class UniformManager {
 		this._uniforms.set( 'samplingTechnique', samplingTechniqueUniform );
 		samplingTechniqueUniform.value = DEFAULT_STATE.samplingTechnique;
 
-		ub( 'useAdaptiveSampling', DEFAULT_STATE.adaptiveSampling );
-		u( 'adaptiveSamplingMin', DEFAULT_STATE.adaptiveSamplingMin ?? 1, 'int' );
-		u( 'adaptiveSamplingMax', DEFAULT_STATE.adaptiveSamplingMax, 'int' );
 		u( 'fireflyThreshold', DEFAULT_STATE.fireflyThreshold, 'float' );
 
 		// Emissive

package/src/managers/helpers/TileHelper.js

@@ -1,8 +1,8 @@
 /**
  * TileHelper — 2D canvas overlay showing the active tile border.
  *
- * Universal: works for path tracer tiled rendering, OIDN denoiser,
- * and AI upscaler. Callers provide pixel-space tile bounds via
+ * Shows progress of the OIDN denoiser and AI upscaler (both process the
+ * image in tiles). Callers provide pixel-space tile bounds via
  * `setActiveTile()` and control visibility via `show()` / `hide()`.
  *
  * Layer: 'hud' (rendered by OverlayManager's 2D canvas pass).