rayzee 8.6.0 → 8.7.0

package/src/managers/AnimationManager.js

@@ -1,12 +1,13 @@
 /**
- * AnimationManager — Drives GLTF skeletal/morph animations for BVH refit.
+ * AnimationManager — Drives animation clips for the path tracer.
  *
- * Owns the Three.js AnimationMixer, advances clips each frame,
- * extracts deformed vertex positions via CPU skinning, and returns
- * a per-mesh reader in the shape PathTracerApp.refitBVH() accepts.
+ * Deforming clips (a SkinnedMesh or morph track) return a per-mesh position reader for
+ * PathTracerApp.refitBVH(). Rigid clips return nothing and hand the moved meshes to
+ * `applyPoseCallback`, which updates placements only — a refit would bake world positions into
+ * triangles that other placements share.
  */
 
-import { AnimationMixer, EventDispatcher, Timer, Vector3, LoopRepeat, LoopOnce } from 'three';
+import { AnimationMixer, EventDispatcher, Timer, Vector3, LoopRepeat, LoopOnce, PropertyBinding } from 'three';
 import { EngineEvents } from '../EngineEvents.js';
 
 export class AnimationManager extends EventDispatcher {
@@ -31,9 +32,20 @@ export class AnimationManager extends EventDispatcher {
 		this._savedTimeScale = 1;
 		this.onFinished = null; // callback when a non-looping clip ends
 
+		this._rigid = false;
+		this._plans = null; // per clip: { meshes: Int32Array, visibility: boolean, cameras: Camera[] }
+		this._allPlan = null;
+		this._activeClip = 0;
+		this._slotOf = null; // meshIndex -> row in the two caches below, or -1
+		this._lastWorld = null; // world matrix last handed to applyPoseCallback, 16 per row
+		this._lastVisible = null; // 0 / 1, or 2 before the first pose
+
 		/** Injected by PathTracerApp — wakes the render loop after play/resume. */
 		this.wakeCallback = null;
 
+		/** Injected by PathTracerApp — receives `{ meshIndices, visibilityChanged, cameras }`. */
+		this.applyPoseCallback = null;
+
 	}
 
 	/**
@@ -88,6 +100,10 @@ export class AnimationManager extends EventDispatcher {
 
 		this.actions = actions;
 
+		this._rigid = ! meshes.some( m => m?.isSkinnedMesh ) &&
+			! animations.some( clip => clip.tracks.some( t => t.name.includes( 'morphTargetInfluences' ) ) );
+		this._planClips( animations );
+
 		// Listen for non-looping clip completion
 		this.mixer.addEventListener( 'finished', () => {
 
@@ -121,7 +137,154 @@ export class AnimationManager extends EventDispatcher {
 		this._meshPositions = [];
 
 		const skinnedCount = meshes.filter( m => m.isSkinnedMesh ).length;
-		console.debug( `[AnimationManager] Init: ${animations.length} clips, ${meshes.length} meshes (${skinnedCount} skinned), ${offset} triangles` );
+		console.debug( `[AnimationManager] Init: ${animations.length} clips, ${meshes.length} meshes (${skinnedCount} skinned), ${offset} triangles, ${this._rigid ? 'rigid' : 'deforming'}` );
+
+	}
+
+	/** Which meshes and cameras each clip moves, directly or through an ancestor. @private */
+	_planClips( animations ) {
+
+		const root = this._mixerRoot;
+		const byName = new Map();
+		// First name in pre-order wins, as in PropertyBinding.findNode.
+		root.traverse?.( node => {
+
+			if ( ! byName.has( node.name ) ) byName.set( node.name, node );
+			byName.set( node.uuid, node );
+
+		} );
+
+		this._plans = animations.map( clip => {
+
+			const animated = new Set();
+			let visibility = false;
+			for ( const track of clip.tracks ) {
+
+				const { nodeName, propertyName } = PropertyBinding.parseTrackName( track.name );
+				const node = byName.get( nodeName );
+				if ( ! node ) continue;
+				animated.add( node );
+				if ( propertyName === 'visible' ) visibility = true;
+
+			}
+
+			const meshes = [];
+			for ( let m = 0; m < this._meshes.length; m ++ ) {
+
+				for ( let o = this._meshes[ m ]; o; o = o.parent ) {
+
+					if ( animated.has( o ) ) {
+
+						meshes.push( m );
+						break;
+
+					}
+
+				}
+
+			}
+
+			const cameras = new Set();
+			for ( const node of animated ) node.traverse( o => o.isCamera && cameras.add( o ) );
+
+			return { meshes: Int32Array.from( meshes ), visibility, cameras: [ ...cameras ] };
+
+		} );
+
+		this._allPlan = null;
+		if ( ! this._rigid ) return;
+
+		this._slotOf = new Int32Array( this._meshes.length ).fill( - 1 );
+		let rows = 0;
+		for ( const plan of this._plans ) for ( const m of plan.meshes ) if ( this._slotOf[ m ] < 0 ) this._slotOf[ m ] = rows ++;
+
+		// Unknown until the first pose, which therefore sends every animated mesh.
+		this._lastWorld = new Float64Array( rows * 16 ).fill( NaN );
+		this._lastVisible = new Uint8Array( rows ).fill( 2 );
+
+	}
+
+	/** The plan for a clip index, or the union of every clip for -1. @private */
+	_planFor( clipIndex ) {
+
+		if ( ! this._plans ) return null;
+		if ( clipIndex >= 0 ) return this._plans[ clipIndex ] ?? null;
+
+		if ( ! this._allPlan ) {
+
+			const meshes = new Set(), cameras = new Set();
+			let visibility = false;
+			for ( const plan of this._plans ) {
+
+				plan.meshes.forEach( m => meshes.add( m ) );
+				plan.cameras.forEach( c => cameras.add( c ) );
+				visibility ||= plan.visibility;
+
+			}
+
+			this._allPlan = { meshes: Int32Array.from( meshes ), visibility, cameras: [ ...cameras ] };
+
+		}
+
+		return this._allPlan;
+
+	}
+
+	/** Send meshes whose world matrix or visibility changed since the last pose. @private */
+	_applyRigidPose( clipIndex ) {
+
+		const plan = this._planFor( clipIndex );
+		if ( ! plan ) return;
+
+		const moved = [];
+		let visibilityChanged = false;
+		const last = this._lastWorld, lastVisible = this._lastVisible;
+
+		for ( const m of plan.meshes ) {
+
+			const mesh = this._meshes[ m ];
+			const row = this._slotOf[ m ];
+			const e = mesh.matrixWorld.elements;
+			const o = row * 16;
+
+			for ( let i = 0; i < 16; i ++ ) {
+
+				if ( last[ o + i ] !== e[ i ] ) {
+
+					for ( let j = 0; j < 16; j ++ ) last[ o + j ] = e[ j ];
+					moved.push( m );
+					break;
+
+				}
+
+			}
+
+			if ( plan.visibility || lastVisible[ row ] === 2 ) {
+
+				let visible = 1;
+				for ( let n = mesh; n; n = n.parent ) if ( ! n.visible ) {
+
+					visible = 0;
+					break;
+
+				}
+
+				if ( lastVisible[ row ] !== visible ) {
+
+					lastVisible[ row ] = visible;
+					visibilityChanged = true;
+
+				}
+
+			}
+
+		}
+
+		if ( moved.length || visibilityChanged || plan.cameras.length ) {
+
+			this.applyPoseCallback?.( { meshIndices: moved, visibilityChanged, cameras: plan.cameras } );
+
+		}
 
 	}
 
@@ -145,6 +308,7 @@ export class AnimationManager extends EventDispatcher {
 
 		}
 
+		this._activeClip = clipIndex;
 		this.timer.reset();
 		this.isPlaying = true;
 		this.wakeCallback?.();
@@ -188,10 +352,19 @@ export class AnimationManager extends EventDispatcher {
 
 		if ( ! this.mixer ) return;
 
+		// Restores every animated property to its loaded value.
 		this.mixer.stopAllAction();
 		this.mixer.timeScale = this._savedTimeScale || 1;
 		this.timer.reset();
 		this.isPlaying = false;
+
+		if ( this._rigid ) {
+
+			this._mixerRoot.updateMatrixWorld( true );
+			this._applyRigidPose( - 1 );
+
+		}
+
 		this.dispatchEvent( { type: EngineEvents.ANIMATION_STOPPED } );
 
 	}
@@ -229,12 +402,15 @@ export class AnimationManager extends EventDispatcher {
 	 *
 	 * @param {number} time - Absolute time in seconds
 	 * @param {number} [clipIndex=0] - Clip to evaluate, or -1 for all active
-	 * @returns {function(number): Float32Array|null} Per-mesh reader for refitBVH, or null if no mixer
+	 * @returns {function(number): Float32Array|null} Per-mesh reader for refitBVH, or null if no
+	 *   mixer or the clips are rigid
 	 */
 	seekTo( time, clipIndex = 0 ) {
 
 		if ( ! this.mixer || this.actions.length === 0 ) return null;
 
+		this._activeClip = clipIndex;
+
 		// Ensure the target action(s) are active so setTime evaluates them.
 		// Actions must NOT be paused — setTime() calls update() internally,
 		// which skips paused actions entirely.
@@ -279,7 +455,8 @@ export class AnimationManager extends EventDispatcher {
 	 * Advance animation and prepare deformed positions.
 	 * Call once per frame from the animate loop.
 	 *
-	 * @returns {function(number): Float32Array|null} Per-mesh reader for refitBVH, or null if not playing
+	 * @returns {function(number): Float32Array|null} Per-mesh reader for refitBVH, or null if not
+	 *   playing or the clips are rigid
 	 */
 	update() {
 
@@ -312,6 +489,16 @@ export class AnimationManager extends EventDispatcher {
 		// once here, on mixerRoot rather than the scene, keeps unrelated static objects out of it.
 		this._mixerRoot.updateMatrixWorld( true );
 
+		if ( this._rigid ) {
+
+			this._applyRigidPose( this._activeClip );
+			return null;
+
+		}
+
+		const cameras = this._planFor( this._activeClip )?.cameras;
+		if ( cameras?.length ) this.applyPoseCallback?.( { meshIndices: [], visibilityChanged: false, cameras } );
+
 		return m => this._computeMeshPositions( m );
 
 	}
@@ -446,6 +633,13 @@ export class AnimationManager extends EventDispatcher {
 		this._meshPositions = null;
 		this._skinnedCache = null;
 		this._clipsCache = null;
+		this._rigid = false;
+		this._plans = null;
+		this._allPlan = null;
+		this._activeClip = 0;
+		this._slotOf = null;
+		this._lastWorld = null;
+		this._lastVisible = null;
 
 	}
 

package/src/managers/DenoisingManager.js

@@ -4,9 +4,9 @@ import { AIUpscaler } from '../Passes/AIUpscaler.js';
 import { EngineEvents } from '../EngineEvents.js';
 import { createLogger } from '../utils/Logger.js';
 
-// The neural passes live in `../dlss/` but report through the manager that drives them, so they
-// share one namespace: `rayzee.log.only( 'dlss' )` shows the whole chain.
-const dlssLog = createLogger( 'dlss' );
+// The neural passes live in `../neural/` but report through the manager that drives them, so they
+// share one namespace: `rayzee.log.only( 'neural' )` shows the whole chain.
+const neuralLog = createLogger( 'neural' );
 import { ENGINE_DEFAULTS as DEFAULT_STATE, ASVGF_QUALITY_PRESETS, NRD_DEFAULTS, NRD_QUALITY_PRESETS, NRD_PRESET_KEYS } from '../EngineDefaults.js';
 
 // A refresh slower than this is a slideshow, not a live view, so the cadence swaps to a cheaper
@@ -112,16 +112,16 @@ export class DenoisingManager extends EventDispatcher {
 
 		this.denoiser = null;
 		this.upscaler = null;
-		// Which model the AI upscaler runs. 'esrgan' is the ONNX chain; 'dlss' is the neural
+		// Which model the AI upscaler runs. 'esrgan' is the ONNX chain; 'neural' is the neural
 		// super-resolution pass, which is fixed at 2x and needs a denoised source.
 		this.upscalerBackend = 'esrgan';
-		this._dlssUpscaler = null;
+		this._neuralUpscaler = null;
 		// The neural-rendering (detail) pass is independent of the upscaler: it changes appearance,
 		// not resolution, and runs last because its result cannot be read back.
 		this.neuralRendering = false;
 		this.neuralRenderingSettings = {};
-		this._dlssNeural = null;
-		this._dlssModule = null;
+		this._retouch = null;
+		this._superResModule = null;
 		this._neuralPostBusy = false;
 
 		// The tier the finished image uses. The loaded tier is not always this one: while the
@@ -162,6 +162,7 @@ export class DenoisingManager extends EventDispatcher {
 		// Bound event forwarding handlers (stored for removal on re-setup / dispose)
 		this._denoiserStartHandler = null;
 		this._denoiserEndHandler = null;
+		this._denoiserTileHandler = null;
 		this._upscalerResChangedHandler = null;
 		this._upscalerStartHandler = null;
 		this._upscalerProgressHandler = null;
@@ -298,8 +299,21 @@ export class DenoisingManager extends EventDispatcher {
 
 		};
 
+		// The loop has stopped by the time a final denoise runs, so each tile has to redraw the
+		// canvas itself. Not through the display-refresh callback: that restarts the loop, which a
+		// video export drives by hand.
+		this._denoiserTileHandler = e => {
+
+			if ( e.continuous ) return;
+			this._publishOutput();
+			const ctx = this.pipeline?.context;
+			if ( this._stages.compositor && ctx ) this._stages.compositor.render( ctx );
+
+		};
+
 		this.denoiser.addEventListener( 'start', this._denoiserStartHandler );
 		this.denoiser.addEventListener( 'end', this._denoiserEndHandler );
+		this.denoiser.addEventListener( 'tileProgress', this._denoiserTileHandler );
 
 	}
 
@@ -804,20 +818,20 @@ export class DenoisingManager extends EventDispatcher {
 	}
 
 	/**
-	 * Selects the AI upscaler's model. 'dlss' is fixed at 2x and reads the denoised picture, so it
+	 * Selects the AI upscaler's model. 'neural' is fixed at 2x and reads the denoised picture, so it
 	 * is a no-op without a denoiser — feeding it raw Monte-Carlo noise measurably loses to bilinear.
 	 *
-	 * @param {'esrgan'|'dlss'} backend
+	 * @param {'esrgan'|'neural'} backend
 	 */
 	setUpscalerBackend( backend ) {
 
-		const next = backend === 'dlss' ? 'dlss' : 'esrgan';
+		const next = backend === 'neural' ? 'neural' : 'esrgan';
 		if ( next === this.upscalerBackend ) return;
 
 		this.upscalerBackend = next;
 		// Whatever is on screen came from the model being switched away from.
 		this._restoreRenderDisplay();
-		if ( next !== 'dlss' ) this._releaseDLSSUpscaler();
+		if ( next !== 'neural' ) this._releaseNeuralUpscaler();
 
 	}
 
@@ -847,15 +861,15 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	_releaseDLSSUpscaler() {
+	_releaseNeuralUpscaler() {
 
-		this._dlssUpscaler?.dispose();
-		this._dlssUpscaler = null;
+		this._neuralUpscaler?.dispose();
+		this._neuralUpscaler = null;
 
 		// The frame packer lives on the module, not on the upscaler, and holds two buffers the size
 		// of the render. Nothing else reaches it, so this is its only release point. Guarded on the
 		// module having been loaded, so a teardown never pulls in 1 MB of runtime to call a no-op.
-		this._dlssModule?.releaseDenoisedReader();
+		this._superResModule?.releaseDenoisedReader();
 
 	}
 
@@ -866,17 +880,17 @@ export class DenoisingManager extends EventDispatcher {
 		if ( settings ) this.neuralRenderingSettings = { ...this.neuralRenderingSettings, ...settings };
 		if ( ! this.neuralRendering ) {
 
-			this._releaseDLSSNeural();
+			this._releaseNeuralRetouch();
 			this._restoreRenderDisplay();
 
 		}
 
 	}
 
-	_releaseDLSSNeural() {
+	_releaseNeuralRetouch() {
 
-		this._dlssNeural?.dispose();
-		this._dlssNeural = null;
+		this._retouch?.dispose();
+		this._retouch = null;
 
 	}
 
@@ -894,7 +908,7 @@ export class DenoisingManager extends EventDispatcher {
 	 */
 	async _runNeuralPost( isStillComplete ) {
 
-		const wantSR = this.upscaler?.enabled && this.upscalerBackend === 'dlss';
+		const wantSR = this.upscaler?.enabled && this.upscalerBackend === 'neural';
 		const wantNR = this.neuralRendering;
 		if ( ! wantSR && ! wantNR ) return;
 
@@ -904,14 +918,14 @@ export class DenoisingManager extends EventDispatcher {
 
 		if ( ! this.upscalerCanvas ) {
 
-			dlssLog.warn( 'neural pass skipped: the engine has no overlay canvas to present on' );
+			neuralLog.warn( 'neural pass skipped: the engine has no overlay canvas to present on' );
 			return;
 
 		}
 
 		if ( ! this.pipeline?.context?.getTexture( 'oidn:output' ) ) {
 
-			dlssLog.warn( 'neural pass skipped: no denoised picture — it needs OIDN' );
+			neuralLog.warn( 'neural pass skipped: no denoised picture — it needs OIDN' );
 			return;
 
 		}
@@ -921,26 +935,26 @@ export class DenoisingManager extends EventDispatcher {
 
 		try {
 
-			const sr = await import( '../dlss/DLSSSuperRes.js' );
-			this._dlssModule = sr;
+			const sr = await import( '../neural/NeuralSuperRes.js' );
+			this._superResModule = sr;
 
 			// The detail pass has a size ceiling — above it a run takes minutes and then loses every GPU
 			// device in the page. Running it FIRST is what keeps it under: at render size it sees a
 			// quarter of the pixels it would after a 2x upscale, and the render reserve already caps
 			// that at 2048. The check stays as a floor under a raised reserve.
-			const nrModule = wantNR ? await import( '../dlss/DLSSNeural.js' ) : null;
+			const nrModule = wantNR ? await import( '../neural/NeuralRetouch.js' ) : null;
 			const srcSize = this.denoiser?._outTexSize;
 			const nrPixels = ( srcSize?.width ?? 0 ) * ( srcSize?.height ?? 0 );
-			const runNR = wantNR && nrPixels <= nrModule.DLSS_NR_MAX_PIXELS;
+			const runNR = wantNR && nrPixels <= nrModule.RETOUCH_MAX_PIXELS;
 
 			if ( wantNR && ! runNR ) {
 
-				dlssLog.warn(
+				neuralLog.warn(
 					`Neural rendering skipped: the render is ${( nrPixels / 1e6 ).toFixed( 1 )} MP, above the ` +
-					`${( nrModule.DLSS_NR_MAX_PIXELS / 1e6 ).toFixed( 1 )} MP the pass survives.` +
+					`${( nrModule.RETOUCH_MAX_PIXELS / 1e6 ).toFixed( 1 )} MP the pass survives.` +
 					( wantSR ? ' The upscale still ran.' : '' )
 				);
-				this._releaseDLSSNeural();
+				this._releaseNeuralRetouch();
 
 			}
 
@@ -961,16 +975,16 @@ export class DenoisingManager extends EventDispatcher {
 
 			if ( wantSR ) {
 
-				if ( this._dlssUpscaler
-					&& ( this._dlssUpscaler.inputWidth !== source.width || this._dlssUpscaler.inputHeight !== source.height ) ) {
+				if ( this._neuralUpscaler
+					&& ( this._neuralUpscaler.inputWidth !== source.width || this._neuralUpscaler.inputHeight !== source.height ) ) {
 
-					this._releaseDLSSUpscaler();
+					this._releaseNeuralUpscaler();
 
 				}
 
-				if ( ! this._dlssUpscaler ) {
+				if ( ! this._neuralUpscaler ) {
 
-					this._dlssUpscaler = await sr.DLSSSuperRes.create( { width: source.width, height: source.height } );
+					this._neuralUpscaler = await sr.NeuralSuperRes.create( { width: source.width, height: source.height } );
 
 				}
 
@@ -979,23 +993,23 @@ export class DenoisingManager extends EventDispatcher {
 			let image = source;
 
 			// Detail first, upscale second. The detail pass hands back scene-referred light (see
-			// `app/public/dlss/PATCHES.md`), so the upscaler still gets the linear HDR it expects —
+			// the runtime's `rayzee-patch` edits), so the upscaler still gets the linear HDR it expects —
 			// which is what makes this order possible at all.
 			if ( runNR ) {
 
 				const result = await nrModule.enhanceFrame( {
 					source: image,
 					settings: this.neuralRenderingSettings,
-					instance: this._dlssNeural,
+					instance: this._retouch,
 					exposure: tone.exposure,
 					tone: wantSR ? null : tone,
 				} );
-				this._dlssNeural = result.instance;
+				this._retouch = result.instance;
 				image = result;
 
 			}
 
-			if ( wantSR ) image = await this._dlssUpscaler.upscaleToRGBA8( image, tone );
+			if ( wantSR ) image = await this._neuralUpscaler.upscaleToRGBA8( image, tone );
 
 			if ( ! isStillComplete() ) {
 
@@ -1024,7 +1038,7 @@ export class DenoisingManager extends EventDispatcher {
 
 		} catch ( error ) {
 
-			dlssLog.warn( 'neural pass failed', error );
+			neuralLog.warn( 'neural pass failed', error );
 
 		} finally {
 
@@ -1060,7 +1074,7 @@ export class DenoisingManager extends EventDispatcher {
 
 			// One owner of the overlay canvas, so the neural chain and the ONNX upscaler are
 			// exclusive. The neural chain also runs on its own when only its detail pass is on.
-			if ( this.neuralRendering || ( this.upscaler?.enabled && this.upscalerBackend === 'dlss' ) ) {
+			if ( this.neuralRendering || ( this.upscaler?.enabled && this.upscalerBackend === 'neural' ) ) {
 
 				this._runNeuralPost( isStillComplete );
 				return;
@@ -1184,8 +1198,8 @@ export class DenoisingManager extends EventDispatcher {
 		// Remove pending completion-chain listener
 		this._cleanupCompletionListener();
 		// Owns a second GPUDevice plus 3 MB of weights, so it must not outlive the manager.
-		this._releaseDLSSUpscaler();
-		this._releaseDLSSNeural();
+		this._releaseNeuralUpscaler();
+		this._releaseNeuralRetouch();
 
 		// Before the denoiser destroys the picture the Compositor would otherwise still sample.
 		this._unpublishOutput();
@@ -1194,6 +1208,7 @@ export class DenoisingManager extends EventDispatcher {
 
 			if ( this._denoiserStartHandler ) this.denoiser.removeEventListener( 'start', this._denoiserStartHandler );
 			if ( this._denoiserEndHandler ) this.denoiser.removeEventListener( 'end', this._denoiserEndHandler );
+			if ( this._denoiserTileHandler ) this.denoiser.removeEventListener( 'tileProgress', this._denoiserTileHandler );
 			this.denoiser.dispose();
 			this.denoiser = null;
 
@@ -1207,15 +1222,16 @@ export class DenoisingManager extends EventDispatcher {
 			if ( this._upscalerEndHandler ) this.upscaler.removeEventListener( 'end', this._upscalerEndHandler );
 			this.upscaler.dispose();
 			this.upscaler = null;
-			// Which model the AI upscaler runs. 'esrgan' is the ONNX chain; 'dlss' is the neural
+			// Which model the AI upscaler runs. 'esrgan' is the ONNX chain; 'neural' is the neural
 			// super-resolution pass, which is fixed at 2x and needs a denoised source.
 			this.upscalerBackend = 'esrgan';
-			this._dlssUpscaler = null;
+			this._neuralUpscaler = null;
 
 		}
 
 		this._denoiserStartHandler = null;
 		this._denoiserEndHandler = null;
+		this._denoiserTileHandler = null;
 		this._upscalerResChangedHandler = null;
 		this._upscalerStartHandler = null;
 		this._upscalerProgressHandler = null;