rayzee 7.23.3 → 7.25.0

package/src/Processor/AssetLoader.js

@@ -9,7 +9,7 @@ import { KTX2Loader } from 'three/addons/loaders/KTX2Loader.js';
 import { EXRLoader } from 'three/addons/loaders/EXRLoader.js';
 import { createMeshesFromMultiMaterialMesh } from 'three/addons/utils/SceneUtils.js';
 import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';
-import { unzipSync, strFromU8 } from 'three/addons/libs/fflate.module.js';
+import { unzipSync, zipSync, strFromU8 } from 'three/addons/libs/fflate.module.js';
 import { disposeObjectFromMemory, updateLoading } from './utils';
 import { BuildTimer } from './BuildTimer.js';
 import { getAssetConfig } from '../AssetConfig.js';
@@ -21,13 +21,20 @@ const SUPPORTED_FORMATS = {
 	'fbx': { type: 'model', name: 'FBX' }, 'obj': { type: 'model', name: 'OBJ' },
 	'stl': { type: 'model', name: 'STL' }, 'ply': { type: 'model', name: 'PLY (Polygon File Format)' },
 	'dae': { type: 'model', name: 'Collada' }, '3mf': { type: 'model', name: '3D Manufacturing Format' },
-	'usdz': { type: 'model', name: 'Universal Scene Description' },
+	'usd': { type: 'model', name: 'USD (Universal Scene Description)' },
+	'usda': { type: 'model', name: 'USDA (USD ASCII)' },
+	'usdc': { type: 'model', name: 'USDC (USD Crate)' },
+	'usdz': { type: 'model', name: 'USDZ (USD Archive)' },
 	'hdr': { type: 'environment', name: 'HDR (High Dynamic Range)' }, 'exr': { type: 'environment', name: 'EXR (OpenEXR)' },
 	'png': { type: 'image', name: 'PNG' }, 'jpg': { type: 'image', name: 'JPEG' },
 	'jpeg': { type: 'image', name: 'JPEG' }, 'webp': { type: 'image', name: 'WebP' },
 	'zip': { type: 'archive', name: 'ZIP Archive' }
 };
 
+// Loose USD layers inside a ZIP compose into one scene; these pick out the
+// layers and the image assets they reference.
+const USD_LAYER_RE = /\.(usd|usda|usdc)$/i;
+const USD_IMAGE_RE = /\.(png|jpg|jpeg|avif)$/i;
 /**
  * AssetLoader class - handles loading of 3D models, environment maps, and archives
  */
@@ -234,7 +241,10 @@ export class AssetLoader extends EventDispatcher {
 			case 'ply': return await this.loadPLYFromArrayBuffer( arrayBuffer, filename );
 			case 'dae': return await this.loadColladaFromFile( file, filename );
 			case '3mf': return await this.load3MFFromArrayBuffer( arrayBuffer, filename );
-			case 'usdz': return await this.loadUSDZFromArrayBuffer( arrayBuffer, filename );
+			case 'usd':
+			case 'usda':
+			case 'usdc':
+			case 'usdz': return await this.loadUSDFromArrayBuffer( arrayBuffer, filename );
 			default: throw new Error( `Support for ${extension} files is not yet implemented` );
 
 		}
@@ -647,6 +657,10 @@ export class AssetLoader extends EventDispatcher {
 			const extension = path.split( '.' ).pop().toLowerCase();
 			if ( SUPPORTED_FORMATS[ extension ] && SUPPORTED_FORMATS[ extension ].type === 'model' ) {
 
+				// A loose layer is only one slice of a USD scene — hand the whole
+				// archive over so its references and payloads can resolve.
+				if ( USD_LAYER_RE.test( path ) ) return await this.loadUSDHierarchyFromZip( zip );
+
 				console.log( `Loading model file from ZIP: ${path}` );
 				return await this.loadModelFromZipEntry( zip[ path ], path, extension, zip );
 
@@ -658,6 +672,48 @@ export class AssetLoader extends EventDispatcher {
 
 	}
 
+	// USDLoader only builds a cross-layer asset map on its USDZ branch, so repack
+	// the archive as USDZ — root layer first, per AOUSD core spec 16.4.1.2 — and
+	// let the loader resolve the references/payloads itself.
+	async loadUSDHierarchyFromZip( zip ) {
+
+		const layers = Object.keys( zip ).filter( name => USD_LAYER_RE.test( name ) );
+		if ( layers.length === 0 ) throw new Error( 'No USD layers found in the ZIP archive' );
+
+		const root = AssetLoader._pickUSDRootLayer( layers );
+		console.log( `Loading USD scene from ZIP: ${root} (${layers.length} layers)` );
+
+		const packed = { [ root ]: [ zip[ root ], { level: 0 } ] };
+		for ( const name of Object.keys( zip ) ) {
+
+			if ( name === root ) continue;
+			if ( USD_LAYER_RE.test( name ) || USD_IMAGE_RE.test( name ) ) packed[ name ] = [ zip[ name ], { level: 0 } ];
+
+		}
+
+		return await this.loadUSDFromArrayBuffer( zipSync( packed ), root );
+
+	}
+
+	// Shallowest layer wins; among ties prefer the <dir>/<dir>.usd convention so a
+	// set's entry point beats its sibling variants.
+	static _pickUSDRootLayer( layers ) {
+
+		const depth = name => name.split( '/' ).length;
+		const minDepth = Math.min( ...layers.map( depth ) );
+		const candidates = layers.filter( name => depth( name ) === minDepth );
+
+		const conventional = candidates.find( name => {
+
+			const parts = name.split( '/' );
+			return parts.length > 1 && parts[ parts.length - 1 ].replace( USD_LAYER_RE, '' ) === parts[ parts.length - 2 ];
+
+		} );
+
+		return conventional || candidates[ 0 ];
+
+	}
+
 	async loadModelFromZipEntry( fileContent, filePath, extension, zipContents ) {
 
 		try {
@@ -698,8 +754,11 @@ export class AssetLoader extends EventDispatcher {
 				case '3mf':
 					result = await this.load3MFFromArrayBuffer( fileContent.buffer, filePath );
 					break;
+				case 'usd':
+				case 'usda':
+				case 'usdc':
 				case 'usdz':
-					result = await this.loadUSDZFromArrayBuffer( fileContent.buffer, filePath );
+					result = await this.loadUSDFromArrayBuffer( fileContent, filePath );
 					break;
 				default:
 					throw new Error( `Support for ${extension} files is not yet implemented` );
@@ -1396,21 +1455,28 @@ export class AssetLoader extends EventDispatcher {
 
 	}
 
-	async loadUSDZFromArrayBuffer( arrayBuffer, filename = 'model.usdz' ) {
+	async loadUSDFromArrayBuffer( data, filename = 'model.usd' ) {
 
 		try {
 
-			updateLoading( { isLoading: true, status: "Processing USDZ Data...", progress: 5 } );
+			updateLoading( { isLoading: true, status: "Processing USD Data...", progress: 5 } );
 			await new Promise( r => setTimeout( r, 0 ) );
 
-			if ( ! this.loaderCache.usdz ) {
+			if ( ! this.loaderCache.usd ) {
 
-				const { USDZLoader } = await import( 'three/examples/jsm/loaders/USDZLoader.js' );
-				this.loaderCache.usdz = new USDZLoader();
+				const { USDLoader } = await import( 'three/examples/jsm/loaders/USDLoader.js' );
+				this.loaderCache.usd = new USDLoader();
 
 			}
 
-			const object = this.loaderCache.usdz.parse( arrayBuffer );
+			// parse() returns the group synchronously but resolves textures async;
+			// setupPathTracing snapshots materials, so maps must land before it runs.
+			const object = await new Promise( ( resolve, reject ) => {
+
+				this.loaderCache.usd.parse( data, '', resolve, reject );
+
+			} );
+
 			object.name = filename;
 
 			this.releaseTargetModel();
@@ -1424,7 +1490,7 @@ export class AssetLoader extends EventDispatcher {
 
 		} catch ( error ) {
 
-			console.error( 'Error loading USDZ:', error );
+			console.error( 'Error loading USD:', error );
 			this.dispatchEvent( { type: 'error', message: error.message, filename } );
 			throw error;
 

package/src/Processor/ToneMapCPU.js

@@ -140,15 +140,26 @@ function neutralToneMap( r, g, b, exposure, out ) {
 
 }
 
+/**
+ * Three.js clamps the fragment output with `.max( 0 )` *before* tone mapping
+ * (NodeMaterial.js, "force unsigned floats"), so the GPU curves never see a negative
+ * channel. Compositor's saturation grade (default 1.2) drives complementary channels
+ * below zero on a third of a typical frame, and AgX/Neutral mix those negatives across
+ * channels instead of clipping them — measured 7-10 levels of shadow error against the
+ * viewport until the readback clamps the same way.
+ */
+const clampNegative = fn => ( r, g, b, exposure, out ) =>
+	fn( r > 0 ? r : 0, g > 0 ? g : 0, b > 0 ? b : 0, exposure, out );
+
 /** Look-up table mapping Three.js ToneMapping constants to CPU functions. */
 export const TONE_MAP_FNS = new Map( [
-	[ NoToneMapping, noToneMap ],
-	[ LinearToneMapping, linearToneMap ],
-	[ ReinhardToneMapping, reinhardToneMap ],
-	[ CineonToneMapping, cineonToneMap ],
-	[ ACESFilmicToneMapping, acesFilmicToneMap ],
-	[ AgXToneMapping, agxToneMap ],
-	[ NeutralToneMapping, neutralToneMap ]
+	[ NoToneMapping, clampNegative( noToneMap ) ],
+	[ LinearToneMapping, clampNegative( linearToneMap ) ],
+	[ ReinhardToneMapping, clampNegative( reinhardToneMap ) ],
+	[ CineonToneMapping, clampNegative( cineonToneMap ) ],
+	[ ACESFilmicToneMapping, clampNegative( acesFilmicToneMap ) ],
+	[ AgXToneMapping, clampNegative( agxToneMap ) ],
+	[ NeutralToneMapping, clampNegative( neutralToneMap ) ]
 ] );
 
 /** sRGB gamma (1/2.2) — fast pow approximation. Prefer `linearToSRGB` when matching Three.js's output. */
@@ -165,6 +176,25 @@ export function linearToSRGB( c ) {
 
 }
 
+/**
+ * Exposure as the WebGPU output pass applies it.
+ *
+ * Three.js applies `toneMappingExposure` *inside* ToneMappingNode's tone-mapping branch, and
+ * that branch returns the colour untouched for NoToneMapping (ToneMappingNode.js: `if
+ * ( toneMapping === NoToneMapping ) return colorNode`). So exposure is a no-op on screen there,
+ * and a CPU readback that applies it anyway paints brighter than the viewport it replaces
+ * (measured +33.6 % at exposure 2).
+ *
+ * @param {number} exposure - renderer.toneMappingExposure
+ * @param {number} toneMapping - Three.js ToneMapping constant
+ * @returns {number}
+ */
+export function effectiveExposure( exposure, toneMapping ) {
+
+	return toneMapping === NoToneMapping ? 1.0 : exposure;
+
+}
+
 /** Rec.709 luminance coefficients (same as Display / Common.js). */
 const LUM_R = 0.2126, LUM_G = 0.7152, LUM_B = 0.0722;
 

package/src/RenderSettings.js

@@ -224,6 +224,7 @@ export class RenderSettings extends EventDispatcher {
 			handleRenderLimitMode: ( value ) => {
 
 				stages.pathTracer?.setRenderLimitMode?.( value );
+				reconcileCompletion?.();
 
 			},
 

package/src/Stages/PathTracerStage.js

@@ -1185,25 +1185,15 @@ export class PathTracerStage extends RenderStage {
 	}
 
 	/**
-	 * Update completion threshold based on render mode
+	 * Update completion threshold based on render mode. The ceiling holds in every limit mode —
+	 * uncapping it under a time budget lets a generous deadline silently slow every render.
 	 */
 	updateCompletionThreshold() {
 
-		const renderMode = this.renderMode.value;
-		const maxFrames = this.maxSamples.value;
-
-		if ( this.renderLimitMode === 'time' ) {
-
-			this.completionThreshold = Infinity;
-
-		} else {
-
-			this.completionThreshold = updateCompletionThreshold(
-				renderMode,
-				maxFrames
-			);
-
-		}
+		this.completionThreshold = updateCompletionThreshold(
+			this.renderMode.value,
+			this.maxSamples.value
+		);
 
 	}
 

package/src/managers/DenoisingManager.js

@@ -138,6 +138,13 @@ export class DenoisingManager extends EventDispatcher {
 				adapterInfo: null
 			} ),
 
+			refreshInput: () => {
+
+				const ctx = this.pipeline?.context;
+				if ( this._stages.compositor && ctx ) this._stages.compositor.render( ctx );
+
+			},
+
 			getGPUTextures: () => {
 
 				if ( ! pt?.storageTextures?.readTarget ) return null;
@@ -190,6 +197,13 @@ export class DenoisingManager extends EventDispatcher {
 
 			},
 
+			refreshInput: () => {
+
+				const ctx = this.pipeline?.context;
+				if ( this._stages.compositor && ctx ) this._stages.compositor.render( ctx );
+
+			},
+
 			getGPUTextures: () => {
 
 				if ( ! pt?.storageTextures?.readTarget ) return null;
@@ -428,13 +442,6 @@ export class DenoisingManager extends EventDispatcher {
 		// Remove any stale completion-chain listener from a previous render cycle
 		this._cleanupCompletionListener();
 
-		// Show post-process canvas if any post-process is enabled
-		if ( ( this.denoiser?.enabled || this.upscaler?.enabled ) && this.denoiserCanvas ) {
-
-			this.denoiserCanvas.style.display = 'block';
-
-		}
-
 		// Chain: denoise first (if enabled), then upscale (if enabled)
 		const startUpscaler = () => {
 
@@ -458,13 +465,6 @@ export class DenoisingManager extends EventDispatcher {
 
 		} else {
 
-			// Re-render compositor stage so WebGPU canvas has valid content
-			if ( this.upscaler?.enabled && this._stages.compositor && context ) {
-
-				this._stages.compositor.render( context );
-
-			}
-
 			startUpscaler();
 
 		}
@@ -638,8 +638,10 @@ export class DenoisingManager extends EventDispatcher {
 	setOIDNQuality( quality ) {
 
 		this.denoiser?.updateQuality( quality );
-		// Clean-aux normal follows the model: balanced/high (clean-aux models) → accumulate; fast → keep bump.
-		this._stages.pathTracer?.setCleanAuxNormal?.( !! this.denoiser?.enabled && quality !== 'fast' );
+		// Clean-aux normal follows the model, not the tier name — see OIDNDenoiser.QUALITY_MODELS.
+		this._stages.pathTracer?.setCleanAuxNormal?.(
+			!! this.denoiser?.enabled && !! this.denoiser?.expectsCleanAux( quality )
+		);
 		this._onPostProcessRefresh?.();
 
 	}