rayzee 4.8.14 → 5.0.0

package/src/Pipeline/CompletionTracker.js

@@ -0,0 +1,89 @@
+/**
+ * Tracks render completion state, time limits, and sample limits.
+ *
+ * Owns: timeElapsed, lastResetTime, renderCompleteDispatched.
+ * Called each frame by the render loop and on reset.
+ */
+export class CompletionTracker {
+
+	constructor() {
+
+		this.timeElapsed = 0;
+		this.lastResetTime = performance.now();
+		this.renderCompleteDispatched = false;
+
+	}
+
+	/**
+	 * Updates elapsed time. Call each frame while rendering is active.
+	 */
+	updateTime() {
+
+		this.timeElapsed = ( performance.now() - this.lastResetTime ) / 1000;
+
+	}
+
+	/**
+	 * Checks whether the time-based render limit has been reached.
+	 * @param {string} renderLimitMode - 'time' or 'samples'
+	 * @param {number} renderTimeLimit - Time limit in seconds
+	 * @returns {boolean}
+	 */
+	isTimeLimitReached( renderLimitMode, renderTimeLimit ) {
+
+		return renderLimitMode === 'time' && renderTimeLimit > 0 && this.timeElapsed >= renderTimeLimit;
+
+	}
+
+	/**
+	 * Checks whether ANY render limit (time or samples) is reached.
+	 * @param {Object} pathTracer - The PathTracer stage
+	 * @param {string} renderLimitMode
+	 * @param {number} renderTimeLimit
+	 * @returns {boolean}
+	 */
+	isLimitReached( pathTracer, renderLimitMode, renderTimeLimit ) {
+
+		if ( ! pathTracer ) return false;
+
+		if ( this.isTimeLimitReached( renderLimitMode, renderTimeLimit ) ) return true;
+
+		return pathTracer.frameCount >= pathTracer.completionThreshold;
+
+	}
+
+	/**
+	 * Marks render as complete and returns true if this is the first time.
+	 * @returns {boolean} true if freshly completed (should trigger denoise chain)
+	 */
+	markComplete() {
+
+		if ( this.renderCompleteDispatched ) return false;
+		this.renderCompleteDispatched = true;
+		return true;
+
+	}
+
+	/**
+	 * Resets all tracking state. Call on accumulation reset.
+	 */
+	reset() {
+
+		this.timeElapsed = 0;
+		this.lastResetTime = performance.now();
+		this.renderCompleteDispatched = false;
+
+	}
+
+	/**
+	 * Adjusts lastResetTime to account for idle time so timeElapsed
+	 * continues from where it paused rather than including idle time.
+	 */
+	resumeFromPause() {
+
+		this.renderCompleteDispatched = false;
+		this.lastResetTime = performance.now() - this.timeElapsed * 1000;
+
+	}
+
+}

package/src/Processor/AssetLoader.js

@@ -1,5 +1,5 @@
 import { Box3, Vector3, RectAreaLight, Color, FloatType, LinearFilter, EquirectangularReflectionMapping, LinearMipmapLinearFilter,
-	TextureLoader, Mesh, MeshStandardMaterial, Points, PointsMaterial, LoadingManager, EventDispatcher
+	TextureLoader, Mesh, MeshStandardMaterial, MeshPhysicalMaterial, CircleGeometry, Points, PointsMaterial, LoadingManager, EventDispatcher
 } from 'three';
 import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
 import { HDRLoader } from 'three/addons/loaders/HDRLoader.js';
@@ -1214,7 +1214,7 @@ export class AssetLoader extends EventDispatcher {
 
 					const light = new RectAreaLight(
 						new Color( ...userData.color ),
-						userData.intensity / Math.PI, // Adjust intensity for better visual results
+						userData.intensity * 0.1 / Math.PI, // Adjust intensity for better visual results
 						userData.width,
 						userData.height
 					);
@@ -1253,6 +1253,30 @@ export class AssetLoader extends EventDispatcher {
 	}
 
 	// Utility methods
+
+	/**
+	 * Creates and adds a floor plane to the scene.
+	 * The floor plane is used for focus raycasting and ground contact.
+	 */
+	createFloorPlane() {
+
+		this.floorPlane = new Mesh(
+			new CircleGeometry(),
+			new MeshPhysicalMaterial( {
+				transparent: false,
+				color: 0x303030,
+				roughness: 1,
+				metalness: 0,
+				opacity: 0,
+				transmission: 0,
+			} )
+		);
+		this.floorPlane.name = "Ground";
+		this.floorPlane.visible = false;
+		this.scene.add( this.floorPlane );
+
+	}
+
 	setFloorPlane( floorPlane ) {
 
 		this.floorPlane = floorPlane;

package/src/Processor/SceneProcessor.js

@@ -1297,6 +1297,152 @@ export class SceneProcessor {
 
 	}
 
+	/**
+	 * Computes the dirty buffer ranges for a set of affected mesh BLASes.
+	 * Used for partial GPU upload after per-mesh refit instead of full buffer copy.
+	 *
+	 * @param {number[]} affectedMeshIndices
+	 * @returns {{ triRanges: Array<{offset:number,count:number}>, bvhRanges: Array<{offset:number,count:number}> }}
+	 */
+	computeBLASDirtyRanges( affectedMeshIndices ) {
+
+		const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
+		const FPN = 16; // FLOATS_PER_NODE — 4 × vec4 per BVH node
+		const triRanges = [];
+		const bvhRanges = [];
+
+		for ( const meshIdx of affectedMeshIndices ) {
+
+			const entry = this.instanceTable.entries[ meshIdx ];
+			if ( ! entry ) continue;
+
+			triRanges.push( { offset: entry.triOffset * FPT, count: entry.triCount * FPT } );
+			bvhRanges.push( { offset: entry.blasOffset * FPN, count: entry.blasNodeCount * FPN } );
+
+		}
+
+		// Always include TLAS range (rebuilt on every refit)
+		bvhRanges.push( { offset: 0, count: this.instanceTable.tlasNodeCount * FPN } );
+
+		return { triRanges, bvhRanges };
+
+	}
+
+	/**
+	 * Transfers all scene data (geometry, BVH, materials, textures, emissive, lights)
+	 * from this SceneProcessor to the PathTracer stage for GPU rendering.
+	 *
+	 * @param {import('../Stages/PathTracer.js').PathTracer} pathTracer
+	 * @param {import('../managers/LightManager.js').LightManager} lightManager
+	 * @param {import('three').Scene} meshScene
+	 * @param {import('three').Texture|null} environmentTexture
+	 * @returns {boolean} false if critical data is missing
+	 */
+	uploadToPathTracer( pathTracer, lightManager, meshScene, environmentTexture ) {
+
+		if ( ! this.triangleData ) {
+
+			console.error( 'SceneProcessor: Failed to get triangle data' );
+			return false;
+
+		}
+
+		pathTracer.setTriangleData( this.triangleData, this.triangleCount );
+
+		if ( ! this.bvhData ) {
+
+			console.error( 'SceneProcessor: Failed to get BVH data' );
+			return false;
+
+		}
+
+		pathTracer.setBVHData( this.bvhData );
+
+		if ( this.materialData ) {
+
+			pathTracer.materialData.setMaterialData( this.materialData );
+
+		} else {
+
+			console.warn( 'SceneProcessor: No material data, using defaults' );
+
+		}
+
+		if ( environmentTexture ) {
+
+			pathTracer.environment.setEnvironmentTexture( environmentTexture );
+
+		}
+
+		pathTracer.materialData.setMaterialTextures( {
+			albedoMaps: this.albedoTextures,
+			normalMaps: this.normalTextures,
+			bumpMaps: this.bumpTextures,
+			roughnessMaps: this.roughnessTextures,
+			metalnessMaps: this.metalnessTextures,
+			emissiveMaps: this.emissiveTextures,
+			displacementMaps: this.displacementTextures,
+		} );
+
+		if ( this.emissiveTriangleData ) {
+
+			pathTracer.setEmissiveTriangleData(
+				this.emissiveTriangleData,
+				this.emissiveTriangleCount,
+				this.emissiveTotalPower,
+			);
+
+		}
+
+		if ( this.lightBVHNodeData ) {
+
+			pathTracer.setLightBVHData(
+				this.lightBVHNodeData,
+				this.lightBVHNodeCount,
+			);
+
+		}
+
+		lightManager.transferSceneLights( meshScene );
+		return true;
+
+	}
+
+	/**
+	 * Updates material emissive data and rebuilds emissive triangle sampling data.
+	 * Returns null if no change, or the updated emissive data for GPU upload.
+	 *
+	 * @param {number} materialIndex
+	 * @param {string} property - 'emissive' | 'emissiveIntensity' | 'visible'
+	 * @param {*} value
+	 * @returns {{ rawData: Float32Array, emissiveCount: number, totalPower: number }|null}
+	 */
+	updateMaterialEmissive( materialIndex, property, value ) {
+
+		if ( ! this.emissiveTriangleBuilder ) return null;
+
+		const mat = this.materials[ materialIndex ];
+		if ( ! mat ) return null;
+
+		if ( property === 'emissive' ) mat.emissive = value;
+		else if ( property === 'emissiveIntensity' ) mat.emissiveIntensity = value;
+		else if ( property === 'visible' ) mat.visible = value;
+
+		const changed = this.emissiveTriangleBuilder.updateMaterialEmissive(
+			materialIndex, mat,
+			this.triangleData, this.materials, this.triangleCount,
+		);
+
+		if ( ! changed ) return null;
+
+		return {
+			rawData: this.emissiveTriangleBuilder.createEmissiveRawData(),
+			emissiveCount: this.emissiveTriangleBuilder.emissiveCount,
+			totalPower: this.emissiveTriangleBuilder.totalEmissivePower,
+		};
+
+	}
+
 	/**
 	 * Update triangle positions for a single mesh entry.
 	 * Iterates in BVH order for sequential writes (cache-friendly), random reads from newPositions.

package/src/Processor/TLASBuilder.js

@@ -116,42 +116,48 @@ export class TLASBuilder {
 		let bestAxis = 0;
 		let bestSplit = 0;
 
-		for ( let axis = 0; axis < 3; axis ++ ) {
+		// Only attempt SAH when surface area is finite and positive —
+		// degenerate/overflow AABBs (meshes far from origin) produce NaN costs.
+		if ( parentSA > 0 && isFinite( parentSA ) ) {
 
-			// Sort indices by centroid along axis
-			const sorted = indices.slice().sort( ( a, b ) => {
+			for ( let axis = 0; axis < 3; axis ++ ) {
 
-				const aabbA = entries[ a ].worldAABB;
-				const aabbB = entries[ b ].worldAABB;
-				const cA = this._centroid( aabbA, axis );
-				const cB = this._centroid( aabbB, axis );
-				return cA - cB;
+				// Sort indices by centroid along axis
+				const sorted = indices.slice().sort( ( a, b ) => {
 
-			} );
+					const aabbA = entries[ a ].worldAABB;
+					const aabbB = entries[ b ].worldAABB;
+					const cA = this._centroid( aabbA, axis );
+					const cB = this._centroid( aabbB, axis );
+					return cA - cB;
 
-			// Evaluate SAH for each split position
-			for ( let i = 1; i < sorted.length; i ++ ) {
+				} );
 
-				const leftAABB = this._computeGroupAABB( entries, sorted, 0, i );
-				const rightAABB = this._computeGroupAABB( entries, sorted, i, sorted.length );
+				// Evaluate SAH for each split position
+				for ( let i = 1; i < sorted.length; i ++ ) {
 
-				const leftSA = this._surfaceArea(
-					leftAABB.minX, leftAABB.minY, leftAABB.minZ,
-					leftAABB.maxX, leftAABB.maxY, leftAABB.maxZ
-				);
-				const rightSA = this._surfaceArea(
-					rightAABB.minX, rightAABB.minY, rightAABB.minZ,
-					rightAABB.maxX, rightAABB.maxY, rightAABB.maxZ
-				);
+					const leftAABB = this._computeGroupAABB( entries, sorted, 0, i );
+					const rightAABB = this._computeGroupAABB( entries, sorted, i, sorted.length );
 
-				// SAH cost: traversal + (leftSA/parentSA * leftCount + rightSA/parentSA * rightCount)
-				const cost = 1.0 + ( leftSA * i + rightSA * ( sorted.length - i ) ) / parentSA;
+					const leftSA = this._surfaceArea(
+						leftAABB.minX, leftAABB.minY, leftAABB.minZ,
+						leftAABB.maxX, leftAABB.maxY, leftAABB.maxZ
+					);
+					const rightSA = this._surfaceArea(
+						rightAABB.minX, rightAABB.minY, rightAABB.minZ,
+						rightAABB.maxX, rightAABB.maxY, rightAABB.maxZ
+					);
 
-				if ( cost < bestCost ) {
+					// SAH cost: traversal + (leftSA/parentSA * leftCount + rightSA/parentSA * rightCount)
+					const cost = 1.0 + ( leftSA * i + rightSA * ( sorted.length - i ) ) / parentSA;
 
-					bestCost = cost;
-					bestAxis = axis;
-					bestSplit = i;
+					if ( cost < bestCost ) {
+
+						bestCost = cost;
+						bestAxis = axis;
+						bestSplit = i;
+
+					}
 
 				}
 
@@ -159,6 +165,19 @@ export class TLASBuilder {
 
 		}
 
+		// Fallback to median split when SAH fails to find a valid partition
+		// (degenerate AABB, overflow surface area, or coincident centroids).
+		if ( bestSplit <= 0 || bestSplit >= indices.length ) {
+
+			bestAxis = 0;
+			const dx = maxX - minX, dy = maxY - minY, dz = maxZ - minZ;
+			if ( dy > dx && dy > dz ) bestAxis = 1;
+			else if ( dz > dx ) bestAxis = 2;
+
+			bestSplit = indices.length >> 1;
+
+		}
+
 		// Sort along best axis and split
 		const sorted = indices.slice().sort( ( a, b ) => {
 
@@ -301,10 +320,22 @@ export class TLASBuilder {
 
 	}
 
-	_countNodes( node ) {
+	_countNodes( root ) {
+
+		if ( ! root ) return 0;
+
+		let count = 0;
+		const stack = [ root ];
+		while ( stack.length > 0 ) {
+
+			const node = stack.pop();
+			count ++;
+			if ( node.leftChild ) stack.push( node.leftChild );
+			if ( node.rightChild ) stack.push( node.rightChild );
+
+		}
 
-		if ( ! node ) return 0;
-		return 1 + this._countNodes( node.leftChild ) + this._countNodes( node.rightChild );
+		return count;
 
 	}
 

package/src/RenderSettings.js

@@ -101,13 +101,91 @@ export class RenderSettings extends EventDispatcher {
 
 	/**
 	 * Wires internal references. Called by PathTracerApp after init().
+	 *
+	 * @param {Object} params
+	 * @param {Object} params.stages           - Pipeline stages { pathTracer, display, autoExposure, ... }
+	 * @param {Function} params.resetCallback   - Called to reset accumulation
+	 * @param {Function} [params.reconcileCompletion] - Called when completion limits change
 	 */
-	bind( { pathTracer, resetCallback, handlers = {}, delegates = {} } ) {
+	bind( { stages, resetCallback, reconcileCompletion } ) {
 
-		this._pathTracer = pathTracer;
+		this._pathTracer = stages.pathTracer;
 		this._resetCallback = resetCallback;
-		this._handlers = handlers;
-		this._delegates = delegates;
+		this._delegates = {};
+		this._handlers = this._buildHandlers( stages, reconcileCompletion );
+
+	}
+
+	/**
+	 * Builds handler functions for multi-stage settings that can't
+	 * be routed with a simple uniform forward.
+	 */
+	_buildHandlers( stages, reconcileCompletion ) {
+
+		return {
+
+			handleTransparentBackground: ( value ) => {
+
+				stages.pathTracer?.setUniform( 'transparentBackground', value );
+				stages.display?.setTransparentBackground( value );
+
+			},
+
+			handleExposure: ( value ) => {
+
+				if ( ! stages.autoExposure?.enabled ) {
+
+					stages.display?.setExposure( value );
+
+				}
+
+			},
+
+			handleSaturation: ( value ) => {
+
+				stages.display?.setSaturation( value );
+
+			},
+
+			handleRenderLimitMode: ( value ) => {
+
+				stages.pathTracer?.setRenderLimitMode?.( value );
+
+			},
+
+			handleMaxSamples: ( value ) => {
+
+				stages.pathTracer?.setUniform( 'maxSamples', value );
+				stages.pathTracer?.updateCompletionThreshold();
+				reconcileCompletion?.();
+
+			},
+
+			handleRenderTimeLimit: () => {
+
+				reconcileCompletion?.();
+
+			},
+
+			handleRenderMode: ( value ) => {
+
+				stages.pathTracer?.setUniform( 'renderMode', parseInt( value ) );
+
+			},
+
+			handleEnvironmentRotation: ( value ) => {
+
+				stages.pathTracer?.environment.setEnvironmentRotation( value );
+
+			},
+
+			handleInteractionModeEnabled: ( value ) => {
+
+				stages.pathTracer?.setInteractionModeEnabled( value );
+
+			},
+
+		};
 
 	}
 

package/src/TSL/LightsSampling.js

@@ -145,7 +145,7 @@ export const sampleRectAreaLight = Fn( ( [ light, rayOrigin, ruv, lightSelection
 			const cosAngle = dot( direction.negate(), lightNormal ).toVar();
 
 			ls_lightType.assign( int( LIGHT_TYPE_AREA ) );
-			ls_emission.assign( light.color.mul( light.intensity ).div( PI ) );
+			ls_emission.assign( light.color.mul( light.intensity ) );
 			ls_distance.assign( dist );
 			ls_direction.assign( direction );
 			// Guard division: ensure denominator is never zero
@@ -205,7 +205,7 @@ export const sampleCircAreaLight = Fn( ( [ light, rayOrigin, ruv, lightSelection
 			const cosAngle = dot( direction.negate(), lightNormal ).toVar();
 
 			ls_lightType.assign( int( LIGHT_TYPE_AREA ) );
-			ls_emission.assign( light.color.mul( light.intensity ).div( PI ) );
+			ls_emission.assign( light.color.mul( light.intensity ) );
 			ls_distance.assign( dist );
 			ls_direction.assign( direction );
 			// Guard division
@@ -1062,15 +1062,14 @@ export const calculateDirectLightingUnified = Fn( ( [
 							const lightPdfWeighted = lightSample.pdf.mul( lightWeight ).toVar();
 							const brdfPdfWeighted = bPdf.mul( brdfWeight ).toVar();
 
-							// Apply power heuristic for area lights and primary directional lights
+							// Apply power heuristic only for area lights — the BRDF path can
+							// intersect area lights, so both strategies contribute and MIS is valid.
+							// Point/spot/directional lights are delta or non-intersectable by the
+							// BRDF path, so MIS would only reduce energy without compensation.
 							If( lightSample.lightType.equal( int( LIGHT_TYPE_AREA ) ), () => {
 
 								misW.assign( powerHeuristic( { pdf1: lightPdfWeighted, pdf2: brdfPdfWeighted } ) );
 
-							} ).ElseIf( bounceIndex.equal( int( 0 ) ).and( lightSample.lightType.equal( int( LIGHT_TYPE_DIRECTIONAL ) ) ), () => {
-
-								misW.assign( powerHeuristic( { pdf1: lightPdfWeighted, pdf2: brdfPdfWeighted } ) );
-
 							} );
 
 						} );

package/src/index.js

@@ -53,15 +53,5 @@ export { TransformManager } from './managers/TransformManager.js';
 // Video rendering
 export { VideoRenderManager } from './managers/VideoRenderManager.js';
 
-// Sub-API facades (namespaced access via engine.camera, engine.lights, etc.)
-export {
-	OutputAPI,
-	LightsAPI,
-	AnimationAPI,
-	SelectionAPI,
-	TransformAPI,
-	CameraAPI,
-	EnvironmentAPI,
-	MaterialsAPI,
-	DenoisingAPI,
-} from './api/index.js';
+// Interaction
+export { InteractionManager } from './managers/InteractionManager.js';

package/src/managers/AnimationManager.js

@@ -6,29 +6,35 @@
  * them in the format expected by PathTracerApp.refitBVH().
  */
 
-import { AnimationMixer, Timer, Vector3, LoopRepeat, LoopOnce } from 'three';
+import { AnimationMixer, EventDispatcher, Timer, Vector3, LoopRepeat, LoopOnce } from 'three';
+import { EngineEvents } from '../EngineEvents.js';
 
-export class AnimationManager {
+export class AnimationManager extends EventDispatcher {
 
 	constructor() {
 
+		super();
+
 		this.mixer = null;
 		this.timer = new Timer();
 		this.actions = [];
 		this.isPlaying = false;
 
-		this._scene = null;       // scene root (for matrixWorld updates)
-		this._mixerRoot = null;   // mixer target (GLTF model root for track resolution)
+		this._scene = null; // scene root (for matrixWorld updates)
+		this._mixerRoot = null; // mixer target (GLTF model root for track resolution)
 		this._meshes = null;
 		this._meshTriRanges = null; // { start, count, uniqueVerts, indices }[]
-		this._posBuffer = null;     // Float32Array(triCount * 9) — reused each frame
+		this._posBuffer = null; // Float32Array(triCount * 9) — reused each frame
 		this._tempVec = new Vector3();
-		this._skinnedCache = null;  // per-mesh Float32Array for skinned vertex positions
+		this._skinnedCache = null; // per-mesh Float32Array for skinned vertex positions
 		this._totalTriangleCount = 0;
 		this._clipsCache = null;
 		this._savedTimeScale = 1;
 		this.onFinished = null; // callback when a non-looping clip ends
 
+		/** Injected by PathTracerApp — wakes the render loop after play/resume. */
+		this.wakeCallback = null;
+
 	}
 
 	/**
@@ -144,6 +150,8 @@ export class AnimationManager {
 
 		this.timer.reset();
 		this.isPlaying = true;
+		this.wakeCallback?.();
+		this.dispatchEvent( { type: EngineEvents.ANIMATION_STARTED } );
 
 	}
 
@@ -157,6 +165,7 @@ export class AnimationManager {
 		this.mixer.timeScale = 0;
 		this.timer.reset();
 		this.isPlaying = false;
+		this.dispatchEvent( { type: EngineEvents.ANIMATION_PAUSED } );
 
 	}
 
@@ -170,6 +179,8 @@ export class AnimationManager {
 		this.mixer.timeScale = this._savedTimeScale || 1;
 		this.timer.reset();
 		this.isPlaying = true;
+		this.wakeCallback?.();
+		this.dispatchEvent( { type: EngineEvents.ANIMATION_STARTED } );
 
 	}
 
@@ -184,6 +195,7 @@ export class AnimationManager {
 		this.mixer.timeScale = this._savedTimeScale || 1;
 		this.timer.reset();
 		this.isPlaying = false;
+		this.dispatchEvent( { type: EngineEvents.ANIMATION_STOPPED } );
 
 	}