rayzee 4.8.14 → 5.0.0

package/src/managers/CameraManager.js

@@ -1,30 +1,38 @@
-import { EventDispatcher, Vector3 } from 'three';
+import { EventDispatcher, PerspectiveCamera, Vector3 } from 'three';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 import { EngineEvents, } from '../EngineEvents.js';
 import { AF_DEFAULTS } from '../EngineDefaults.js';
 
 /**
- * Manages camera switching, auto-focus, and AF point placement.
+ * Manages camera creation, switching, auto-focus, and AF point placement.
  *
- * Extracted from PathTracerApp to keep the facade slim.
+ * Owns the PerspectiveCamera and OrbitControls instances.
  * Dispatches events that PathTracerApp relays to external consumers.
  */
 export class CameraManager extends EventDispatcher {
 
 	/**
-	 * @param {import('three').PerspectiveCamera} camera
-	 * @param {import('three/addons/controls/OrbitControls.js').OrbitControls} controls
-	 * @param {import('./InteractionManager.js').InteractionManager} interactionManager
+	 * @param {HTMLCanvasElement} canvas - Canvas element for orbit controls
 	 */
-	constructor( camera, controls, interactionManager ) {
+	constructor( canvas ) {
 
 		super();
 
-		this.camera = camera;
-		this.controls = controls;
-		this.interactionManager = interactionManager;
+		const width = canvas.clientWidth;
+		const height = canvas.clientHeight;
+
+		this.camera = new PerspectiveCamera( 60, width / height || 1, 0.01, 1000 );
+		this.camera.position.set( 0, 0, 5 );
+
+		this.controls = new OrbitControls( this.camera, canvas );
+		this.controls.screenSpacePanning = true;
+		this.controls.zoomToCursor = true;
+		this.controls.saveState();
+
+		this.interactionManager = null;
 
 		/** @type {import('three').PerspectiveCamera[]} */
-		this.cameras = [ camera ];
+		this.cameras = [ this.camera ];
 		this.currentCameraIndex = 0;
 
 		// Auto-focus state
@@ -38,6 +46,11 @@ export class CameraManager extends EventDispatcher {
 		// Saved state for default camera when switching to model cameras
 		this._defaultCameraState = null;
 
+		// Callbacks injected by PathTracerApp
+		this._onResize = null;
+		this._onReset = null;
+		this._getSettings = null;
+
 	}
 
 	/**
@@ -67,15 +80,38 @@ export class CameraManager extends EventDispatcher {
 
 	}
 
+	/**
+	 * Stores callbacks for camera operations (resize, reset, settings access).
+	 * Call once after all managers are ready.
+	 *
+	 * @param {Object} callbacks
+	 * @param {Function} callbacks.onResize   - Trigger viewport resize
+	 * @param {Function} callbacks.onReset    - Trigger accumulation reset
+	 * @param {Function} callbacks.getSettings - (key) => value
+	 */
+	initCallbacks( { onResize, onReset, getSettings } ) {
+
+		this._onResize = onResize;
+		this._onReset = onReset;
+		this._getSettings = getSettings;
+
+	}
+
 	/**
 	 * Switches the active camera by index.
+	 * Uses stored callbacks from initCallbacks() for resize/reset.
 	 * @param {number} index
-	 * @param {number} focusDistance - Current focus distance (for orbit target placement)
-	 * @param {Function} onResize   - Callback to trigger resize after camera change
-	 * @param {Function} onReset    - Callback to trigger accumulation reset
+	 * @param {number} [focusDistance] - Override focus distance (falls back to settings)
+	 * @param {Function} [onResize]   - Override resize callback
+	 * @param {Function} [onReset]    - Override reset callback
 	 */
 	switchCamera( index, focusDistance, onResize, onReset ) {
 
+		// Use stored callbacks if not provided (backward-compatible signature)
+		focusDistance = focusDistance ?? this._getSettings?.( 'focusDistance' );
+		onResize = onResize ?? this._onResize;
+		onReset = onReset ?? this._onReset;
+
 		if ( ! this.cameras || this.cameras.length === 0 ) return;
 
 		if ( index < 0 || index >= this.cameras.length ) {
@@ -150,6 +186,35 @@ export class CameraManager extends EventDispatcher {
 
 	}
 
+	/**
+	 * Focuses the orbit camera on a world-space point.
+	 * @param {import('three').Vector3} center
+	 */
+	focusOn( center ) {
+
+		if ( ! center || ! this.controls ) return;
+		this.controls.target.copy( center );
+		this.controls.update();
+		this._onReset?.();
+
+	}
+
+	// ── Aliases (match Sub-API surface) ───────────────────────────
+
+	/** The active Three.js PerspectiveCamera. */
+	get active() {
+
+		return this.camera;
+
+	}
+
+	/** @see getCameraNames */
+	getNames() {
+
+		return this.getCameraNames();
+
+	}
+
 	// ── Auto-Focus ────────────────────────────────────────────────
 
 	setAutoFocusMode( mode ) {
@@ -201,7 +266,10 @@ export class CameraManager extends EventDispatcher {
 	 * @param {Function} params.softReset       - Callback for soft accumulation reset
 	 * @param {Function} params.hardReset       - Callback for hard accumulation reset
 	 */
-	updateAutoFocus( { meshScene, assetLoader, floorPlane, currentFocusDistance, pathTracer, setFocusDistance, softReset, hardReset } ) {
+	updateAutoFocus( ctx ) {
+
+		const { meshScene, assetLoader, floorPlane, currentFocusDistance, pathTracer, setFocusDistance, softReset, hardReset } = ctx || this._afContext || {};
+		if ( ! meshScene ) return;
 
 		if ( this.autoFocusMode === 'manual' ) return;
 
@@ -303,4 +371,54 @@ export class CameraManager extends EventDispatcher {
 
 	}
 
+	/**
+	 * Deferred dependency injection — InteractionManager needs the camera
+	 * in its constructor, so it can't be passed during CameraManager creation.
+	 * @param {import('./InteractionManager.js').InteractionManager} interactionManager
+	 */
+	setInteractionManager( interactionManager ) {
+
+		this.interactionManager = interactionManager;
+
+	}
+
+	/**
+	 * Initialises the stable auto-focus context. Call once after all
+	 * managers and stages are ready. CameraManager stores the context
+	 * and `updateAutoFocus()` reads from it each frame — no per-frame allocation.
+	 *
+	 * @param {Object} deps
+	 * @param {import('three').Scene}           deps.meshScene
+	 * @param {import('../Processor/AssetLoader.js').AssetLoader} deps.assetLoader
+	 * @param {import('three').Mesh}            deps.floorPlane
+	 * @param {import('../Stages/PathTracer.js').PathTracer} deps.pathTracer
+	 * @param {import('../RenderSettings.js').RenderSettings} deps.settings
+	 * @param {Function}                        deps.softReset
+	 * @param {Function}                        deps.hardReset
+	 */
+	initAutoFocus( { meshScene, assetLoader, floorPlane, pathTracer, settings, softReset, hardReset } ) {
+
+		this._afContext = {
+			meshScene,
+			assetLoader,
+			floorPlane,
+			pathTracer,
+			setFocusDistance: ( d ) => settings.set( 'focusDistance', d, { silent: true } ),
+			softReset,
+			hardReset,
+		};
+
+		// Live getter — reads current value without allocation
+		Object.defineProperty( this._afContext, 'currentFocusDistance', {
+			get: () => settings.get( 'focusDistance' ),
+		} );
+
+	}
+
+	dispose() {
+
+		this.controls?.dispose();
+
+	}
+
 }

package/src/managers/DenoisingManager.js

@@ -20,7 +20,7 @@ export class DenoisingManager extends EventDispatcher {
 	/**
 	 * @param {Object} params
 	 * @param {import('three/webgpu').WebGPURenderer} params.renderer
-	 * @param {HTMLCanvasElement|null}                 params.denoiserCanvas
+	 * @param {HTMLCanvasElement}                      params.mainCanvas  - The primary rendering canvas
 	 * @param {import('three').Scene}                  params.scene
 	 * @param {import('three').PerspectiveCamera}      params.camera
 	 * @param {Object}                                 params.stages     - Named references to pipeline stages
@@ -29,12 +29,13 @@ export class DenoisingManager extends EventDispatcher {
 	 * @param {Function}                               params.getSaturation     - () => current saturation value
 	 * @param {Function}                               params.getTransparentBg  - () => boolean
 	 */
-	constructor( { renderer, denoiserCanvas, scene, camera, stages, pipeline, getExposure, getSaturation, getTransparentBg } ) {
+	constructor( { renderer, mainCanvas, scene, camera, stages, pipeline, getExposure, getSaturation, getTransparentBg } ) {
 
 		super();
 
 		this.renderer = renderer;
-		this.denoiserCanvas = denoiserCanvas;
+		this.mainCanvas = mainCanvas;
+		this.denoiserCanvas = this._createDenoiserCanvas( mainCanvas );
 		this.scene = scene;
 		this.camera = camera;
 		this.pipeline = pipeline;
@@ -49,6 +50,74 @@ export class DenoisingManager extends EventDispatcher {
 		this.denoiser = null;
 		this.upscaler = null;
 
+		// Resolution tracking — used for canvas restoration on reset
+		this._lastRenderWidth = 0;
+		this._lastRenderHeight = 0;
+
+	}
+
+	_createDenoiserCanvas( mainCanvas ) {
+
+		const parent = mainCanvas.parentNode;
+		if ( ! parent ) return null;
+
+		const dc = document.createElement( 'canvas' );
+		dc.width = mainCanvas.width;
+		dc.height = mainCanvas.height;
+		dc.style.width = `${mainCanvas.clientWidth}px`;
+		dc.style.height = `${mainCanvas.clientHeight}px`;
+
+		parent.insertBefore( dc, mainCanvas );
+		return dc;
+
+	}
+
+	/**
+	 * Updates the render resolution and propagates to denoiser/upscaler.
+	 * @param {number} width
+	 * @param {number} height
+	 */
+	setRenderSize( width, height ) {
+
+		this._lastRenderWidth = width;
+		this._lastRenderHeight = height;
+		this.denoiser?.setSize( width, height );
+		this.upscaler?.setBaseSize( width, height );
+
+	}
+
+	/**
+	 * Syncs the denoiser canvas CSS dimensions to match display size.
+	 * @param {number} width
+	 * @param {number} height
+	 */
+	syncCanvasStyle( width, height ) {
+
+		if ( this.denoiserCanvas ) {
+
+			this.denoiserCanvas.style.width = `${width}px`;
+			this.denoiserCanvas.style.height = `${height}px`;
+
+		}
+
+	}
+
+	/**
+	 * Restores the denoiser canvas to base render resolution after upscaling.
+	 * @returns {boolean} true if the canvas was resized
+	 */
+	restoreBaseResolution() {
+
+		if ( ! this.denoiserCanvas || ! this._lastRenderWidth || ! this._lastRenderHeight ) return false;
+
+		const wasResized = this.denoiserCanvas.width !== this._lastRenderWidth
+			|| this.denoiserCanvas.height !== this._lastRenderHeight;
+
+		this.denoiserCanvas.width = this._lastRenderWidth;
+		this.denoiserCanvas.height = this._lastRenderHeight;
+
+		return wasResized;
+
 	}
 
 	/**
@@ -374,10 +443,227 @@ export class DenoisingManager extends EventDispatcher {
 
 		}
 
+		if ( this.denoiserCanvas?.parentNode ) {
+
+			this.denoiserCanvas.parentNode.removeChild( this.denoiserCanvas );
+			this.denoiserCanvas = null;
+
+		}
+
+	}
+
+	// ── Injected Dependencies (set after construction) ───────────
+
+	/** @param {import('./OverlayManager.js').OverlayManager} overlayManager */
+	setOverlayManager( overlayManager ) {
+
+		this._overlayManager = overlayManager;
+
+	}
+
+	/** @param {Function} fn - () => void, triggers accumulation reset */
+	setResetCallback( fn ) {
+
+		this._onReset = fn;
+
+	}
+
+	/** @param {import('../RenderSettings.js').RenderSettings} settings */
+	setSettings( settings ) {
+
+		this._settings = settings;
+
+	}
+
+	// ── Stage Parameter Forwarding ───────────────────────────────
+	// These methods match the DenoisingAPI surface so call sites need
+	// zero or minimal changes after facade removal.
+
+	/** Updates ASVGF stage parameters. */
+	setASVGFParams( params ) {
+
+		this._stages.asvgf?.updateParameters( params );
+
+	}
+
+	/** Toggles the ASVGF heatmap debug overlay. */
+	toggleASVGFHeatmap( enabled ) {
+
+		this._stages.asvgf?.toggleHeatmap?.( enabled );
+
+	}
+
+	/**
+	 * Configures ASVGF for a specific render mode (multi-stage coordination).
+	 * @param {Object} config - { enabled, temporalAlpha, atrousIterations, ... }
+	 */
+	configureASVGFForMode( config ) {
+
+		if ( ! this._stages.asvgf ) return;
+
+		this._stages.asvgf.enabled = config.enabled;
+		if ( this._stages.variance ) this._stages.variance.enabled = config.enabled;
+		if ( this._stages.bilateralFilter ) this._stages.bilateralFilter.enabled = config.enabled;
+
+		if ( config.enabled ) {
+
+			this._stages.asvgf.updateParameters( config );
+
+		}
+
+	}
+
+	/** Updates SSRC stage parameters. */
+	setSSRCParams( params ) {
+
+		this._stages.ssrc?.updateParameters( params );
+
+	}
+
+	/** Updates edge-aware filtering parameters. */
+	setEdgeAwareParams( params ) {
+
+		this._stages.edgeFilter?.updateUniforms( params );
+
+	}
+
+	/** Updates auto-exposure stage parameters. */
+	setAutoExposureParams( params ) {
+
+		this._stages.autoExposure?.updateParameters( params );
+
+	}
+
+	/**
+	 * Updates adaptive sampling parameters (with settings bridge).
+	 * @param {Object} params
+	 */
+	setAdaptiveSamplingParams( params ) {
+
+		if ( params.min !== undefined ) this._stages.pathTracer?.setAdaptiveSamplingMin( params.min );
+		if ( params.adaptiveSamplingMax !== undefined ) this._settings?.set( 'adaptiveSamplingMax', params.adaptiveSamplingMax );
+		this._stages.adaptiveSampling?.setAdaptiveSamplingParameters( params );
+
+	}
+
+	/** Toggles the adaptive sampling debug helper. */
+	toggleAdaptiveSamplingHelper( enabled ) {
+
+		this._stages.adaptiveSampling?.toggleHelper( enabled );
+
+	}
+
+	// ── OIDN ─────────────────────────────────────────────────────
+
+	/** Enables or disables Intel OIDN denoiser. */
+	setOIDNEnabled( enabled ) {
+
+		if ( this.denoiser ) this.denoiser.enabled = enabled;
+
+	}
+
+	/** Sets OIDN denoiser quality. */
+	setOIDNQuality( quality ) {
+
+		this.denoiser?.updateQuality( quality );
+
+	}
+
+	/** Enables or disables the OIDN tile helper overlay. */
+	setOIDNTileHelper( enabled ) {
+
+		this._setTileHelper( enabled );
+
+	}
+
+	/** Enables or disables the tile helper overlay. */
+	setTileHelperEnabled( enabled ) {
+
+		this._setTileHelper( enabled );
+
+	}
+
+	/** Enables or disables tile highlight. */
+	setTileHighlightEnabled( enabled ) {
+
+		this._setTileHelper( enabled );
+
+	}
+
+	// ── AI Upscaler ──────────────────────────────────────────────
+
+	/** Enables or disables the AI upscaler. */
+	setUpscalerEnabled( enabled ) {
+
+		if ( this.upscaler ) this.upscaler.enabled = enabled;
+
+	}
+
+	/** Sets the upscaler scale factor. */
+	setUpscalerScaleFactor( factor ) {
+
+		this.upscaler?.setScaleFactor( factor );
+
+	}
+
+	/** Sets the upscaler quality level. */
+	setUpscalerQuality( quality ) {
+
+		this.upscaler?.setQuality( quality );
+
+	}
+
+	// ── Convenience (match DenoisingAPI names with reset) ────────
+
+	/**
+	 * Enables or disables auto-exposure (convenience wrapper).
+	 * @param {boolean} enabled
+	 */
+	setAutoExposure( enabled ) {
+
+		this.setAutoExposureEnabled( enabled, this._getExposure() );
+		this._onReset?.();
+
+	}
+
+	/**
+	 * 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
+	 * @param {string} [asvgfPreset]
+	 */
+	setStrategy( strategy, asvgfPreset ) {
+
+		this.setDenoiserStrategy( strategy, asvgfPreset );
+		this._onReset?.();
+
 	}
 
 	// ── Private ───────────────────────────────────────────────────
 
+	_setTileHelper( enabled ) {
+
+		const tileHelper = this._overlayManager?.getHelper( 'tiles' );
+		if ( tileHelper ) {
+
+			tileHelper.enabled = enabled;
+			if ( ! enabled ) tileHelper.hide();
+
+		}
+
+	}
+
+
 	_getEffectiveExposure() {
 
 		return this._stages.autoExposure?.enabled

package/src/managers/EnvironmentManager.js

@@ -78,10 +78,103 @@ export class EnvironmentManager {
 
 		/**
 		 * Optional callbacks set by the owning stage.
-		 * @type {{ onReset?: Function, getSceneTextureNodes?: Function }}
+		 * @type {{ onReset?: Function, onAutoExposureReset?: Function, getSceneTextureNodes?: Function }}
 		 */
 		this.callbacks = {};
 
+		// Mode state machine (absorbed from EnvironmentAPI)
+		this._previousHDRI = null;
+
+	}
+
+	// ===== MODE STATE MACHINE =====
+
+	/**
+	 * Switches the environment mode (hdri, gradient, color, procedural).
+	 * Preserves the HDRI texture when switching away, restores when switching back.
+	 * @param {'hdri'|'gradient'|'color'|'procedural'} mode
+	 */
+	async setMode( mode ) {
+
+		const prev = this.envParams.mode;
+		this.envParams.mode = mode;
+
+		// Cache HDRI texture when leaving HDRI mode
+		if ( mode !== 'hdri' && prev === 'hdri' ) {
+
+			this._previousHDRI = this.environmentTexture;
+
+		}
+
+		if ( mode === 'gradient' ) {
+
+			await this.generateGradientTexture();
+
+		} else if ( mode === 'color' ) {
+
+			await this.generateSolidColorTexture();
+
+		} else if ( mode === 'procedural' ) {
+
+			await this.generateProceduralSkyTexture();
+
+		} else if ( mode === 'hdri' && this._previousHDRI ) {
+
+			await this.setEnvironmentMap( this._previousHDRI );
+			this._previousHDRI = null;
+
+		}
+
+		this.markDirty();
+		this.callbacks.onAutoExposureReset?.();
+		this._notifyReset();
+
+	}
+
+	/**
+	 * Marks the environment texture as needing GPU re-upload on the next frame.
+	 */
+	markDirty() {
+
+		if ( this.environmentTexture ) this.environmentTexture.needsUpdate = true;
+
+	}
+
+	// ===== Aliases (match Sub-API surface for zero-churn migration) =====
+
+	/** @see envParams */
+	get params() {
+
+		return this.envParams;
+
+	}
+
+	/** @see environmentTexture */
+	get texture() {
+
+		return this.environmentTexture;
+
+	}
+
+	/** @see generateGradientTexture */
+	generateGradient() {
+
+		return this.generateGradientTexture();
+
+	}
+
+	/** @see generateSolidColorTexture */
+	generateSolid() {
+
+		return this.generateSolidColorTexture();
+
+	}
+
+	/** @see generateProceduralSkyTexture */
+	generateProcedural() {
+
+		return this.generateProceduralSkyTexture();
+
 	}
 
 	// ===== CDF STORAGE BUFFERS =====