rayzee 8.6.1 → 8.8.0

package/src/PathTracerApp.js

@@ -1,7 +1,7 @@
 import { WebGPURenderer, RectAreaLightNode, SRGBColorSpace, LinearSRGBColorSpace } from 'three/webgpu';
 import { texture as _tslTexture, cubeTexture as _tslCubeTexture } from 'three/tsl';
 import {
-	Scene, EventDispatcher, Box3
+	Scene, EventDispatcher, Box3, Vector3
 } from 'three';
 import { RectAreaLightTexturesLib } from 'three/addons/lights/RectAreaLightTexturesLib.js';
 import { SceneHelpers } from './SceneHelpers.js';
@@ -195,6 +195,7 @@ export class PathTracerApp extends EventDispatcher {
 		this.assetLoader = null;
 		this._sdf = null;
 		this._animRefitInFlight = false;
+		this._emittersMoved = false;
 		// Max material-texture dimension (longest edge); applied on each scene build.
 		this._maxTextureSize = DEFAULT_STATE.maxTextureSize;
 
@@ -446,6 +447,7 @@ export class PathTracerApp extends EventDispatcher {
 			}
 
 			this.pipeline.render();
+			this.denoisingManager?.afterTrace();
 
 			if ( ! this.stages.pathTracer.isComplete ) {
 
@@ -566,8 +568,15 @@ export class PathTracerApp extends EventDispatcher {
 	/**
 	 * Resets the accumulation buffer.
 	 * @param {boolean} soft - When true, preserves ASVGF temporal history
+	 * @param {Object} [options]
+	 * @param {boolean} [options.motion] - only object placements or geometry moved; keeps the OIDN
+	 *   motion history, which rejects what moved per pixel
 	 */
-	reset( soft = false ) {
+	reset( soft = false, { motion = false } = {} ) {
+
+		// Objects moving is the view changing, as far as the live denoiser's refresh cadence goes.
+		if ( motion ) this.stages.pathTracer?.noteViewChanged();
+		this.denoisingManager?.beforeReset( { keepHistory: soft || motion } );
 
 		if ( this.pipeline ) {
 
@@ -581,6 +590,8 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
+		this.denoisingManager?.afterReset();
+
 		// Whatever is on screen stays until its replacement is ready, including while the camera
 		// moves: the denoising manager decides, since only it knows something is coming.
 		this._abortPostProcess( { keepDisplay: true } );
@@ -1165,6 +1176,7 @@ export class PathTracerApp extends EventDispatcher {
 		// Stop any running animation before rebuilding scene data
 		this.animationManager.dispose();
 		this._animRefitInFlight = false;
+		this._emittersMoved = false;
 
 		// Tag the primary (replace-loaded) model so it appears in the scene-object list.
 		this._tagPrimarySceneObject();
@@ -1615,7 +1627,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		this.stages.pathTracer.updateTriangleData( this._sdf.triangles );
 		this.stages.pathTracer.updateBVHData( this._sdf.bvh );
-		this.reset();
+		this.reset( false, { motion: true } );
 
 		return result;
 
@@ -1637,7 +1649,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		const { triRanges, bvhRanges } = this._sdf.computeBLASDirtyRanges( affectedMeshIndices );
 		this.stages.pathTracer.updateBufferRanges( triRanges, bvhRanges );
-		this.reset();
+		this.reset( false, { motion: true } );
 
 		// Kick off background rebuild for optimal SAH quality
 		this._sdf.scheduleBackgroundRebuild( affectedMeshIndices, ( meshIndex ) => {
@@ -1646,7 +1658,7 @@ export class PathTracerApp extends EventDispatcher {
 			// re-upload here is gigabytes on a large scene, for one mesh's worth of change.
 			const dirty = this._sdf.computeBLASDirtyRanges( [ meshIndex ] );
 			this.stages.pathTracer.updateBufferRanges( dirty.triRanges, dirty.bvhRanges );
-			this.reset();
+			this.reset( false, { motion: true } );
 
 		} );
 
@@ -1654,6 +1666,113 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	/** Apply a pose from AnimationManager: placements, visibility, and a followed camera. @private */
+	_applyAnimationPose( { meshIndices, visibilityChanged, cameras } ) {
+
+		if ( ! this._sdf?.instanceTable ) return;
+		let changed = false;
+
+		if ( meshIndices.length > 0 ) {
+
+			this._notePlacementsMoving( meshIndices );
+			this._sdf.updateMeshTransforms( meshIndices );
+			this.stages.pathTracer?.updateBufferRanges( [], [ this._sdf.computeTLASDirtyRange() ] );
+			if ( this._sdf.movesEmitters( meshIndices ) ) {
+
+				this._emittersMoved = true;
+				// Deferred while playing: the rebuild uploads a scene-sized map, and sampling
+				// already reads each emitter through its placement.
+				if ( ! this.animationManager.isPlaying ) this._refreshMovedEmitters();
+
+			}
+
+			changed = true;
+
+		}
+
+		if ( visibilityChanged ) {
+
+			this.stages.pathTracer?.updateAllMeshVisibility();
+			this._refreshEmissiveForVisibility();
+			changed = true;
+
+		}
+
+		if ( cameras.length > 0 && this._followAnimatedCamera( cameras ) ) changed = true;
+
+		if ( changed ) this.reset( false, { motion: true } );
+
+	}
+
+	/** @private */
+	_notePlacementsMoving( meshIndices ) {
+
+		const dm = this.denoisingManager;
+		const table = this._sdf?.instanceTable;
+		if ( ! dm?.historyActive || ! table ) return;
+
+		for ( const meshIndex of meshIndices ) {
+
+			const run = table.placementRunOf( meshIndex );
+			if ( ! run ) continue;
+			for ( let p = run.start; p < run.start + run.count; p ++ ) dm.notePlacementMoving( table.tlasLeafIndex[ p ], table.world, p * 16 );
+
+		}
+
+	}
+
+	/** @private */
+	_refreshMovedEmitters() {
+
+		if ( ! this._emittersMoved ) return;
+		this._emittersMoved = false;
+		this._uploadEmissivePayload( this._sdf?.refreshEmissiveTransforms() ?? null );
+
+	}
+
+	/**
+	 * Move the view with the selected camera's animated original — the camera list holds copies.
+	 * @returns {boolean} whether the view moved
+	 * @private
+	 */
+	_followAnimatedCamera( cameras ) {
+
+		const cm = this.cameraManager;
+		const selected = cm.currentCameraIndex > 0 ? cm.cameras[ cm.currentCameraIndex ] : null;
+		const uuid = selected?.userData?.__rayzeeSourceUuid;
+		const source = uuid && cameras.find( c => c.uuid === uuid );
+		if ( ! source ) return false;
+
+		source.updateWorldMatrix( true, false );
+		const worldScale = new Vector3();
+		source.matrixWorld.decompose( selected.position, selected.quaternion, worldScale );
+		// Only the mirror survives.
+		selected.scale.set( Math.sign( worldScale.x ) || 1, Math.sign( worldScale.y ) || 1, Math.sign( worldScale.z ) || 1 );
+		if ( source.isPerspectiveCamera ) selected.fov = source.fov;
+
+		const camera = cm.camera;
+		const controls = cm.controls;
+		const distance = controls ? controls.target.distanceTo( camera.position ) : 0;
+
+		camera.position.copy( selected.position );
+		camera.quaternion.copy( selected.quaternion );
+		camera.scale.copy( selected.scale );
+		if ( camera.isPerspectiveCamera && selected.isPerspectiveCamera ) camera.fov = selected.fov;
+		camera.updateProjectionMatrix();
+		camera.updateMatrixWorld( true );
+
+		// Pivot ahead at the same distance, so controls.update() keeps the pose.
+		if ( controls ) {
+
+			const forward = new Vector3( 0, 0, - 1 ).applyQuaternion( camera.quaternion );
+			controls.target.copy( camera.position ).addScaledVector( forward, distance || 1 );
+
+		}
+
+		return true;
+
+	}
+
 	/**
 	 * Apply new transforms for objects that moved, without touching their geometry.
 	 *
@@ -1667,10 +1786,11 @@ export class PathTracerApp extends EventDispatcher {
 	 */
 	updateMeshTransforms( meshIndices ) {
 
+		this._notePlacementsMoving( meshIndices );
 		const result = this._sdf.updateMeshTransforms( meshIndices );
 
 		this.stages.pathTracer.updateBufferRanges( [], [ this._sdf.computeTLASDirtyRange() ] );
-		this.reset();
+		this.reset( false, { motion: true } );
 
 		return result;
 
@@ -2873,10 +2993,11 @@ export class PathTracerApp extends EventDispatcher {
 		const table = this._sdf?.instanceTable;
 		if ( ! table ) return;
 
+		// The emitter list names meshes, the table placements.
 		const hidden = new Set();
 		for ( let i = 0; i < table.count; i ++ ) {
 
-			if ( table.isSet[ i ] && ! table.visible[ i ] ) hidden.add( i );
+			if ( table.isSet[ i ] && ! table.visible[ i ] ) hidden.add( table.sourceMesh[ i ] );
 
 		}
 
@@ -3410,6 +3531,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		// Animation lifecycle → wake + refit flag
 		this.animationManager.wakeCallback = () => this.wake();
+		this.animationManager.applyPoseCallback = ( pose ) => this._applyAnimationPose( pose );
 		this._forwardEvents( this.animationManager, [
 			EngineEvents.ANIMATION_STARTED,
 			EngineEvents.ANIMATION_PAUSED,
@@ -3418,6 +3540,7 @@ export class PathTracerApp extends EventDispatcher {
 		this._addTrackedListener( this.animationManager, EngineEvents.ANIMATION_PAUSED, () => {
 
 			this._animRefitInFlight = false;
+			this._refreshMovedEmitters();
 
 		} );
 		this._addTrackedListener( this.animationManager, EngineEvents.ANIMATION_STOPPED, () => {
@@ -3538,6 +3661,7 @@ export class PathTracerApp extends EventDispatcher {
 			this.animationManager.onFinished = () => {
 
 				this._animRefitInFlight = false;
+				this._refreshMovedEmitters();
 				this.dispatchEvent( { type: EngineEvents.ANIMATION_FINISHED } );
 
 			};

package/src/Processor/AssetLoader.js

@@ -787,10 +787,11 @@ export class AssetLoader extends EventDispatcher {
 		};
 
 		const pbrtStart = performance.now();
-		const { group, environment, report, warnings, meshCount, entryPath: loadedEntry, candidates,
-			parseMs, buildMs, triangleCount, placementCount, mergedShapes, skippedForBudget,
+		const { group, environment, animations, report, warnings, meshCount, entryPath: loadedEntry, candidates,
+			frames, parseMs, buildMs, triangleCount, placementCount, mergedShapes, skippedForBudget,
 			droppedNoTemplate } = await loadPBRTScene( {
 			vfs: zip, source, entryPath, plyParser, imageFromBytes, envFromBytes,
+			animation: options.animation,
 			maxTriangles: options.maxTriangles,
 			maxPlacements: options.maxPlacements,
 			mergeShapesAbove: options.mergeShapesAbove,
@@ -802,15 +803,17 @@ export class AssetLoader extends EventDispatcher {
 		// SceneProcessor.performanceMetrics.
 		this.lastPBRTStats = {
 			parseMs, buildMs, loaderMs: performance.now() - pbrtStart,
-			triangleCount, placementCount, mergedShapes, skippedForBudget, droppedNoTemplate, meshCount
+			triangleCount, placementCount, mergedShapes, skippedForBudget, droppedNoTemplate, meshCount,
+			frames: frames?.length ?? 1
 		};
 
-		// An archive can hold several independent scenes (transparent-machines ships five
-		// animation frames). Only one is loaded, so name it and the alternatives rather
-		// than leave the user comparing against a reference of a different scene.
-		if ( candidates.length > 1 ) {
+		// An archive can hold several independent scenes (bistro ships three views). Only one is
+		// loaded, so name it and the alternatives rather than leave the user comparing against a
+		// reference of a different scene. A frame sequence loads whole, as its animation.
+		const loaded = new Set( frames ?? [ loadedEntry ] );
+		const others = candidates.filter( p => ! loaded.has( p ) );
+		if ( others.length > 0 ) {
 
-			const others = candidates.filter( p => p !== loadedEntry );
 			console.warn( `PBRT archive holds ${candidates.length} scenes; loaded "${loadedEntry}". Others: ${others.join( ', ' )}` );
 			this._issues?.record(
 				ISSUE_CODES.ASSET_AMBIGUOUS_ENTRY,
@@ -849,6 +852,7 @@ export class AssetLoader extends EventDispatcher {
 		group.name = loadedEntry || filename;
 		this.releaseTargetModel();
 		this.targetModel = group;
+		this.animations = animations ?? [];
 
 		// The light's own orientation and `scale` are already baked into the texture, so the
 		// scene is only correct at rotation 0 / intensity 1 — pinned, whatever the host's defaults.
@@ -2032,6 +2036,8 @@ export class AssetLoader extends EventDispatcher {
 
 				// Clone the camera to avoid modifying the original
 				const camera = object.clone();
+				// The clip animates the original; this lets the copy follow it.
+				camera.userData.__rayzeeSourceUuid = object.uuid;
 
 				// Apply world transforms — cameras may be children of
 				// transformed nodes, so local position/quaternion != world.

package/src/Processor/EmissiveTriangleBuilder.js

@@ -72,6 +72,7 @@ export class EmissiveTriangleBuilder {
 	extractEmissiveTriangles( triangleData, materials, triangleCount, table = null ) {
 
 		this.emissiveTriangles = [];
+		this._emissiveMeshes = null;
 		this.totalEmissivePower = 0;
 		this._totalTriangleCount = triangleCount;
 
@@ -172,6 +173,7 @@ export class EmissiveTriangleBuilder {
 					triangleIndex: i,
 					materialIndex: materialIndex,
 					meshIndex: meshIndex,
+					sideSign,
 					instanceLeaf: hasInstance ? table.tlasLeafIndex[ placement ] : - 1,
 					power: power,
 					area: area,
@@ -203,6 +205,74 @@ export class EmissiveTriangleBuilder {
 
 	}
 
+	/** Mesh indices owning at least one emissive triangle. */
+	get emissiveMeshes() {
+
+		return this._emissiveMeshes ??= new Set( this.emissiveTriangles.map( t => t.meshIndex ) );
+
+	}
+
+	/**
+	 * Re-measure every emitter at its placement's current matrix. Call buildLightBVH() after.
+	 * @param {Uint32Array|object} triangleData - packed triangle records, flat or chunked
+	 * @param {import('./InstanceTable.js').InstanceTable} table
+	 */
+	refreshTransforms( triangleData, table ) {
+
+		const chunked = triangleData && triangleData.chunks ? triangleData : null;
+		const chunkedF = chunked ? chunked.viewAs( Float32Array ) : null;
+		const flatF = chunked ? null : new Float32Array( triangleData.buffer, triangleData.byteOffset, triangleData.length );
+		const FLOATS_PER_TRIANGLE = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
+		const m = table.world;
+
+		this.totalEmissivePower = 0;
+
+		for ( const tri of this.emissiveTriangles ) {
+
+			const f = chunked ? chunkedF.chunkFor( tri.triangleIndex ) : flatF;
+			const b = chunked ? chunked.baseOf( tri.triangleIndex ) : tri.triangleIndex * FLOATS_PER_TRIANGLE;
+			const v = [ f[ b ], f[ b + 1 ], f[ b + 2 ], f[ b + 4 ], f[ b + 5 ], f[ b + 6 ], f[ b + 8 ], f[ b + 9 ], f[ b + 10 ] ];
+
+			// As extraction resolves it.
+			const placement = table.placementRunOf?.( tri.meshIndex )?.start ?? - 1;
+			if ( placement >= 0 && table.isSet[ placement ] ) {
+
+				const o = placement * 16;
+				for ( let k = 0; k < 9; k += 3 ) {
+
+					const x = v[ k ], y = v[ k + 1 ], z = v[ k + 2 ];
+					v[ k ] = m[ o ] * x + m[ o + 4 ] * y + m[ o + 8 ] * z + m[ o + 12 ];
+					v[ k + 1 ] = m[ o + 1 ] * x + m[ o + 5 ] * y + m[ o + 9 ] * z + m[ o + 13 ];
+					v[ k + 2 ] = m[ o + 2 ] * x + m[ o + 6 ] * y + m[ o + 10 ] * z + m[ o + 14 ];
+
+				}
+
+			}
+
+			const [ v0x, v0y, v0z, v1x, v1y, v1z, v2x, v2y, v2z ] = v;
+			const area = this._calculateTriangleArea( v0x, v0y, v0z, v1x, v1y, v1z, v2x, v2y, v2z );
+			const e = tri.emissive;
+			tri.power = ( 0.2126 * e.r + 0.7152 * e.g + 0.0722 * e.b ) * tri.emissiveIntensity * area;
+			tri.area = area;
+
+			const nx = ( v1y - v0y ) * ( v2z - v0z ) - ( v1z - v0z ) * ( v2y - v0y );
+			const ny = ( v1z - v0z ) * ( v2x - v0x ) - ( v1x - v0x ) * ( v2z - v0z );
+			const nz = ( v1x - v0x ) * ( v2y - v0y ) - ( v1y - v0y ) * ( v2x - v0x );
+			const nl = ( Math.sqrt( nx * nx + ny * ny + nz * nz ) || 1 ) / tri.sideSign;
+			tri.nx = nx / nl; tri.ny = ny / nl; tri.nz = nz / nl;
+
+			tri.cx = ( v0x + v1x + v2x ) / 3; tri.cy = ( v0y + v1y + v2y ) / 3; tri.cz = ( v0z + v1z + v2z ) / 3;
+			tri.bMinX = Math.min( v0x, v1x, v2x ); tri.bMinY = Math.min( v0y, v1y, v2y ); tri.bMinZ = Math.min( v0z, v1z, v2z );
+			tri.bMaxX = Math.max( v0x, v1x, v2x ); tri.bMaxY = Math.max( v0y, v1y, v2y ); tri.bMaxZ = Math.max( v0z, v1z, v2z );
+
+			this.totalEmissivePower += tri.power;
+
+		}
+
+		this._buildDataArrays();
+
+	}
+
 	/**
 	 * Calculate triangle area using cross product
 	 */