rayzee 4.8.15 → 5.0.0

package/src/managers/InteractionManager.js

@@ -5,6 +5,7 @@ import {
 	Mesh,
 	MeshBasicMaterial
 } from 'three';
+import { EngineEvents } from '../EngineEvents.js';
 
 /**
  * InteractionManager
@@ -65,6 +66,91 @@ export class InteractionManager extends EventDispatcher {
 		this.canvas.addEventListener( 'pointerup', this.handleContextPointerUp );
 		this.canvas.addEventListener( 'contextmenu', this.handleContextMenu );
 
+		// Cross-manager dependencies (injected after init via setDependencies)
+		this._overlayManager = null;
+		this._transformManager = null;
+		this._appDispatch = null;
+		this._orbitControls = null;
+
+	}
+
+	// ==================== CROSS-MANAGER COORDINATION ====================
+
+	/**
+	 * Inject dependencies needed for select/deselect coordination.
+	 * Call once after all managers are created.
+	 *
+	 * @param {Object} deps
+	 * @param {import('./OverlayManager.js').OverlayManager} deps.overlayManager
+	 * @param {import('./TransformManager.js').TransformManager} deps.transformManager
+	 * @param {Function} deps.appDispatch - (event) => dispatches on PathTracerApp
+	 * @param {import('three/addons/controls/OrbitControls.js').OrbitControls} [deps.orbitControls]
+	 */
+	setDependencies( { overlayManager, transformManager, appDispatch, orbitControls } ) {
+
+		this._overlayManager = overlayManager || null;
+		this._transformManager = transformManager || null;
+		this._appDispatch = appDispatch || null;
+		this._orbitControls = orbitControls || null;
+
+	}
+
+	/**
+	 * Programmatically selects an object (or deselects if null).
+	 * Coordinates: outline helper, internal state, transform gizmo, and event dispatch.
+	 * @param {import('three').Object3D|null} object
+	 */
+	select( object ) {
+
+		const outline = this._overlayManager?.getHelper( 'outline' );
+		if ( outline ) outline.setSelectedObjects( object ? [ object ] : [] );
+
+		this.selectedObject = object || null;
+
+		if ( object ) {
+
+			this._transformManager?.attach( object );
+
+		} else {
+
+			this._transformManager?.detach();
+
+		}
+
+		this._appDispatch?.( { type: EngineEvents.OBJECT_SELECTED, object: object || null } );
+
+	}
+
+	/**
+	 * Deselects the current object.
+	 */
+	deselect() {
+
+		this.select( null );
+
+	}
+
+	/**
+	 * Disables selection mode and detaches the transform gizmo.
+	 */
+	disableMode() {
+
+		this.disableSelectMode();
+		this._transformManager?.detach();
+
+	}
+
+	/**
+	 * Subscribes to an interaction event.
+	 * @param {string} type - Event type
+	 * @param {Function} handler - Event handler
+	 * @returns {Function} Unsubscribe function
+	 */
+	on( type, handler ) {
+
+		this.addEventListener( type, handler );
+		return () => this.removeEventListener( type, handler );
+
 	}
 
 	// ==================== FOCUS MODE ====================
@@ -91,6 +177,9 @@ export class InteractionManager extends EventDispatcher {
 
 		}
 
+		// Disable orbit controls when focus mode is active
+		if ( this._orbitControls ) this._orbitControls.enabled = ! this.focusMode;
+
 		// Emit event for external listeners
 		this.dispatchEvent( {
 			type: 'focusModeChanged',
@@ -598,6 +687,59 @@ export class InteractionManager extends EventDispatcher {
 
 	// ==================== LIFECYCLE ====================
 
+	/**
+	 * Wires interaction events to app-level dispatches and side-effects.
+	 * Call once during init after selection sub-API is available on the app.
+	 *
+	 * @param {import('../PathTracerApp.js').PathTracerApp} app
+	 */
+	wireAppEvents( app ) {
+
+		this.addEventListener( 'objectSelected', ( event ) => {
+
+			this.select( event.object );
+			app.refreshFrame();
+			app.dispatchEvent( { type: 'objectSelected', object: event.object, uuid: event.uuid } );
+
+		} );
+
+		this.addEventListener( 'objectDeselected', ( event ) => {
+
+			this.select( null );
+			app.refreshFrame();
+			app.dispatchEvent( { type: 'objectDeselected', object: event.object, uuid: event.uuid } );
+
+		} );
+
+		this.addEventListener( 'selectModeChanged', ( event ) => {
+
+			app.dispatchEvent( { type: EngineEvents.SELECT_MODE_CHANGED, enabled: event.enabled } );
+
+		} );
+
+		this.addEventListener( 'objectDoubleClicked', ( event ) => {
+
+			this.select( event.object );
+			app.refreshFrame();
+			app.dispatchEvent( { type: EngineEvents.OBJECT_DOUBLE_CLICKED, object: event.object, uuid: event.uuid } );
+
+		} );
+
+		this.addEventListener( 'focusChanged', ( event ) => {
+
+			app.settings.set( 'focusDistance', event.worldDistance );
+			app.dispatchEvent( { type: 'focusChanged', distance: event.distance } );
+
+		} );
+
+		this.addEventListener( 'afPointPlaced', ( event ) => {
+
+			app.dispatchEvent( { type: EngineEvents.AF_POINT_PLACED, point: event.point } );
+
+		} );
+
+	}
+
 	/**
 	 * Clean up all event listeners and state
 	 */

package/src/managers/LightManager.js

@@ -15,14 +15,17 @@ export class LightManager extends EventDispatcher {
 	 * @param {import('three').Scene}      scene          - WebGPU light scene
 	 * @param {import('../SceneHelpers.js').SceneHelpers} sceneHelpers
 	 * @param {import('../Stages/PathTracer.js').PathTracer} pathTracer
+	 * @param {Object} [options]
+	 * @param {Function} [options.onReset] - Callback to reset accumulation after light changes
 	 */
-	constructor( scene, sceneHelpers, pathTracer ) {
+	constructor( scene, sceneHelpers, pathTracer, options = {} ) {
 
 		super();
 
 		this.scene = scene;
 		this.sceneHelpers = sceneHelpers;
 		this.pathTracer = pathTracer;
+		this._onReset = options.onReset || null;
 
 	}
 
@@ -78,6 +81,7 @@ export class LightManager extends EventDispatcher {
 		this.scene.add( light );
 		this.updateLights();
 		this._syncHelpers();
+		this._onReset?.();
 
 		return this._buildDescriptor( light );
 
@@ -97,6 +101,7 @@ export class LightManager extends EventDispatcher {
 		if ( light.target ) light.target.removeFromParent();
 		light.removeFromParent();
 		this.updateLights();
+		this._onReset?.();
 		return true;
 
 	}
@@ -109,6 +114,7 @@ export class LightManager extends EventDispatcher {
 		this.sceneHelpers.clear();
 		this._removeAllLights();
 		this.updateLights();
+		this._onReset?.();
 
 	}
 
@@ -205,6 +211,50 @@ export class LightManager extends EventDispatcher {
 
 	}
 
+	// ── Aliases (match Sub-API surface for zero-churn migration) ──
+
+	/** @see addLight */
+	add( type ) {
+
+		return this.addLight( type );
+
+	}
+
+	/** @see removeLight */
+	remove( uuid ) {
+
+		return this.removeLight( uuid );
+
+	}
+
+	/** @see clearLights */
+	clear() {
+
+		this.clearLights();
+
+	}
+
+	/** @see getLights */
+	getAll() {
+
+		return this.getLights();
+
+	}
+
+	/** @see updateLights */
+	sync() {
+
+		this.updateLights();
+
+	}
+
+	/** @see setShowLightHelper */
+	showHelpers( show ) {
+
+		this.setShowLightHelper( show );
+
+	}
+
 	// ── Private ───────────────────────────────────────────────────
 
 	/** Syncs helpers in sceneHelpers with current scene lights. */

package/src/managers/OverlayManager.js

@@ -1,3 +1,7 @@
+import { TileHelper } from './helpers/TileHelper.js';
+import { OutlineHelper } from './helpers/OutlineHelper.js';
+import { EngineEvents } from '../EngineEvents.js';
+
 /**
  * OverlayManager — Unified overlay system for visual helpers.
  *
@@ -63,6 +67,99 @@ export class OverlayManager {
 
 	}
 
+	// ═══════════════════════════════════════════════════════════════
+	// Default helpers setup
+	// ═══════════════════════════════════════════════════════════════
+
+	/**
+	 * Creates and wires the default overlay helpers (tile progress, outline).
+	 * Call once during app init after pipeline and managers are ready.
+	 *
+	 * @param {Object} config
+	 * @param {import('../SceneHelpers.js').SceneHelpers} config.helperScene
+	 * @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 {number} config.renderWidth
+	 * @param {number} config.renderHeight
+	 */
+	setupDefaultHelpers( { helperScene, meshScene, pipeline, denoisingManager, app, renderWidth, renderHeight } ) {
+
+		this.setHelperScene( helperScene );
+
+		// ── Tile helper (shared across path tracer, OIDN, upscaler) ──
+		const tileHelper = new TileHelper();
+		this.register( 'tiles', tileHelper );
+
+		tileHelper.setRenderSize( renderWidth || 1, renderHeight || 1 );
+
+		app.addEventListener( 'resolution_changed', ( e ) => {
+
+			tileHelper.setRenderSize( e.width, e.height );
+
+		} );
+
+		// 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 ──
+		const outlineHelper = new OutlineHelper( this.renderer, meshScene, this.camera );
+		this.register( 'outline', outlineHelper );
+
+	}
+
+	/**
+	 * 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 ) {
+
+		const sources = [ denoisingManager?.denoiser, denoisingManager?.upscaler ];
+
+		for ( const source of sources ) {
+
+			if ( ! source ) continue;
+
+			source.addEventListener( 'tileProgress', ( e ) => {
+
+				if ( e.tile ) {
+
+					tileHelper.setRenderSize( e.imageWidth, e.imageHeight );
+					tileHelper.setActiveTile( e.tile );
+					tileHelper.show();
+					this.refreshHUD();
+
+				}
+
+			} );
+
+			source.addEventListener( 'end', () => {
+
+				tileHelper.hide();
+				this.refreshHUD();
+
+			} );
+
+		}
+
+	}
+
 	// ═══════════════════════════════════════════════════════════════
 	// Helper registration
 	// ═══════════════════════════════════════════════════════════════

package/src/managers/TransformManager.js

@@ -107,6 +107,7 @@ export class TransformManager {
 	setMode( mode ) {
 
 		this._controls.setMode( mode );
+		this._app?.dispatchEvent( { type: EngineEvents.TRANSFORM_MODE_CHANGED, mode } );
 
 	}
 

package/src/managers/VideoRenderManager.js

@@ -87,7 +87,7 @@ export class VideoRenderManager {
 		app.stages.pathTracer?.updateCompletionThreshold?.();
 
 		// Disable camera controls during render
-		if ( app._controls ) app._controls.enabled = false;
+		if ( app.cameraManager.controls ) app.cameraManager.controls.enabled = false;
 
 		try {
 
@@ -132,7 +132,7 @@ export class VideoRenderManager {
 				if ( this._cancelled ) break;
 
 				// 5. Capture frame from output canvas
-				const canvas = app.getOutputCanvas();
+				const canvas = app.getCanvas();
 				if ( canvas && onFrame ) {
 
 					const bitmap = await createImageBitmap( canvas );
@@ -205,7 +205,7 @@ export class VideoRenderManager {
 
 		while ( ! pathTracer.isComplete && ! this._cancelled ) {
 
-			app._camera.updateMatrixWorld();
+			app.cameraManager.camera.updateMatrixWorld();
 			app.pipeline.render();
 
 			// Yield every 4 passes to keep UI responsive and update stats
@@ -280,7 +280,7 @@ export class VideoRenderManager {
 			samplesPerPixel: app.settings.get( 'samplesPerPixel' ),
 			transmissiveBounces: app.settings.get( 'transmissiveBounces' ),
 			renderMode: app.stages.pathTracer?.renderMode?.value,
-			controlsEnabled: app._controls?.enabled,
+			controlsEnabled: app.cameraManager.controls?.enabled,
 			oidnEnabled: app.denoisingManager?.denoiser?.enabled,
 			oidnQuality: app.denoisingManager?.denoiser?.quality,
 			wasPlaying: app.animationManager?.isPlaying,
@@ -306,13 +306,13 @@ export class VideoRenderManager {
 
 		if ( app.stages.pathTracer && state.renderMode !== undefined ) {
 
-			app.setRenderMode( state.renderMode );
+			app.stages.pathTracer?.setUniform( 'renderMode', parseInt( state.renderMode ) );
 
 		}
 
 		app.stages.pathTracer?.updateCompletionThreshold?.();
 
-		if ( app._controls ) app._controls.enabled = state.controlsEnabled ?? true;
+		if ( app.cameraManager.controls ) app.cameraManager.controls.enabled = state.controlsEnabled ?? true;
 
 		if ( app.denoisingManager?.denoiser ) {
 

package/src/managers/helpers/StatsHelper.js

@@ -0,0 +1,45 @@
+import Stats from 'stats-gl';
+
+/**
+ * Creates and configures a stats-gl performance panel.
+ *
+ * @param {import('three/webgpu').WebGPURenderer} renderer
+ * @param {HTMLElement} [container=document.body] - DOM element to mount the stats panel
+ * @returns {Stats}
+ */
+export function createStats( renderer, container ) {
+
+	const stats = new Stats( { horizontal: true, trackGPU: true } );
+	stats.dom.style.position = 'absolute';
+	stats.dom.style.top = 'unset';
+	stats.dom.style.bottom = '48px';
+
+	stats.init( renderer );
+	( container || document.body ).appendChild( stats.dom );
+
+	const foregroundColor = '#ffffff';
+	const backgroundColor = '#1e293b';
+
+	const gradient = stats.fpsPanel.context.createLinearGradient(
+		0, stats.fpsPanel.GRAPH_Y,
+		0, stats.fpsPanel.GRAPH_Y + stats.fpsPanel.GRAPH_HEIGHT
+	);
+	gradient.addColorStop( 0, foregroundColor );
+
+	stats.fpsPanel.fg = stats.msPanel.fg = foregroundColor;
+	stats.fpsPanel.bg = stats.msPanel.bg = backgroundColor;
+	stats.fpsPanel.gradient = stats.msPanel.gradient = gradient;
+
+	if ( stats.gpuPanel ) {
+
+		stats.gpuPanel.fg = foregroundColor;
+		stats.gpuPanel.bg = backgroundColor;
+		stats.gpuPanel.gradient = gradient;
+
+	}
+
+	stats.dom.style.display = '';
+
+	return stats;
+
+}

package/src/api/AnimationAPI.js

@@ -1,87 +0,0 @@
-/**
- * Animation sub-API — playback controls for GLTF animation clips.
- *
- * Access via `engine.animation`.
- *
- * @example
- * engine.animation.play(0);
- * engine.animation.setSpeed(2);
- * console.log(engine.animation.clips);
- */
-export class AnimationAPI {
-
-	/** @param {import('../PathTracerApp.js').PathTracerApp} app */
-	constructor( app ) {
-
-		this._app = app;
-
-	}
-
-	/**
-	 * Plays an animation clip by index.
-	 * @param {number} [clipIndex=0]
-	 */
-	play( clipIndex = 0 ) {
-
-		this._app.playAnimation( clipIndex );
-
-	}
-
-	/**
-	 * Pauses animation, preserving current time position.
-	 */
-	pause() {
-
-		this._app.pauseAnimation();
-
-	}
-
-	/**
-	 * Resumes animation from paused state.
-	 */
-	resume() {
-
-		this._app.resumeAnimation();
-
-	}
-
-	/**
-	 * Stops animation and resets to beginning.
-	 */
-	stop() {
-
-		this._app.stopAnimationPlayback();
-
-	}
-
-	/**
-	 * Sets playback speed multiplier.
-	 * @param {number} speed - 1.0 = normal speed
-	 */
-	setSpeed( speed ) {
-
-		this._app.setAnimationSpeed( speed );
-
-	}
-
-	/**
-	 * Sets loop mode for animation playback.
-	 * @param {boolean} loop - true for repeat, false for play-once
-	 */
-	setLoop( loop ) {
-
-		this._app.setAnimationLoop( loop );
-
-	}
-
-	/**
-	 * Available animation clips.
-	 * @returns {{ index: number, name: string, duration: number }[]}
-	 */
-	get clips() {
-
-		return this._app.animationClips;
-
-	}
-
-}

package/src/api/CameraAPI.js

@@ -1,109 +0,0 @@
-/**
- * Camera sub-API — camera switching, auto-focus, DOF, and raw Three.js access.
- *
- * Access via `engine.camera`.
- *
- * @example
- * engine.camera.switch(1);
- * engine.camera.active.fov = 60;
- * engine.camera.controls.target.set(0, 1, 0);
- */
-export class CameraAPI {
-
-	/** @param {import('../PathTracerApp.js').PathTracerApp} app */
-	constructor( app ) {
-
-		this._app = app;
-
-	}
-
-	/**
-	 * The active Three.js PerspectiveCamera.
-	 * @returns {import('three').PerspectiveCamera}
-	 */
-	get active() {
-
-		return this._app.cameraManager?.camera ?? this._app._camera;
-
-	}
-
-	/**
-	 * The OrbitControls instance.
-	 * @returns {import('three/addons/controls/OrbitControls.js').OrbitControls}
-	 */
-	get controls() {
-
-		return this._app.cameraManager?.controls ?? this._app._controls;
-
-	}
-
-	/**
-	 * Switches the active camera by index.
-	 * @param {number} index
-	 */
-	switch( index ) {
-
-		this._app.switchCamera( index );
-
-	}
-
-	/**
-	 * Returns display names for all available cameras.
-	 * @returns {string[]}
-	 */
-	getNames() {
-
-		return this._app.getCameraNames();
-
-	}
-
-	/**
-	 * Focuses the orbit camera on a world-space point.
-	 * @param {import('three').Vector3} center
-	 */
-	focusOn( center ) {
-
-		this._app.focusOnPoint( center );
-
-	}
-
-	/**
-	 * Sets the auto-focus mode.
-	 * @param {'auto'|'manual'} mode
-	 */
-	setAutoFocusMode( mode ) {
-
-		this._app.cameraManager?.setAutoFocusMode( mode );
-
-	}
-
-	/**
-	 * Sets the normalized AF screen point (0-1 range).
-	 * @param {number} x
-	 * @param {number} y
-	 */
-	setAFScreenPoint( x, y ) {
-
-		this._app.cameraManager?.setAFScreenPoint( x, y );
-
-	}
-
-	/**
-	 * Enters AF point placement interaction mode.
-	 */
-	enterAFPointPlacementMode() {
-
-		this._app.cameraManager?.enterAFPointPlacementMode();
-
-	}
-
-	/**
-	 * Exits AF point placement interaction mode.
-	 */
-	exitAFPointPlacementMode() {
-
-		this._app.cameraManager?.exitAFPointPlacementMode();
-
-	}
-
-}