rayzee 8.4.1 → 8.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "8.4.1",
+  "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

@@ -10,11 +10,13 @@
  */
 export const RENDER_PROFILES = Object.freeze( {
 	viewer: Object.freeze( {
+		areaLightIntensityScale: 0.1, // scales glTF placeholder area-light power (viewer tuning)
 		environmentRotation: 270.0, // degrees
 		toneMapping: 4, // ACESFilmicToneMapping
 		saturation: 1.2, // compensates for ACES desaturation — see Compositor
 	} ),
 	physical: Object.freeze( {
+		areaLightIntensityScale: 1.0,
 		environmentRotation: 0.0,
 		// AgX, matching Blender/Cycles' default view transform. ACES crushes shadows on this
 		// engine's own corpus (shade 1.48 vs AgX 3.01 from identical radiance).
@@ -25,7 +27,7 @@ export const RENDER_PROFILES = Object.freeze( {
 
 /**
  * @param {string} [name] - a RENDER_PROFILES key
- * @returns {{environmentRotation: number, toneMapping: number, saturation: number}}
+ * @returns {{areaLightIntensityScale: number, environmentRotation: number}}
  * @throws {Error} on an unknown name — a typo must not silently select viewer tuning
  */
 export function getRenderProfile( name = 'viewer' ) {
@@ -208,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
@@ -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/EngineIssues.js

@@ -19,7 +19,6 @@ export const ISSUE_CODES = Object.freeze( {
 	STAGE_RENDER_FAILED: 'stage.render_failed',
 	RENDER_RESERVE_CAPPED: 'render.reserve_capped',
 	SCENE_MEMORY_BUDGET: 'scene.memory_budget',
-	LIGHT_PLACEHOLDER_INVALID: 'light.placeholder_invalid',
 	EMISSIVE_INSTANCES_COLLAPSED: 'emissive.instances_collapsed',
 	REFIT_SHARED_GEOMETRY: 'refit.shared_geometry',
 } );

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 ) {
@@ -764,9 +772,8 @@ export class PathTracerApp extends EventDispatcher {
 	 * by reference, and any ancestor transform is baked in. Later edits to `object3d` do not
 	 * reach the render — mutate {@link sceneModel}, then {@link refitBVH}/{@link refitBLASes}.
 	 *
-	 * Lights are read as three.js lights in RADIOMETRIC units — W/sr for point and spot, W/m² for
-	 * directional, radiance for area — and are left as they are; only an area light's rectangle is
-	 * put into world metres on the copy. See `LightUnits.js`.
+	 * Lights keep three.js units — `RectAreaLight.intensity` in nits, point/spot in candela — and are
+	 * converted to radiant power on the copy. `areaLightIntensityScale` does not apply here.
 	 *
 	 * @param {import('three').Object3D} object3d - The Object3D to render; left untouched.
 	 * @param {string} [name='object3d'] - Display name for the object
@@ -1813,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;
@@ -1834,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;
 
@@ -1857,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 );
@@ -1868,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
 	// ═══════════════════════════════════════════════════════════════
@@ -1890,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 ) );
@@ -2015,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()`.
 	 *
@@ -3028,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();
 
 		} );
@@ -3054,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() {
@@ -3176,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

@@ -19,7 +19,6 @@ import { getAssetConfig } from '../AssetConfig.js';
 import { loadPBRTScene, pickEntryPath } from './PBRT/index.js';
 import { extractSceneMetadata } from './SceneMetadata.js';
 import { ISSUE_CODES, ISSUE_SEVERITY } from '../EngineIssues.js';
-import { bakeAreaLightScale, LUMENS_PER_WATT } from '../LightUnits.js';
 import { getRenderProfile } from '../EngineDefaults.js';
 
 // Define supported file formats
@@ -68,43 +67,19 @@ function standInForSplit( source ) {
 
 }
 
-const PLACEHOLDER_SHAPES = new Set( [ 'rectangle', 'square', 'disk', 'ellipse' ] );
+// Luminous efficacy glTF, three.js and Blender's exporter all assume (PBR_WATTS_TO_LUMENS).
+const LUMENS_PER_WATT = 683;
 
-/**
- * Build the light a placeholder node stands for. glTF has no area light, so a three.js host's
- * patched GLTFExporter writes the RectAreaLight into the node's `extras` and leaves the node
- * itself carrying the transform. `intensity` is three.js radiance, which is what the engine
- * stores, so the number is used as authored; only the rectangle needs normalising to world
- * metres (see `bakeAreaLightScale`).
- *
- * `power`, `position`, `rotation` and `direction` are present in the record and deliberately
- * unused. The node's matrix already carries the transform, `direction` is not even normalised,
- * and `power` was written from the light's UNSCALED dimensions — on 24155522.glb's window light,
- * whose ancestor scale is non-uniform (1.6 × 1.2 m in world, not 1.2 × 1.2), it is 25 % low.
- *
- * @returns {RectAreaLight|null} null when the record carries no usable size or intensity.
- */
-function areaLightFromPlaceholder( node, record ) {
+// three.js nits → the engine's radiant power, inverting areaLightRadiance.
+function areaLightPowerFactor( node, width, height, userData ) {
 
-	const width = Number( record.width );
-	const height = Number( record.height );
-	const intensity = Number( record.intensity );
-	if ( ! ( width > 0 ) || ! ( height > 0 ) || ! Number.isFinite( intensity ) ) return null;
+	if ( ! ( userData.normalize ?? true ) ) return Math.PI;
 
-	const shape = PLACEHOLDER_SHAPES.has( record.shape ) ? record.shape : 'rectangle';
-	const color = Array.isArray( record.color ) && record.color.length >= 3 ? record.color : [ 1, 1, 1 ];
-
-	const light = new RectAreaLight( new Color( ...color ), intensity, width, height );
-	light.name = record.name || 'RectAreaLight';
-	light.userData.normalize = record.normalize ?? true;
-	light.userData.spread = Number.isFinite( record.spread ) ? record.spread : Math.PI;
-	light.userData.shape = shape;
-
-	// Parented before baking: the bake needs the node's world scale, and on the append path
-	// nothing has refreshed the tree yet.
-	node.add( light );
-	bakeAreaLightScale( light );
-	return light;
+	const shapeFactor = userData.shape === 'ellipse' || userData.shape === 'disk' ? Math.PI / 4 : 1;
+	const scale = node.getWorldScale( new Vector3() );
+	// abs: a mirrored ancestor decomposes negative; the serializer takes the area as |u × v|.
+	const factor = Math.PI * shapeFactor * Math.abs( width * scale.x * height * scale.y );
+	return Number.isFinite( factor ) ? factor : Math.PI;
 
 }
 
@@ -2109,18 +2084,22 @@ export class AssetLoader extends EventDispatcher {
 
 			const userData = object.userData;
 
-			// three.js states RectAreaLight.intensity as radiance, which is what the engine
-			// stores, so only the rectangle needs putting into world metres.
-			if ( object.isRectAreaLight ) bakeAreaLightScale( object );
+			// An adopted light carries three.js units; convert as point/spot are below.
+			if ( object.isRectAreaLight && ! userData.__radianceConverted ) {
+
+				object.intensity *= areaLightPowerFactor( object, object.width, object.height, userData );
+				userData.__radianceConverted = true;
+
+			}
 
 			// Punctual lights arrive photometric: glTF (and three.js) state point/spot in
-			// candela and directional in lux. The engine keeps the same QUANTITY in radiometric
-			// units — W/sr and W/m² — so only the luminous efficacy is divided back out, which
-			// is what Blender's own glTF importer does. Skipping it rendered every Blender lamp
-			// 683x too bright.
+			// 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 /= LUMENS_PER_WATT;
+				object.intensity *= 4 * Math.PI / LUMENS_PER_WATT;
 				userData.__candelaConverted = true;
 
 			}
@@ -2132,17 +2111,31 @@ export class AssetLoader extends EventDispatcher {
 
 			}
 
-			// An area light serialized into a placeholder node. Keyed on the record's own type
-			// rather than the node's name, so a renamed placeholder still lights the scene.
-			if ( userData.type === 'RectAreaLight' ) {
+			// Process ceiling lights
+			if ( object.name.startsWith( 'RectAreaLightPlaceholder' ) &&
+				userData.name
+				// && userData.name.includes( "ceilingLight" )
+			) {
+
+				if ( userData.type === 'RectAreaLight' ) {
+
+					const normalize = userData.normalize ?? true;
+					const shape = userData.shape ?? 'rectangle';
+					const power = userData.intensity * areaLightPowerFactor( object, userData.width, userData.height, userData );
+					const light = new RectAreaLight(
+						new Color( ...userData.color ),
+						power * this._profile.areaLightIntensityScale,
+						userData.width,
+						userData.height
+					);
+					light.userData.normalize = normalize;
+					light.userData.spread = Number.isFinite( userData.spread ) ? userData.spread : Math.PI;
+					light.userData.shape = shape;
+					light.userData.__radianceConverted = true; // already power, and traverse() reaches it
+					light.name = userData.name;
+					object.add( light );
 
-				const light = areaLightFromPlaceholder( object, userData );
-				if ( ! light ) this._issues?.record(
-					ISSUE_CODES.LIGHT_PLACEHOLDER_INVALID,
-					`area-light placeholder "${object.name}" carries no usable size or intensity`,
-					{ node: object.name, record: userData },
-					ISSUE_SEVERITY.WARNING,
-				);
+				}
 
 			}
 

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/Processor/LightSerializer.js

@@ -1,11 +1,10 @@
 import { Vector3, Quaternion } from 'three';
 import { blackbodyToLinearRGB } from './blackbody.js';
-import { lightPower } from '../LightUnits.js';
 
-// Scene lights hold the three.js quantity in radiometric units (see LightUnits.js): point and
-// spot in W/sr, the Sun in W/m², area lights in radiance. The GPU buffer wants radiant intensity
-// for point/spot — already what they hold — and radiant POWER for area lights, which the shader
-// turns back into radiance with its own π·area. This is where that adaptation happens.
+// Point & spot lights specify Power in Watts; the shader uses radiant intensity
+// (W/sr) as `intensity / dist²`, so convert with I = P / 4π (isotropic emitter),
+// matching Blender. Area lights are already radiant power; the Sun is irradiance.
+const INV_4PI = 1 / ( 4 * Math.PI );
 
 // Effective emission colour + intensity after per-light Exposure (EV stops) and
 // optional blackbody Temperature tint (Blender-style). Both fold into the values
@@ -62,10 +61,9 @@ export class LightSerializer {
 
 	calculateLightImportance( light, type = 'directional' ) {
 
-		// Ranked on Power, so the ordering does not shift when a light type's stored quantity
-		// differs from what the panel shows.
+		// Calculate luminance-weighted importance
 		const luminance = 0.2126 * light.color.r + 0.7152 * light.color.g + 0.0722 * light.color.b;
-		let importance = lightPower( light ) * luminance;
+		let importance = light.intensity * luminance;
 
 		// Area lights get additional importance based on size
 		if ( type === 'area' ) {
@@ -174,12 +172,6 @@ export class LightSerializer {
 
 		const em = effectiveEmission( light );
 
-		// The shader recovers radiance as power/(π·area), so hand it the power that inverts to
-		// the radiance the light holds. Area is measured off u/v exactly as the shader does it.
-		const rectArea = 4 * u.clone().cross( v ).length();
-		const emittingArea = shape > 0.5 ? rectArea * Math.PI / 4 : rectArea;
-		const power = em.intensity * Math.PI * ( normalize > 0.5 ? emittingArea : 1 );
-
 		// Store in cache with importance (16 floats, vec4-aligned)
 		this.areaLightCache.push( {
 			data: [
@@ -187,7 +179,7 @@ export class LightSerializer {
 				u.x, u.y, u.z, // u half-vector (3)
 				v.x, v.y, v.z, // v half-vector (3)
 				em.r, em.g, em.b, // color (3) — incl. temperature tint
-				power, // radiant power in Watts (1) — incl. exposure
+				em.intensity, // radiant power in Watts (1) — incl. exposure
 				normalize, // power-normalize flag (1)
 				spread, // emission spread in radians (1)
 				shape, // 0 = rect, 1 = disk/ellipse (1)
@@ -217,7 +209,7 @@ export class LightSerializer {
 			data: [
 				position.x, position.y, position.z, // position (3)
 				em.r, em.g, em.b, // color (3) — incl. temperature tint
-				em.intensity, // radiant intensity W/sr, incl. exposure (1)
+				em.intensity * INV_4PI, // radiant intensity W/sr = power(W)/4π, incl. exposure (1)
 				light.distance || 0.0, // cutoff distance (0 = infinite) (1)
 				light.decay !== undefined ? light.decay : 2.0 // decay exponent (1)
 			],
@@ -260,7 +252,7 @@ export class LightSerializer {
 				position.x, position.y, position.z, // position (3)
 				direction.x, direction.y, direction.z, // direction (3)
 				em.r, em.g, em.b, // color (3) — incl. temperature tint
-				em.intensity, // radiant intensity W/sr, incl. exposure (1)
+				em.intensity * INV_4PI, // radiant intensity W/sr = power(W)/4π, incl. exposure (1)
 				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)

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

@@ -853,10 +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;
-		this._lastBounceCountsLoopBound = - 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 ++;