rayzee 8.4.0 → 8.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "8.4.0",
+  "version": "8.5.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/EngineDefaults.js

@@ -210,6 +210,8 @@ export const ENGINE_DEFAULTS = {
 	bloomRadius: 0.15,
 	bloomThreshold: 0.85,
 	interactionModeEnabled: true,
+	// Per-axis render scale while the camera moves (0.5 = a quarter of the pixels); 1 turns it off.
+	interactionRenderScale: 0.5,
 	debugVisScale: 100,
 
 	// Denoising strategy
@@ -1062,7 +1064,8 @@ export const DEFAULT_TEXTURE_MATRIX = [ 0, 0, 1, 1, 0, 0, 0, 1 ];
 export const PRODUCTION_RENDER_CONFIG = {
 	// maxSamples is a CEILING: adaptive sampling retires the frame once adaptiveStopFraction of pixels converge,
 	// so easy scenes finish well under it while hard GI scenes use the full budget.
-	maxSamples: 150, bounces: 20, transmissiveBounces: 8, maxSubsurfaceSteps: 64,
+	// Below 24 a ray that spends its transmissive budget is shaded opaque — black pixels, not dim glass.
+	maxSamples: 30, bounces: 20, transmissiveBounces: 24, maxSubsurfaceSteps: 64,
 	renderMode: 1, enableAlphaShadows: true,
 	// 'high' is the only tier that reaches OIDN's _large weights (calb_cnrm); ~2x denoise cost.
 	enableOIDN: true, oidnQuality: 'high',
@@ -1077,7 +1080,8 @@ export const PRODUCTION_RENDER_CONFIG = {
 export const INTERACTIVE_RENDER_CONFIG = {
 	maxSamples: ENGINE_DEFAULTS.maxSamples, bounces: ENGINE_DEFAULTS.bounces,
 	renderMode: ENGINE_DEFAULTS.renderMode, enableAlphaShadows: ENGINE_DEFAULTS.enableAlphaShadows,
-	transmissiveBounces: ENGINE_DEFAULTS.transmissiveBounces,
+	// 12, not 5: a spent budget leaves black glass and costs MORE — the ray then bounces diffusely.
+	transmissiveBounces: 12,
 	maxSubsurfaceSteps: ENGINE_DEFAULTS.maxSubsurfaceSteps,
 	// On, like production. The final pass costs one cheap denoise when the preview settles, and both
 	// neural passes need a denoised frame to be worth running — on Monte-Carlo noise the upscaler
@@ -1090,6 +1094,30 @@ export const INTERACTIVE_RENDER_CONFIG = {
 	usePixelFreeze: true, // speeds up idle refinement on heavy/high-res views; inert while moving (freeze resets)
 };
 
+// The RenderSettings a mode preset owns. configureForMode applies these, and anything that borrows a
+// mode for a while (the video renderer) restores exactly these keys.
+export function modePresetSettings( config ) {
+
+	return {
+		maxSamples: config.maxSamples,
+		maxBounces: config.bounces,
+		transmissiveBounces: config.transmissiveBounces,
+		maxSubsurfaceSteps: config.maxSubsurfaceSteps,
+		enableAlphaShadows: config.enableAlphaShadows ?? false,
+		// Tier-1 convergence early-stop
+		useAdaptiveSampling: config.useAdaptiveSampling ?? false,
+		noiseThreshold: config.noiseThreshold ?? ENGINE_DEFAULTS.noiseThreshold,
+		adaptiveStopFraction: config.adaptiveStopFraction ?? ENGINE_DEFAULTS.adaptiveStopFraction,
+		adaptiveMinSamples: config.adaptiveMinSamples ?? ENGINE_DEFAULTS.adaptiveMinSamples,
+		// Tier-2 per-pixel freeze
+		usePixelFreeze: config.usePixelFreeze ?? false,
+		pixelFreezeThreshold: config.pixelFreezeThreshold ?? ENGINE_DEFAULTS.pixelFreezeThreshold,
+		pixelFreezeStability: config.pixelFreezeStability ?? ENGINE_DEFAULTS.pixelFreezeStability,
+		interactionModeEnabled: config.interactionModeEnabled ?? ENGINE_DEFAULTS.interactionModeEnabled,
+	};
+
+}
+
 // Memory management constants
 export const MEMORY_CONSTANTS = {
 	MAX_BUFFER_MEMORY: 1024 * 1024 * 1024,

package/src/PathTracerApp.js

@@ -17,7 +17,7 @@ import { AutoExposure } from './Stages/AutoExposure.js';
 import { Compositor } from './Stages/Compositor.js';
 import { RenderPipeline } from './Pipeline/RenderPipeline.js';
 import { CompletionTracker } from './Pipeline/CompletionTracker.js';
-import { ENGINE_DEFAULTS as DEFAULT_STATE, PRODUCTION_RENDER_CONFIG, INTERACTIVE_RENDER_CONFIG, MAX_STORAGE_TEXTURE_SIZE, MAX_RESERVABLE_RENDER_SIZE, setReservedRenderSize, getRenderProfile } from './EngineDefaults.js';
+import { ENGINE_DEFAULTS as DEFAULT_STATE, PRODUCTION_RENDER_CONFIG, INTERACTIVE_RENDER_CONFIG, modePresetSettings, MAX_STORAGE_TEXTURE_SIZE, MAX_RESERVABLE_RENDER_SIZE, setReservedRenderSize, getRenderProfile } from './EngineDefaults.js';
 import { updateStats, updateLoading, resetLoading, setStatusCallback, getDisplaySamples, disposeObjectFromMemory, disposeRenderer } from './Processor/utils.js';
 import { BuildTimer } from './Processor/BuildTimer.js';
 import { createLogger, fmt } from './utils/Logger.js';
@@ -239,6 +239,12 @@ export class PathTracerApp extends EventDispatcher {
 
 		// Resolution state
 		this._resizeDebounceTimer = null;
+		// The size the host asked for. The canvas backing store is this × _renderScale, which drops
+		// below 1 only while the camera moves.
+		this._displayWidth = 0;
+		this._displayHeight = 0;
+		this._renderScale = 1;
+		this._pendingRenderScale = null;
 
 		// Tracked listeners for clean dispose()
 		this._trackedListeners = [];
@@ -342,6 +348,8 @@ export class PathTracerApp extends EventDispatcher {
 
 		if ( this.cameraManager.controls ) this.cameraManager.controls.update();
 
+		this._applyPendingRenderScale();
+
 		// Animation playback: compute skinned positions and refit BVH.
 		// Guard prevents overlapping async refits (fire-and-forget with 1-frame latency).
 		if ( this.animationManager?.isPlaying && ! this._animRefitInFlight ) {
@@ -1812,9 +1820,7 @@ export class PathTracerApp extends EventDispatcher {
 		if ( ! this._isRenderSizeSupported( width, height ) ) return;
 
 		this.renderer.setPixelRatio( 1.0 );
-		this.renderer.setSize( width, height, false );
-		this.cameraManager.camera.aspect = width / height;
-		this.cameraManager.camera.updateProjectionMatrix();
+		this._setDisplaySize( width, height );
 
 		const lastW = this.denoisingManager?._lastRenderWidth ?? 0;
 		const lastH = this.denoisingManager?._lastRenderHeight ?? 0;
@@ -1833,7 +1839,8 @@ export class PathTracerApp extends EventDispatcher {
 
 		if ( ! this._isRenderSizeSupported( renderWidth, renderHeight ) ) return;
 
-		this.pipeline?.setSize( renderWidth, renderHeight );
+		this.pipeline?.setSize( this._scaled( renderWidth ), this._scaled( renderHeight ) );
+		// Full size: the denoiser only runs once the camera has stopped.
 		this.denoisingManager?.setRenderSize( renderWidth, renderHeight );
 		this.needsReset = true;
 
@@ -1856,9 +1863,7 @@ export class PathTracerApp extends EventDispatcher {
 		if ( ! this._isRenderSizeSupported( width, height ) ) return null;
 
 		this.renderer.setPixelRatio( 1.0 );
-		this.renderer.setSize( width, height, false );
-		this.cameraManager.camera.aspect = width / height;
-		this.cameraManager.camera.updateProjectionMatrix();
+		this._setDisplaySize( width, height );
 
 		clearTimeout( this._resizeDebounceTimer );
 		this._applyRenderResize( width, height );
@@ -1867,6 +1872,66 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	_scaled( size ) {
+
+		return Math.max( 1, Math.round( size * this._renderScale ) );
+
+	}
+
+	// The wavefront takes its resolution from the canvas backing store, so that is what has to shrink.
+	// updateStyle=false keeps the CSS size, and the browser stretches the smaller frame over it.
+	_setDisplaySize( width, height ) {
+
+		this._displayWidth = width;
+		this._displayHeight = height;
+
+		this.renderer.setSize( this._scaled( width ), this._scaled( height ), false );
+		this.cameraManager.camera.aspect = width / height;
+		this.cameraManager.camera.updateProjectionMatrix();
+
+	}
+
+	// OIDN as the live denoiser rebuilds its network on every size change, so it keeps full size.
+	_interactionRenderScale() {
+
+		if ( this.denoisingManager?.continuousDenoise ) return 1;
+		const scale = Number( this.settings.get( 'interactionRenderScale' ) );
+		return scale > 0 ? Math.min( 1, Math.max( 0.125, scale ) ) : 1;
+
+	}
+
+	// Interaction can start inside PathTracer.render(), where resizing would pull textures out from
+	// under the frame, so the change waits for the next frame boundary. No wake(): the move that
+	// started it already woke the loop, and waking from inside render() would re-enter it.
+	_requestRenderScale( scale ) {
+
+		this._pendingRenderScale = scale;
+
+	}
+
+	_applyPendingRenderScale() {
+
+		if ( this._pendingRenderScale !== null ) this._applyRenderScale( this._pendingRenderScale );
+
+	}
+
+	_applyRenderScale( scale ) {
+
+		this._pendingRenderScale = null;
+		if ( this._disposed || scale === this._renderScale ) return;
+
+		this._renderScale = scale;
+		if ( ! this._displayWidth || ! this._displayHeight ) return;
+
+		this._setDisplaySize( this._displayWidth, this._displayHeight );
+		this.pipeline?.setSize( this._scaled( this._displayWidth ), this._scaled( this._displayHeight ) );
+		// History from the other size would reproject garbage.
+		this.pipeline?.eventBus.emit( 'asvgf:reset' );
+		this.pipeline?.eventBus.emit( 'denoiser:reset' );
+		this.needsReset = true;
+
+	}
+
 	// ═══════════════════════════════════════════════════════════════
 	// Mode Configuration
 	// ═══════════════════════════════════════════════════════════════
@@ -1889,22 +1954,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		// Anything with a SETTING_ROUTES entry must go through settings, not setUniform: set() early-returns on
 		// `prev === value`, so a uniform written behind the map leaves it stale and the next set() silently no-ops.
-		this.settings.setMany( {
-			maxSamples: config.maxSamples,
-			maxBounces: config.bounces,
-			transmissiveBounces: config.transmissiveBounces,
-			maxSubsurfaceSteps: config.maxSubsurfaceSteps,
-			enableAlphaShadows: config.enableAlphaShadows ?? false,
-			// Tier-1 convergence early-stop
-			useAdaptiveSampling: config.useAdaptiveSampling ?? false,
-			noiseThreshold: config.noiseThreshold ?? DEFAULT_STATE.noiseThreshold,
-			adaptiveStopFraction: config.adaptiveStopFraction ?? DEFAULT_STATE.adaptiveStopFraction,
-			adaptiveMinSamples: config.adaptiveMinSamples ?? DEFAULT_STATE.adaptiveMinSamples,
-			// Tier-2 per-pixel freeze
-			usePixelFreeze: config.usePixelFreeze ?? false,
-			pixelFreezeThreshold: config.pixelFreezeThreshold ?? DEFAULT_STATE.pixelFreezeThreshold,
-			pixelFreezeStability: config.pixelFreezeStability ?? DEFAULT_STATE.pixelFreezeStability,
-		}, { silent: true, source: SETTING_SOURCE.MODE_PRESET } );
+		this.settings.setMany( modePresetSettings( config ), { silent: true, source: SETTING_SOURCE.MODE_PRESET } );
 
 		// renderMode has no SETTING_ROUTES entry
 		this.stages.pathTracer?.setUniform( 'renderMode', parseInt( config.renderMode ) );
@@ -2014,7 +2064,7 @@ export class PathTracerApp extends EventDispatcher {
 	 * - `_bounceEarlyExitThreshold` / `_useDynamicDispatch` both consume the async
 	 *   survivor curve. Kernels bind on ENTERING_COUNT, so an under-sized grid silently
 	 *   drops rays, and the frame a readback lands on is GPU-scheduled.
-	 * - `interactionModeEnabled` is a 100 ms timer that clamps bounces to 1, disables
+	 * - `interactionModeEnabled` is a 100 ms timer that lowers the render resolution, disables
 	 *   accumulation and freezes frameCount; it engages on the very first frame.
 	 * - auto-focus raycasts per frame and auto-exposure adapts off `performance.now()`.
 	 *
@@ -3027,6 +3077,8 @@ export class PathTracerApp extends EventDispatcher {
 		this._addTrackedListener( this.cameraManager.controls, 'change', () => {
 
 			this.needsReset = true;
+			// Here rather than in render(), so the first frame of the move is already at the lower resolution.
+			this.stages.pathTracer?.enterInteractionMode();
 			this.wake();
 
 		} );
@@ -3053,8 +3105,15 @@ export class PathTracerApp extends EventDispatcher {
 
 		const initRenderW = this.canvas.clientWidth || 1;
 		const initRenderH = this.canvas.clientHeight || 1;
+		this._displayWidth = initRenderW;
+		this._displayHeight = initRenderH;
 		this.pipeline.setSize( initRenderW, initRenderH );
 
+		this.pipeline.eventBus.on( 'pathtracer:interactionStart', () => this._requestRenderScale( this._interactionRenderScale() ) );
+		// Never fires inside a frame (a timer, or interaction mode being switched off), so it applies at once —
+		// renderFrames() and the video renderer drive pipeline.render() without passing through animate().
+		this.pipeline.eventBus.on( 'pathtracer:interactionEnd', () => this._applyRenderScale( 1 ) );
+
 	}
 
 	async _initManagers() {
@@ -3106,6 +3165,7 @@ export class PathTracerApp extends EventDispatcher {
 		this.denoisingManager.setOverlayManager( this.overlayManager );
 		this.denoisingManager.setResetCallback( () => this.reset() );
 		this.denoisingManager.setPostProcessRefreshCallback( () => this.requestPostProcessRefresh() );
+		this.denoisingManager.setDisplayRefreshCallback( () => this.refreshFrame() );
 		this.denoisingManager.setSettings( this.settings );
 
 		// Expose environment manager (lives on pathTracer stage)
@@ -3174,6 +3234,11 @@ export class PathTracerApp extends EventDispatcher {
 			reconcileCompletion: () => this._reconcileCompletion(),
 			denoisingManager: this.denoisingManager,
 			cameraManager: this.cameraManager,
+			onInteractionRenderScale: () => {
+
+				if ( this.stages.pathTracer?.interactionMode ) this._requestRenderScale( this._interactionRenderScale() );
+
+			},
 		} );
 
 		this.renderer.toneMappingExposure = this.settings.get( 'exposure' ) ?? 1.0;

package/src/Processor/AssetLoader.js

@@ -67,6 +67,9 @@ function standInForSplit( source ) {
 
 }
 
+// Luminous efficacy glTF, three.js and Blender's exporter all assume (PBR_WATTS_TO_LUMENS).
+const LUMENS_PER_WATT = 683;
+
 // three.js nits → the engine's radiant power, inverting areaLightRadiance.
 function areaLightPowerFactor( node, width, height, userData ) {
 
@@ -2089,17 +2092,25 @@ export class AssetLoader extends EventDispatcher {
 
 			}
 
-			// glTF punctual point/spot intensity is candela (W/sr); the engine's light
-			// model is Blender-style Power (W) that LightSerializer divides by 4π. Convert
-			// glTF candela → Power once at import (×4π) so it nets to the correct I/d².
-			// Directional (lux ≈ irradiance) is used directly and needs no conversion.
+			// Punctual lights arrive photometric: glTF (and three.js) state point/spot in
+			// candela and directional in lux. The engine is radiometric Blender Watts, which
+			// LightSerializer turns into W/sr with ÷4π, so the luminous efficacy has to be
+			// divided back out — Blender's own glTF importer does exactly this. Skipping it
+			// rendered every Blender lamp 683x too bright.
 			if ( ( object.isPointLight || object.isSpotLight ) && ! userData.__candelaConverted ) {
 
-				object.intensity *= 4 * Math.PI;
+				object.intensity *= 4 * Math.PI / LUMENS_PER_WATT;
 				userData.__candelaConverted = true;
 
 			}
 
+			if ( object.isDirectionalLight && ! userData.__luxConverted ) {
+
+				object.intensity /= LUMENS_PER_WATT;
+				userData.__luxConverted = true;
+
+			}
+
 			// Process ceiling lights
 			if ( object.name.startsWith( 'RectAreaLightPlaceholder' ) &&
 				userData.name

package/src/Processor/CameraOptimizer.js

@@ -19,12 +19,11 @@ export class CameraOptimizer {
 		this.interactionMode = false;
 		this.interactionTimeout = null;
 		this.originalValues = {};
+		this.appliedValues = {};
 		this.wasAccumulationEnabled = true; // Track original accumulation state
 
 		// Enhanced interaction mode settings for reduced quality during interaction
 		this.interactionQualitySettings = {
-			maxBounceCount: 1,
-			// pixelRatio: 0.25,
 			enableAccumulation: false,
 			...settings.qualitySettings
 		};
@@ -54,6 +53,7 @@ export class CameraOptimizer {
 			// Enter interaction mode and save original values
 			this.interactionMode = true;
 			this.originalValues = {}; // Reset stored values
+			this.appliedValues = {};
 
 			// Store original accumulation state before any changes
 			if ( this.material.uniforms.enableAccumulation ) {
@@ -80,7 +80,8 @@ export class CameraOptimizer {
 
 					// Handle material uniforms
 					this.originalValues[ key ] = this.material.uniforms[ key ].value;
-					this.material.uniforms[ key ].value = this.interactionQualitySettings[ key ];
+					this.material.uniforms[ key ].value = this._resolveQualityValue( key, this.interactionQualitySettings[ key ] );
+					this.appliedValues[ key ] = this.material.uniforms[ key ].value;
 
 				}
 
@@ -136,8 +137,13 @@ export class CameraOptimizer {
 
 			} else if ( this.material.uniforms[ key ] ) {
 
-				// Restore material uniforms
-				this.material.uniforms[ key ].value = this.originalValues[ key ];
+				// A value written while we held it (a settings change) is newer than the one we saved.
+				const applied = this.appliedValues[ key ];
+				if ( applied === undefined || this.material.uniforms[ key ].value === applied ) {
+
+					this.material.uniforms[ key ].value = this.originalValues[ key ];
+
+				}
 
 			}
 
@@ -145,6 +151,7 @@ export class CameraOptimizer {
 
 		this.interactionMode = false;
 		this.originalValues = {}; // Clear stored values
+		this.appliedValues = {};
 
 		// Call exit callback first (this may trigger a reset)
 		if ( this.onExitCallback ) {
@@ -213,7 +220,8 @@ export class CameraOptimizer {
 
 				} else if ( this.material.uniforms[ key ] ) {
 
-					this.material.uniforms[ key ].value = settings[ key ];
+					this.material.uniforms[ key ].value = this._resolveQualityValue( key, settings[ key ] );
+					this.appliedValues[ key ] = this.material.uniforms[ key ].value;
 
 				}
 
@@ -223,6 +231,14 @@ export class CameraOptimizer {
 
 	}
 
+	// A function derives the interaction value from the one it replaces.
+	_resolveQualityValue( key, target ) {
+
+		if ( typeof target !== 'function' ) return target;
+		return target( this.originalValues[ key ] ?? this.material.uniforms[ key ].value );
+
+	}
+
 	/**
      * Set the interaction delay
      * @param {number} delay - Delay in milliseconds

package/src/RenderSettings.js

@@ -63,6 +63,7 @@ const SETTING_ROUTES = {
 	panoramaLonRange: { handler: 'handlePanoramaLonRange', reset: true },
 	panoramaLatRange: { handler: 'handlePanoramaLatRange', reset: true },
 	interactionModeEnabled: { handler: 'handleInteractionModeEnabled', reset: false },
+	interactionRenderScale: { handler: 'handleInteractionRenderScale', reset: false },
 	maxSamples: { handler: 'handleMaxSamples', reset: false },
 	transparentBackground: { handler: 'handleTransparentBackground' },
 	backgroundColor: { handler: 'handleBackgroundColor', reset: true },
@@ -148,6 +149,7 @@ export class RenderSettings extends EventDispatcher {
 	 * @param {Function} [params.reconcileCompletion] - Called when completion limits change
 	 * @param {Object} [params.denoisingManager] - Needed to force ASVGF off under panorama
 	 * @param {Object} [params.cameraManager]    - Needed to force auto-focus manual under panorama
+	 * @param {Function} [params.onInteractionRenderScale] - Applies a new moving-camera render scale
 	 */
 	bind( params ) {
 
@@ -162,7 +164,7 @@ export class RenderSettings extends EventDispatcher {
 	 * Builds handler functions for multi-stage settings that can't
 	 * be routed with a simple uniform forward.
 	 */
-	_buildHandlers( { stages, renderer, resetCallback, reconcileCompletion, denoisingManager, cameraManager } ) {
+	_buildHandlers( { stages, renderer, resetCallback, reconcileCompletion, denoisingManager, cameraManager, onInteractionRenderScale } ) {
 
 		// UniformManager copies into the existing node, so one scratch vector serves every write.
 		const panoScratch = new Vector2();
@@ -279,6 +281,12 @@ export class RenderSettings extends EventDispatcher {
 
 			},
 
+			handleInteractionRenderScale: ( value ) => {
+
+				onInteractionRenderScale?.( value );
+
+			},
+
 		};
 
 	}

package/src/Stages/PathTracer.js

@@ -88,6 +88,8 @@ export class PathTracer extends PathTracerStage {
 		this._lastBounceEnergy = null;
 		// maxBounces the curve was measured at; the curve is ignored once this no longer matches (-1 = none).
 		this._lastBounceCountsBudget = - 1;
+		// Loop length the curve covers; maxBounces alone is not it (free bounces extend the loop).
+		this._lastBounceCountsLoopBound = - 1;
 		this._readbackPending = false;
 		this._readbackEveryNFrames = 4;
 		this._readbackFrameCounter = 0;
@@ -341,7 +343,7 @@ export class PathTracer extends PathTracerStage {
 
 		const maxBounces = this.maxBounces.value;
 		// Transmissive/SSS steps consume iterations without advancing camera-bounce depth, so the loop must run far enough for deep glass/subsurface walks (mirror PathTracerCore); the survivor curve + early-exit break it early on non-SSS scenes.
-		const loopBound = maxBounces + this.transmissiveBounces.value + this.maxSubsurfaceSteps.value;
+		const loopBound = this._bounceLoopBound();
 
 		const frameHeight = this._wfRenderHeight.value;
 		const chunkRows = this._chunkRows;
@@ -356,9 +358,17 @@ export class PathTracer extends PathTracerStage {
 		// new camera-bounce caps the counts are cap-independent, so trust it up to that cutoff (whole curve when
 		// same/decreasing budget; only the [0, oldBudget) overlap when increasing). budget=-1 → cutoff 0 → full
 		// dispatch everywhere. This avoids the full-work spike on every bounce-count change.
+		// A curve measured with a smaller free-bounce budget under-counts survivors at EVERY depth, not
+		// just past its tail, so sizing off it drops the deep glass paths the bigger budget bought.
+		if ( loopBound > this._lastBounceCountsLoopBound ) this._curveSizingValid = false;
+
 		const curve = this._lastBounceCounts;
+		const curveMeasuredThisFar = maxBounces <= this._lastBounceCountsBudget
+			&& loopBound <= this._lastBounceCountsLoopBound;
 		const curveReliableUpto = ( singleChunk && curve )
-			? ( maxBounces <= this._lastBounceCountsBudget ? loopBound + 1 : this._lastBounceCountsBudget )
+			? ( curveMeasuredThisFar
+				? loopBound + 1
+				: Math.min( this._lastBounceCountsBudget, this._lastBounceCountsLoopBound ) )
 			: 0;
 
 		// Blender-style row-band streaming: the fixed-budget path pool processes the image in bands of ≤ chunkRows
@@ -698,6 +708,12 @@ export class PathTracer extends PathTracerStage {
 
 	}
 
+	_bounceLoopBound() {
+
+		return this.maxBounces.value + this.transmissiveBounces.value + this.maxSubsurfaceSteps.value;
+
+	}
+
 	// Async readback of the per-bounce snapshot every N frames; never awaited, so the early-exit uses past-frame data.
 	_maybeReadbackCounters() {
 
@@ -722,7 +738,8 @@ export class PathTracer extends PathTracerStage {
 		// the budget 3 -> 20 doubles the frame's dispatch work (13 -> 26 bounce iterations, 109 -> 214
 		// compute passes) for as long as that lasts. Waiting out the N-frame cadence just extends it, so
 		// re-measure on the next frame instead — same idiom as the mid-motion priming above.
-		if ( this.maxBounces.value !== this._lastBounceCountsBudget ) {
+		if ( this.maxBounces.value !== this._lastBounceCountsBudget
+			|| this._bounceLoopBound() !== this._lastBounceCountsLoopBound ) {
 
 			this._readbackFrameCounter = this._readbackEveryNFrames;
 
@@ -738,6 +755,7 @@ export class PathTracer extends PathTracerStage {
 		this._readbackPending = true;
 		const gen = this._readbackGeneration;
 		const budget = this.maxBounces.value;
+		const measuredLoopBound = this._bounceLoopBound();
 		const n = this._queueManager.MAX_BOUNCE_SNAPSHOTS;
 		this.renderer.getArrayBufferAsync( attr ).then( ( buf ) => {
 
@@ -750,6 +768,7 @@ export class PathTracer extends PathTracerStage {
 				this._lastBounceCounts = all.subarray( 0, n );
 				this._lastBounceEnergy = all.subarray( n, 2 * n );
 				this._lastBounceCountsBudget = budget;
+				this._lastBounceCountsLoopBound = measuredLoopBound;
 				this._curveSizingValid = true;
 
 			}
@@ -834,9 +853,25 @@ export class PathTracer extends PathTracerStage {
 		// (row-major active list → under-coverage of the lower rows → GI band). Force full coverage
 		// until the readback re-measures at the new size; bump the generation so any readback already
 		// in flight (carrying the old-resolution counts) is discarded when it resolves.
-		this._lastBounceCounts = null;
-		this._lastBounceEnergy = null;
-		this._lastBounceCountsBudget = - 1;
+		// The early exit only compares energy against a per-pixel threshold, so the curve rescaled to the
+		// new pixel count keeps it working — nothing re-measures while the camera moves, and the moving-camera
+		// resolution drop would otherwise run every bounce slot. A multi-chunk curve holds only the last band.
+		if ( this._lastBounceCounts && this._numChunks <= 1 && oldW > 0 && oldH > 0 ) {
+
+			const ratio = ( newW * newH ) / ( oldW * oldH );
+			const rescale = ( v ) => Math.min( 0xFFFFFFFF, Math.round( v * ratio ) );
+			this._lastBounceCounts = this._lastBounceCounts.map( rescale );
+			this._lastBounceEnergy = this._lastBounceEnergy.map( rescale );
+
+		} else {
+
+			this._lastBounceCounts = null;
+			this._lastBounceEnergy = null;
+			this._lastBounceCountsBudget = - 1;
+			this._lastBounceCountsLoopBound = - 1;
+
+		}
+
 		this._curveSizingValid = false;
 		this._readbackFrameCounter = 0;
 		this._readbackGeneration ++;

package/src/Stages/PathTracerStage.js

@@ -298,18 +298,6 @@ export class PathTracerStage extends RenderStage {
 		const self = this;
 		const materialInterface = {
 			uniforms: {
-				maxBounceCount: {
-					get value() {
-
-						return self.maxBounces.value;
-
-					},
-					set value( v ) {
-
-						self.maxBounces.value = v;
-
-					}
-				},
 				enableAccumulation: {
 					get value() {
 
@@ -322,15 +310,15 @@ export class PathTracerStage extends RenderStage {
 
 					}
 				},
-				enableEmissiveTriangleSampling: {
+				fireflyThreshold: {
 					get value() {
 
-						return self.enableEmissiveTriangleSampling.value;
+						return self.fireflyThreshold.value;
 
 					},
 					set value( v ) {
 
-						self.enableEmissiveTriangleSampling.value = v;
+						self.fireflyThreshold.value = v;
 
 					}
 				},
@@ -351,11 +339,16 @@ export class PathTracerStage extends RenderStage {
 
 		this.cameraOptimizer = new CameraOptimizer( this.renderer, materialInterface, {
 			enabled: DEFAULT_STATE.interactionModeEnabled,
+			// Nothing that costs light: the app lowers the resolution instead (PathTracerApp._applyRenderScale).
+			// The firefly limit grows with sqrt(frame + 1), and every moving frame is frame 0, where it clipped
+			// ~10% of an emissive-lit interior's light. ×8 is the limit a still image reaches at 64 samples:
+			// lowest large-area error of the values measured, and half the extra grain of turning it off.
 			qualitySettings: {
-				maxBounceCount: 1,
 				enableAccumulation: false,
-				enableEmissiveTriangleSampling: false,
+				fireflyThreshold: ( threshold ) => threshold * 8,
 			},
+			onEnter: () => this.emit( 'pathtracer:interactionStart' ),
+			onExit: () => this.emit( 'pathtracer:interactionEnd' ),
 			onReset: () => {
 
 				this.reset();

package/src/TSL/LightsCore.js

@@ -251,10 +251,15 @@ export const getDistanceAttenuation = /*@__PURE__*/ wgslFn( `
 	}
 ` );
 
-// Spot light attenuation
+// Spot cone falloff, Blender/Cycles' shape: the soft edge is a smoothstep over a band of
+// COSINE width (1 - cosCone) * blend, not one that ends at the inner cone's angle. The two
+// agree at blend 0 and 1 and diverge in between — three.js' ramp ran twice as wide at 0.5,
+// leaving the penumbra up to 2x dark against a Cycles render of the same lamp.
 export const getSpotAttenuation = /*@__PURE__*/ wgslFn( `
-	fn getSpotAttenuation( coneCosine: f32, penumbraCosine: f32, angleCosine: f32 ) -> f32 {
-		return smoothstep( coneCosine, penumbraCosine, angleCosine );
+	fn getSpotAttenuation( coneCosine: f32, blend: f32, angleCosine: f32 ) -> f32 {
+		let smoothWidth = ( 1.0 - coneCosine ) * blend;
+		if ( smoothWidth <= 0.0 ) { return 1.0; }
+		return smoothstep( 0.0, 1.0, ( angleCosine - coneCosine ) / smoothWidth );
 	}
 ` );
 

package/src/TSL/LightsSampling.js

@@ -261,10 +261,7 @@ export const sampleSpotLightWithRadius = Fn( ( [ light, rayOrigin, lightSelectio
 
 		If( ls_valid, () => {
 
-			// Penumbra: inner cone angle = outerAngle * (1 - penumbra)
-			// Clamp penumbraCosAngle > coneCosAngle to avoid smoothstep UB when penumbra = 0
-			const penumbraCosAngle = cos( light.angle.mul( float( 1.0 ).sub( light.penumbra ) ) ).max( coneCosAngle.add( 1e-5 ) ).toVar();
-			const coneAttenuation = getSpotAttenuation( { coneCosine: coneCosAngle, penumbraCosine: penumbraCosAngle, angleCosine: spotCosAngle } );
+			const coneAttenuation = getSpotAttenuation( { coneCosine: coneCosAngle, blend: light.penumbra, angleCosine: spotCosAngle } );
 			const distanceAttenuation = getDistanceAttenuation( { lightDistance: lightDist, cutoffDistance: light.distance, decayExponent: light.decay } );
 
 			// Gobo projection mask + IES photometric profile — both 1.0 when not assigned.