rayzee 9.3.1 → 9.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "9.3.1",
+  "version": "9.3.2",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/PathTracerApp.js

@@ -1925,9 +1925,9 @@ export class PathTracerApp extends EventDispatcher {
 	async refitBVH( newPositions, newNormals ) {
 
 		await this.ensureSceneResident();
-		const result = await this._sdf.refitBVH( newPositions, newNormals );
+		const { triRanges, ...result } = await this._sdf.refitBVH( newPositions, newNormals );
 
-		this.stages.pathTracer.updateTriangleData( this._sdf.triangles );
+		this.stages.pathTracer.updateTriangleData( this._sdf.triangles, triRanges );
 		this.stages.pathTracer.updateBVHData( this._sdf.bvh );
 		this.reset( false, { motion: true } );
 

package/src/Processor/SceneProcessor.js

@@ -2648,6 +2648,8 @@ export class SceneProcessor {
 		// can be released as soon as it is read. Callers hand over world space; triangles are
 		// stored per instance, so each mesh comes back through its own inverse.
 		const table = this.instanceTable;
+		const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
+		const triRanges = [];
 		for ( let i = 0; i < table.count; i ++ ) {
 
 			if ( ! table.isSet[ i ] || ! table.isOwner( i ) ) continue;
@@ -2664,6 +2666,11 @@ export class SceneProcessor {
 
 			}
 
+			const offset = table.triOffsetOf( i ) * FPT, count = table.triCountOf( i ) * FPT;
+			const last = triRanges.at( - 1 );
+			if ( last && last.offset + last.count === offset ) last.count += count;
+			else triRanges.push( { offset, count } );
+
 		}
 
 		return new Promise( ( resolve, reject ) => {
@@ -2673,7 +2680,7 @@ export class SceneProcessor {
 				const msg = e.data;
 				if ( msg.type === 'refitComplete' ) {
 
-					resolve( { refitTimeMs: msg.refitTimeMs } );
+					resolve( { refitTimeMs: msg.refitTimeMs, triRanges } );
 
 				} else if ( msg.type === 'error' ) {
 

package/src/Stages/PathTracerStage.js

@@ -1088,12 +1088,17 @@ export class PathTracerStage extends RenderStage {
 
 	}
 
-	/** Re-uploads every triangle from the CPU records, adopting `triangleData` as them when given. */
-	updateTriangleData( triangleData ) {
+	/**
+	 * Re-uploads triangles from the CPU records, adopting `triangleData` as them when given.
+	 * @param {Object} [triangleData]
+	 * @param {Array<{offset:number,count:number}>} [ranges] - only these, in record lanes; every triangle when omitted
+	 */
+	updateTriangleData( triangleData, ranges ) {
 
 		if ( triangleData?.chunks?.length > 1 ) this._triangleRecords = triangleData;
 		else if ( triangleData ) this._triangleFlat = triangleData.chunks ? triangleData.chunks[ 0 ] : triangleData;
-		this._uploadTriangles( 0, this._triangleRecordCount );
+		if ( ranges ) this.updateBufferRanges( ranges, [] );
+		else this._uploadTriangles( 0, this._triangleRecordCount );
 
 	}
 

package/src/managers/AnimationManager.js

@@ -39,6 +39,8 @@ export class AnimationManager extends EventDispatcher {
 		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
+		this._lastMeshWorld = null; // deforming clips: world matrix at each mesh's last read, 16 per mesh
+		this._lastMorphWeights = null;
 
 		/** Injected by PathTracerApp — wakes the render loop after play/resume. */
 		this.wakeCallback = null;
@@ -135,6 +137,8 @@ export class AnimationManager extends EventDispatcher {
 		// 9 floats × every triangle — 1,030 MB at 30M, past what a renderer can allocate.
 		this._skinnedCache = [];
 		this._meshPositions = [];
+		this._lastMeshWorld = this._rigid ? null : new Float64Array( meshes.length * 16 ).fill( NaN );
+		this._lastMorphWeights = [];
 
 		const skinnedCount = meshes.filter( m => m.isSkinnedMesh ).length;
 		console.debug( `[AnimationManager] Init: ${animations.length} clips, ${meshes.length} meshes (${skinnedCount} skinned), ${offset} triangles, ${this._rigid ? 'rigid' : 'deforming'}` );
@@ -499,7 +503,52 @@ export class AnimationManager extends EventDispatcher {
 		const cameras = this._planFor( this._activeClip )?.cameras;
 		if ( cameras?.length ) this.applyPoseCallback?.( { meshIndices: [], visibilityChanged: false, cameras } );
 
-		return m => this._computeMeshPositions( m );
+		// Decided once per reader: an expanded instanced emitter asks for one mesh several times.
+		const moved = new Int8Array( this._meshes.length );
+		return m => {
+
+			if ( moved[ m ] === 0 ) moved[ m ] = this._meshes[ m ].isSkinnedMesh || this._poseChanged( m ) ? 1 : - 1;
+			return moved[ m ] > 0 ? this._computeMeshPositions( m ) : null;
+
+		};
+
+	}
+
+	/** Whether a mesh's world matrix or morph weights differ from when its positions were last read. @private */
+	_poseChanged( m ) {
+
+		const mesh = this._meshes[ m ];
+		const last = this._lastMeshWorld;
+		const e = mesh.matrixWorld.elements;
+		const o = m * 16;
+		let changed = false;
+
+		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 ];
+				changed = true;
+				break;
+
+			}
+
+		}
+
+		const weights = mesh.morphTargetInfluences;
+		if ( weights?.length ) {
+
+			const lastWeights = this._lastMorphWeights[ m ];
+			if ( ! lastWeights || lastWeights.length !== weights.length || lastWeights.some( ( w, i ) => w !== weights[ i ] ) ) {
+
+				this._lastMorphWeights[ m ] = Float64Array.from( weights );
+				changed = true;
+
+			}
+
+		}
+
+		return changed;
 
 	}
 
@@ -640,6 +689,8 @@ export class AnimationManager extends EventDispatcher {
 		this._slotOf = null;
 		this._lastWorld = null;
 		this._lastVisible = null;
+		this._lastMeshWorld = null;
+		this._lastMorphWeights = null;
 
 	}
 

package/src/managers/CameraManager.js

@@ -1,4 +1,4 @@
-import { EventDispatcher, MathUtils, OrthographicCamera, PerspectiveCamera, Quaternion, Vector3 } from 'three';
+import { EventDispatcher, MathUtils, Matrix4, OrthographicCamera, PerspectiveCamera, Quaternion, Vector3 } from 'three';
 import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 import { EngineEvents, } from '../EngineEvents.js';
 import { AF_DEFAULTS, CAMERA_PROJECTION_IDS } from '../EngineDefaults.js';
@@ -62,6 +62,7 @@ export class CameraManager extends EventDispatcher {
 		this._smoothedFocusDistance = null;
 		this._afPointDirty = false;
 		this._afSuspended = false;
+		this._afPick = null;
 
 		// Saved state for default camera when switching to model cameras
 		this._defaultCameraState = null;
@@ -833,13 +834,12 @@ export class CameraManager extends EventDispatcher {
 			&& stage.frameCount > 0
 			&& ! stage.isComplete ) return;
 
-		// AF screen point (0 to 1, y down) to NDC.
-		const validHit = this.interactionManager.pickSurface( this.afScreenPoint.x * 2 - 1, 1 - this.afScreenPoint.y * 2 );
+		const hitPoint = this._pickFocusPoint( stage.resetCount );
 
 		let rawDistance;
-		if ( validHit ) {
+		if ( hitPoint ) {
 
-			rawDistance = viewDepth( validHit.point, this.camera );
+			rawDistance = viewDepth( hitPoint, this.camera );
 			this._lastValidFocusDistance = rawDistance;
 
 		} else {
@@ -910,6 +910,32 @@ export class CameraManager extends EventDispatcher {
 
 	}
 
+	/** Picks again only on a new view or AF point, or a render reset, which every scene change makes. @private */
+	_pickFocusPoint( resetCount ) {
+
+		const camera = this.camera;
+		const { x, y } = this.afScreenPoint;
+		const last = this._afPick ??= { point: new Vector3(), hit: false, resetCount: NaN, x: NaN, y: NaN, view: new Matrix4(), projection: new Matrix4() };
+
+		if ( this._afPointDirty || resetCount !== last.resetCount || x !== last.x || y !== last.y
+			|| ! last.view.equals( camera.matrixWorld ) || ! last.projection.equals( camera.projectionMatrix ) ) {
+
+			// AF screen point (0 to 1, y down) to NDC.
+			const hit = this.interactionManager.pickSurface( x * 2 - 1, 1 - y * 2 );
+			last.hit = !! hit;
+			if ( hit ) last.point.copy( hit.point );
+			last.resetCount = resetCount;
+			last.x = x;
+			last.y = y;
+			last.view.copy( camera.matrixWorld );
+			last.projection.copy( camera.projectionMatrix );
+
+		}
+
+		return last.hit ? last.point : null;
+
+	}
+
 	/**
 	 * Deferred dependency injection — InteractionManager needs the camera
 	 * in its constructor, so it can't be passed during CameraManager creation.