rayzee 10.0.0 → 11.1.0

package/src/Processor/EquirectHDRInfo.js

@@ -1,44 +1,7 @@
 import { DataUtils, HalfFloatType, FloatType, SRGBColorSpace } from 'three';
 import CDFWorker from './Workers/CDFWorker.js?worker&inline';
 import { createWorker } from '../Platform.js';
-
-/**
- * Binary search to find the closest index
- */
-function binarySearchFindClosestIndexOf( array, targetValue, offset = 0, count = array.length ) {
-
-	let lower = offset;
-	let upper = offset + count - 1;
-
-	while ( lower < upper ) {
-
-		const mid = ( lower + upper ) >> 1;
-
-		if ( array[ mid ] < targetValue ) {
-
-			lower = mid + 1;
-
-		} else {
-
-			upper = mid;
-
-		}
-
-	}
-
-	return lower - offset;
-
-}
-
-/**
- * Calculate luminance from RGB values
- */
-function colorToLuminance( r, g, b ) {
-
-	// https://en.wikipedia.org/wiki/Relative_luminance
-	return 0.2126 * r + 0.7152 * g + 0.0722 * b;
-
-}
+import { buildExactEnvironmentTable } from './EnvironmentExactTable.js';
 
 /**
  * sRGB to linear conversion (IEC 61966-2-1 transfer function)
@@ -154,27 +117,24 @@ export function extractFloatData( envMap ) {
 }
 
 /**
- * EquirectHDRInfo - Importance sampling data for equirectangular HDR maps
- *
- * Builds inverted marginal and conditional CDFs from an HDR environment map.
- * Outputs Float32Arrays consumed directly by StorageInstancedBufferAttribute
- * on the GPU — no intermediate DataTexture or HalfFloat conversion needed.
- *
- * Supports two modes:
- * - `updateFrom(hdr)`: synchronous, runs on main thread
- * - `updateFromAsync(hdr)`: offloads CDF math to a Web Worker
+ * EquirectHDRInfo - an equirectangular environment's sampling table (EnvironmentExactTable.js), built on the
+ * main thread (`updateFrom`) or in CDFWorker (`updateFromAsync`). `totalSum` is the map's ∫ luminance dω, 0
+ * when there is nothing to sample.
  */
 export class EquirectHDRInfo {
 
 	constructor() {
 
-		// Placeholder data matching the default storage buffer sizes in PathTracer
-		this.marginalData = new Float32Array( [ 0, 1 ] );
-		this.conditionalData = new Float32Array( [ 0, 0, 1, 1 ] );
 		this.totalSum = 0;
-		this.compensationDelta = 0;
 		this.width = 0;
 		this.height = 0;
+		this.exactConditional = null;
+		this.exactMarginal = null;
+		this.exactRowGuide = null;
+		this.exactMarginalGuide = null;
+		this.exactWidth = 0;
+		this.exactHeight = 0;
+		this.radianceIntegral = 0;
 
 		this._worker = null;
 
@@ -182,8 +142,10 @@ export class EquirectHDRInfo {
 
 	dispose() {
 
-		this.marginalData = null;
-		this.conditionalData = null;
+		this.exactConditional = null;
+		this.exactMarginal = null;
+		this.exactRowGuide = null;
+		this.exactMarginalGuide = null;
 
 		if ( this._worker ) {
 
@@ -194,28 +156,28 @@ export class EquirectHDRInfo {
 
 	}
 
+	_adopt( table, width, height ) {
+
+		Object.assign( this, table );
+		this.width = width;
+		this.height = height;
+		this.totalSum = table.radianceIntegral;
+
+	}
+
 	/**
-	 * Synchronous CDF build on main thread (fallback path).
+	 * Synchronous build on the main thread (fallback path).
 	 */
 	updateFrom( hdr ) {
 
 		const { floatData, width, height } = extractFloatData( hdr );
-
-		const result = EquirectHDRInfo.computeCDF( floatData, width, height );
-
-		this.marginalData = result.marginalData;
-		this.conditionalData = result.conditionalData;
-		this.totalSum = result.totalSum;
-		this.compensationDelta = result.compensationDelta;
-		this.width = width;
-		this.height = height;
+		this._adopt( buildExactEnvironmentTable( floatData, width, height ), width, height );
 
 	}
 
 	/**
-	 * Async CDF build offloaded to a Web Worker.
-	 * Float extraction (HalfFloat → Float32) runs on main thread (needs Three.js DataUtils),
-	 * then the pure-math CDF computation runs off-thread.
+	 * The build offloaded to a Web Worker. Float extraction (HalfFloat → Float32) runs on the main thread
+	 * (it needs three's DataUtils); the table's math runs off it.
 	 * @returns {Promise<void>}
 	 */
 	async updateFromAsync( hdr ) {
@@ -253,12 +215,8 @@ export class EquirectHDRInfo {
 
 			} );
 
-			this.marginalData = result.marginalData;
-			this.conditionalData = result.conditionalData;
-			this.totalSum = result.totalSum;
-			this.compensationDelta = result.compensationDelta;
-			this.width = result.width;
-			this.height = result.height;
+			const { width: w, height: h, ...table } = result;
+			this._adopt( table, w, h );
 
 		} finally {
 
@@ -273,155 +231,4 @@ export class EquirectHDRInfo {
 
 	}
 
-	/**
-	 * Pure-math CDF computation. Used by both the sync path and CDFWorker.
-	 * Static so it can be called without an instance.
-	 */
-	static computeCDF( floatData, width, height ) {
-
-		const numPixels = width * height;
-
-		// Pass 1: compute per-pixel luminance weighted by sin(theta) and raw total sum.
-		// sin(theta) compensates for the equirectangular projection: pixels near the poles
-		// cover less solid angle, so weighting by sin(theta) makes the CDF proportional to
-		// luminance per solid angle rather than luminance per pixel.
-		const pixelWeights = new Float32Array( numPixels );
-		let rawTotalSum = 0.0;
-
-		for ( let y = 0; y < height; y ++ ) {
-
-			const sinTheta = Math.sin( Math.PI * ( y + 0.5 ) / height );
-
-			for ( let x = 0; x < width; x ++ ) {
-
-				const i = y * width + x;
-				const w = colorToLuminance(
-					floatData[ 4 * i ],
-					floatData[ 4 * i + 1 ],
-					floatData[ 4 * i + 2 ],
-				) * sinTheta;
-				pixelWeights[ i ] = w;
-				rawTotalSum += w;
-
-			}
-
-		}
-
-		// MIS Compensation (Karlík et al. 2019, Eq. 14)
-		// With equal sample allocation (c_I = 0.5): delta = 2*(1 - 0.5)*meanWeight = meanWeight
-		// Subtracting mean sharpens the env map PDF, reducing oversampling
-		// of dim regions already well-covered by BSDF sampling.
-		const meanWeight = rawTotalSum / numPixels;
-		let compensatedTotalSum = 0.0;
-
-		for ( let i = 0; i < numPixels; i ++ ) {
-
-			pixelWeights[ i ] = Math.max( 0, pixelWeights[ i ] - meanWeight );
-			compensatedTotalSum += pixelWeights[ i ];
-
-		}
-
-		// Fall back to raw weights if compensation zeroed everything (uniform env map)
-		const useCompensation = compensatedTotalSum > 0;
-		const totalSumValue = useCompensation ? compensatedTotalSum : rawTotalSum;
-		const compensationDelta = useCompensation ? meanWeight : 0;
-
-		if ( ! useCompensation ) {
-
-			for ( let y = 0; y < height; y ++ ) {
-
-				const sinTheta = Math.sin( Math.PI * ( y + 0.5 ) / height );
-
-				for ( let x = 0; x < width; x ++ ) {
-
-					const i = y * width + x;
-					pixelWeights[ i ] = colorToLuminance(
-						floatData[ 4 * i ],
-						floatData[ 4 * i + 1 ],
-						floatData[ 4 * i + 2 ],
-					) * sinTheta;
-
-				}
-
-			}
-
-		}
-
-		// Pass 2: build conditional and marginal CDFs from (compensated) weights
-		const cdfConditional = new Float32Array( numPixels );
-		const cdfMarginal = new Float32Array( height );
-
-		let cumulativeWeightMarginal = 0.0;
-
-		for ( let y = 0; y < height; y ++ ) {
-
-			let cumulativeRowWeight = 0.0;
-			for ( let x = 0; x < width; x ++ ) {
-
-				const i = y * width + x;
-				cumulativeRowWeight += pixelWeights[ i ];
-				cdfConditional[ i ] = cumulativeRowWeight;
-
-			}
-
-			// Normalize row CDF to [0, 1]
-			if ( cumulativeRowWeight !== 0 ) {
-
-				for ( let i = y * width, l = y * width + width; i < l; i ++ ) {
-
-					cdfConditional[ i ] /= cumulativeRowWeight;
-
-				}
-
-			}
-
-			cumulativeWeightMarginal += cumulativeRowWeight;
-			cdfMarginal[ y ] = cumulativeWeightMarginal;
-
-		}
-
-		// Normalize marginal CDF to [0, 1]
-		if ( cumulativeWeightMarginal !== 0 ) {
-
-			for ( let i = 0, l = cdfMarginal.length; i < l; i ++ ) {
-
-				cdfMarginal[ i ] /= cumulativeWeightMarginal;
-
-			}
-
-		}
-
-		// Create inverted CDF arrays (Float32 directly for storage buffers)
-		const marginalData = new Float32Array( height );
-		const conditionalData = new Float32Array( numPixels );
-
-		// Invert marginal CDF
-		for ( let i = 0; i < height; i ++ ) {
-
-			const dist = ( i + 1 ) / height;
-			const row = binarySearchFindClosestIndexOf( cdfMarginal, dist );
-
-			marginalData[ i ] = ( row + 0.5 ) / height;
-
-		}
-
-		// Invert conditional CDFs
-		for ( let y = 0; y < height; y ++ ) {
-
-			for ( let x = 0; x < width; x ++ ) {
-
-				const i = y * width + x;
-				const dist = ( x + 1 ) / width;
-				const col = binarySearchFindClosestIndexOf( cdfConditional, dist, y * width, width );
-
-				conditionalData[ i ] = ( col + 0.5 ) / width;
-
-			}
-
-		}
-
-		return { marginalData, conditionalData, totalSum: totalSumValue, compensationDelta };
-
-	}
-
 }

package/src/Processor/FileFormats.js

@@ -0,0 +1,116 @@
+import { FloatType, Mesh, MeshStandardMaterial, Points, PointsMaterial } from 'three';
+
+/**
+ * File formats beyond glTF and .hdr, each registered on its own (`assetLoader.registerFormat( fbxFormat )`) so a host
+ * ships only the readers it uses. A model format's `parse( file, { filename, cache } )` resolves to `{ model, result? }`;
+ * an environment format's `createLoader( manager )` to a three.js loader whose `loadAsync` resolves to a texture.
+ * Each three.js loader is imported the first time its format is read.
+ */
+
+export const fbxFormat = {
+	name: 'FBX', label: 'FBX', type: 'model', extensions: [ 'fbx' ],
+	async parse( file, { cache } ) {
+
+		cache.fbx ??= new ( await import( 'three/addons/loaders/FBXLoader.js' ) ).FBXLoader();
+		return { model: cache.fbx.parse( await file.arrayBuffer() ) };
+
+	},
+};
+
+export const objFormat = {
+	name: 'OBJ', label: 'OBJ', type: 'model', extensions: [ 'obj' ],
+	async parse( file, { filename, cache } ) {
+
+		cache.obj ??= new ( await import( 'three/addons/loaders/OBJLoader.js' ) ).OBJLoader();
+		const model = cache.obj.parse( await file.text() );
+		model.name = filename;
+		return { model };
+
+	},
+};
+
+export const stlFormat = {
+	name: 'STL', label: 'STL', type: 'model', extensions: [ 'stl' ],
+	async parse( file, { filename, cache } ) {
+
+		cache.stl ??= new ( await import( 'three/addons/loaders/STLLoader.js' ) ).STLLoader();
+		const model = new Mesh( cache.stl.parse( await file.arrayBuffer() ), new MeshStandardMaterial() );
+		model.name = filename;
+		return { model };
+
+	},
+};
+
+export const plyFormat = {
+	name: 'PLY (Polygon File Format)', label: 'PLY', type: 'model', extensions: [ 'ply' ],
+	async parse( file, { filename, cache } ) {
+
+		cache.ply ??= new ( await import( 'three/addons/loaders/PLYLoader.js' ) ).PLYLoader();
+		const geometry = cache.ply.parse( await file.arrayBuffer() );
+		let model;
+		if ( geometry.index !== null ) {
+
+			model = new Mesh( geometry, new MeshStandardMaterial() );
+
+		} else {
+
+			const material = new PointsMaterial( { size: 0.01 } );
+			material.vertexColors = geometry.hasAttribute( 'color' );
+			model = new Points( geometry, material );
+
+		}
+
+		model.name = filename;
+		return { model };
+
+	},
+};
+
+export const colladaFormat = {
+	name: 'Collada', label: 'Collada', type: 'model', extensions: [ 'dae' ],
+	async parse( file, { filename, cache } ) {
+
+		cache.collada ??= new ( await import( 'three/addons/loaders/ColladaLoader.js' ) ).ColladaLoader();
+		const collada = cache.collada.parse( await file.text() );
+		collada.scene.name = filename;
+		return { model: collada.scene, result: collada };
+
+	},
+};
+
+export const threeMFFormat = {
+	name: '3D Manufacturing Format', label: '3MF', type: 'model', extensions: [ '3mf' ],
+	async parse( file, { cache } ) {
+
+		cache.threemf ??= new ( await import( 'three/addons/loaders/3MFLoader.js' ) ).ThreeMFLoader();
+		return { model: cache.threemf.parse( await file.arrayBuffer() ) };
+
+	},
+};
+
+export const usdFormat = {
+	name: 'USD (Universal Scene Description)', label: 'USD', type: 'model', extensions: [ 'usd', 'usda', 'usdc', 'usdz' ],
+	async parse( file, { filename, cache } ) {
+
+		cache.usd ??= new ( await import( 'three/addons/loaders/USDLoader.js' ) ).USDLoader();
+		const data = await file.arrayBuffer();
+		// parse() returns the group at once but resolves textures later; the materials are read after, so wait for them.
+		const model = await new Promise( ( resolve, reject ) => cache.usd.parse( data, '', resolve, reject ) );
+		model.name = filename;
+		return { model };
+
+	},
+};
+
+export const exrFormat = {
+	name: 'EXR (OpenEXR)', label: 'EXR', type: 'environment', extensions: [ 'exr' ],
+	async createLoader( manager ) {
+
+		const { EXRLoader } = await import( 'three/addons/loaders/EXRLoader.js' );
+		return new EXRLoader( manager ).setDataType( FloatType );
+
+	},
+};
+
+/** Every format above. */
+export const allFormats = [ fbxFormat, objFormat, stlFormat, plyFormat, colladaFormat, threeMFFormat, usdFormat, exrFormat ];

package/src/Processor/GLTFDecoders.js

@@ -0,0 +1,85 @@
+import { getAssetConfig } from '../AssetConfig.js';
+
+const DRACO = 'KHR_draco_mesh_compression';
+const BASISU = 'KHR_texture_basisu';
+const MESHOPT = [ 'EXT_meshopt_compression', 'KHR_meshopt_compression' ];
+
+const decoder = new TextDecoder();
+
+// The glTF's JSON as text: a .glb's first chunk, a .gltf whole. Only searched, never parsed.
+function jsonText( data ) {
+
+	if ( typeof data === 'string' ) return data;
+	if ( ! ( data instanceof ArrayBuffer ) ) return JSON.stringify( data?.extensionsUsed ?? [] );
+
+	const view = new DataView( data );
+	const isBinary = data.byteLength >= 20 && view.getUint32( 0, true ) === 0x46546C67;
+	if ( ! isBinary ) return decoder.decode( data );
+	const length = Math.min( view.getUint32( 12, true ), data.byteLength - 20 );
+	return decoder.decode( new Uint8Array( data, 20, length ) );
+
+}
+
+async function attachDecoders( loader, text, renderer ) {
+
+	const { dracoDecoderPath, ktx2TranscoderPath } = getAssetConfig();
+	const [ draco, ktx2, meshopt ] = await Promise.all( [
+		text.includes( DRACO ) && ! loader.dracoLoader ? import( 'three/addons/loaders/DRACOLoader.js' ) : null,
+		text.includes( BASISU ) && ! loader.ktx2Loader ? import( 'three/addons/loaders/KTX2Loader.js' ) : null,
+		MESHOPT.some( name => text.includes( name ) ) && ! loader.meshoptDecoder ? import( 'three/addons/libs/meshopt_decoder.module.js' ) : null,
+	] );
+
+	if ( draco ) {
+
+		const dracoLoader = new draco.DRACOLoader();
+		dracoLoader.setDecoderConfig( { type: 'js' } );
+		dracoLoader.setDecoderPath( dracoDecoderPath );
+		loader.setDRACOLoader( dracoLoader );
+
+	}
+
+	if ( ktx2 ) {
+
+		const ktx2Loader = new ktx2.KTX2Loader();
+		ktx2Loader.setTranscoderPath( ktx2TranscoderPath );
+		if ( renderer ) {
+
+			ktx2Loader.detectSupport( renderer );
+			// RGBA only: GPU-compressed texture arrays are blocked by a three.js TSL limitation (the node compiler's
+			// state survives dispose(), so swapping DataArrayTexture for CompressedArrayTexture breaks WGSL compilation).
+			ktx2Loader.workerConfig = {
+				astcSupported: false, etc1Supported: false, etc2Supported: false,
+				dxtSupported: false, bptcSupported: false, pvrtcSupported: false,
+			};
+
+		}
+
+		loader.setKTX2Loader( ktx2Loader );
+
+	}
+
+	if ( meshopt ) loader.setMeshoptDecoder( meshopt.MeshoptDecoder );
+
+}
+
+/**
+ * Gives a GLTFLoader the Draco, KTX2 and meshopt decoders only when the file it parses uses them, importing each then:
+ * most glTFs use none, and the three are ~35 KB compressed a host would otherwise always ship.
+ * @param {Object} loader - a GLTFLoader
+ * @param {?Object} renderer - for KTX2's format detection
+ */
+export function decodersOnDemand( loader, renderer ) {
+
+	const parse = loader.parse.bind( loader );
+	loader.parse = ( data, path, onLoad, onError ) => {
+
+		attachDecoders( loader, jsonText( data ), renderer ).then(
+			() => parse( data, path, onLoad, onError ),
+			( error ) => onError?.( error ),
+		);
+
+	};
+
+	return loader;
+
+}

package/src/Processor/GLTFDiffuseTransmission.js

@@ -0,0 +1,63 @@
+import { Color, LinearSRGBColorSpace, SRGBColorSpace } from 'three';
+
+export const DIFFUSE_TRANSMISSION_EXTENSION = 'KHR_materials_diffuse_transmission';
+
+/**
+ * A GLTFLoader plugin for KHR_materials_diffuse_transmission, which three.js does not read: each material's factors
+ * and textures become the engine's `diffuseTransmission`, `diffuseTransmissionColor`, `diffuseTransmissionMap` (its
+ * alpha is the factor) and `diffuseTransmissionColorMap`. The engine folds the maps in like the other extension maps,
+ * through the albedo map's uv transform.
+ */
+export function diffuseTransmissionPlugin( parser ) {
+
+	// The factor texture is read for its alpha alone and may be another slot's colour texture, so its colour space is
+	// left as it is.
+	const assign = ( material, key, info, colorSpace ) => {
+
+		const params = {};
+		return parser.assignTexture( params, key, info, colorSpace ).then( () => {
+
+			if ( params[ key ] ) material[ key ] = params[ key ];
+
+		} );
+
+	};
+
+	return {
+
+		name: DIFFUSE_TRANSMISSION_EXTENSION,
+
+		afterRoot( result ) {
+
+			const definitions = parser.json.materials ?? [];
+			const done = new Set();
+			const pending = [];
+
+			for ( const scene of result.scenes ?? [] ) scene.traverse( ( object ) => {
+
+				const materials = Array.isArray( object.material ) ? object.material : object.material ? [ object.material ] : [];
+				for ( const material of materials ) {
+
+					if ( done.has( material ) ) continue;
+					done.add( material );
+					const index = parser.associations.get( material )?.materials;
+					const extension = index === undefined ? null : definitions[ index ]?.extensions?.[ DIFFUSE_TRANSMISSION_EXTENSION ];
+					if ( ! extension ) continue;
+
+					material.diffuseTransmission = extension.diffuseTransmissionFactor ?? 0;
+					const [ r, g, b ] = extension.diffuseTransmissionColorFactor ?? [ 1, 1, 1 ];
+					material.diffuseTransmissionColor = new Color().setRGB( r, g, b, LinearSRGBColorSpace );
+					if ( extension.diffuseTransmissionTexture ) pending.push( assign( material, 'diffuseTransmissionMap', extension.diffuseTransmissionTexture ) );
+					if ( extension.diffuseTransmissionColorTexture ) pending.push( assign( material, 'diffuseTransmissionColorMap', extension.diffuseTransmissionColorTexture, SRGBColorSpace ) );
+
+				}
+
+			} );
+
+			return Promise.all( pending );
+
+		},
+
+	};
+
+}

package/src/Processor/GeometryExtractor.js

@@ -1,7 +1,7 @@
 import { BufferAttribute, Vector3, Vector2, Color, Matrix3, Matrix4, FrontSide, BackSide, DoubleSide, RGBAFormat } from "three";
-import {
-	TEXTURE_CONSTANTS, TRIANGLE_DATA_LAYOUT, MATERIAL_DEFAULTS, packNormalOct, packTriangleFlags, MATERIAL_SIDE_CUTAWAY
-} from '../EngineDefaults.js';
+import { MATERIAL_DEFAULTS } from '../EngineDefaults.js';
+import { TRIANGLE_DATA_LAYOUT, packNormalOct, packTriangleFlags } from './BufferLayout.js';
+import { TEXTURE_CONSTANTS } from './TextureBuckets.js';
 import { ISSUE_CODES } from '../EngineIssues.js';
 import { ChunkedRecords, SHARED_MEMORY_AVAILABLE } from './ChunkedRecords.js';
 import { createLogger, fmt, warnOnce } from '../utils/Logger.js';
@@ -11,7 +11,7 @@ const log = createLogger( 'geometry' );
 
 const MAX_TEXTURES_LIMIT = TEXTURE_CONSTANTS.MAX_TEXTURES_LIMIT;
 
-const COLOR_DEFAULTS = new Set( [ 'color', 'emissive', 'attenuationColor', 'sheenColor', 'specularColor', 'subsurfaceColor' ] );
+const COLOR_DEFAULTS = new Set( [ 'color', 'emissive', 'attenuationColor', 'sheenColor', 'specularColor', 'subsurfaceColor', 'diffuseTransmissionColor' ] );
 
 /**
  * Where a packed material value came from: the three.js material carried it, a legacy-type
@@ -58,6 +58,8 @@ export function resolveMaterialTextures( material ) {
 		sheenRoughnessMap: material.sheenRoughnessMap,
 		specularIntensityMap: material.specularIntensityMap,
 		specularColorMap: material.specularColorMap,
+		diffuseTransmissionMap: material.diffuseTransmissionMap,
+		diffuseTransmissionColorMap: material.diffuseTransmissionColorMap,
 		iridescenceMap: material.iridescenceMap,
 		iridescenceThicknessMap: material.iridescenceThicknessMap,
 	};
@@ -1110,6 +1112,9 @@ export class GeometryExtractor {
 			specularIntensity: pick( 'specularIntensity' ),
 			specularColor: pick( 'specularColor' ),
 
+			diffuseTransmission: pick( 'diffuseTransmission' ),
+			diffuseTransmissionColor: pick( 'diffuseTransmissionColor' ),
+
 			normalScale: pick( 'normalScale' ),
 			bumpScale: pick( 'bumpScale' ),
 			displacementScale: pick( 'displacementScale' ),
@@ -1141,6 +1146,8 @@ export class GeometryExtractor {
 			sheenRoughnessMap: this.processTexture( textures.sheenRoughnessMap, this.sheenRoughnessMaps ),
 			specularIntensityMap: this.processTexture( textures.specularIntensityMap, this.specularIntensityMaps ),
 			specularColorMap: this.processTexture( textures.specularColorMap, this.specularColorMaps ),
+			diffuseTransmissionMap: this.processTexture( textures.diffuseTransmissionMap, this.diffuseTransmissionMaps ),
+			diffuseTransmissionColorMap: this.processTexture( textures.diffuseTransmissionColorMap, this.diffuseTransmissionColorMaps ),
 			iridescenceMap: this.processTexture( textures.iridescenceMap, this.iridescenceMaps ),
 			iridescenceThicknessMap: this.processTexture( textures.iridescenceThicknessMap, this.iridescenceThicknessMaps ),
 
@@ -1171,7 +1178,6 @@ export class GeometryExtractor {
 	getMaterialSide( material ) {
 
 		if ( material.transmission > 0.0 ) return 2;
-		if ( material.userData?.cutaway === true ) return MATERIAL_SIDE_CUTAWAY;
 		switch ( material.side ) {
 
 			case FrontSide: return 0;
@@ -1538,6 +1544,8 @@ export class GeometryExtractor {
 		this.iridescenceThicknessMaps = [];
 		this.specularIntensityMaps = [];
 		this.specularColorMaps = [];
+		this.diffuseTransmissionMaps = [];
+		this.diffuseTransmissionColorMaps = [];
 		this.directionalLights = [];
 		this.cameras = [];
 
@@ -1579,6 +1587,8 @@ export class GeometryExtractor {
 			iridescenceThicknessMaps: this.iridescenceThicknessMaps,
 			specularIntensityMaps: this.specularIntensityMaps,
 			specularColorMaps: this.specularColorMaps,
+			diffuseTransmissionMaps: this.diffuseTransmissionMaps,
+			diffuseTransmissionColorMaps: this.diffuseTransmissionColorMaps,
 			directionalLights: this.directionalLights,
 			cameras: this.cameras
 		};

package/src/Processor/HostMemory.js

@@ -14,7 +14,7 @@
  * that actually runs out (BVH assembly), where it asks only for that step's bytes.
  */
 
-import { TRIANGLE_DATA_LAYOUT } from '../EngineDefaults.js';
+import { TRIANGLE_DATA_LAYOUT } from './BufferLayout.js';
 import { DEFAULT_CHUNK_BYTES } from './ChunkedRecords.js';
 
 /** Bytes one stored triangle occupies in the triangle records. */
@@ -59,6 +59,12 @@ export const SAFE_SCENE_BYTES = 7040 * 1024 * 1024;
  */
 export const MAX_SCENE_BYTES = 9216 * 1024 * 1024;
 
+// Scene-archive budgets with the memory spill on: the triangles and BVH leave the heap as the build goes, so the host
+// passes these instead of the importer's own. The whole 15-part Moana subset (55.7M / 7.0M) loads cold under them, at
+// an 8.1 GB preflight estimate; the preflight, not the budget, refuses anything larger.
+export const SPILL_TRIANGLE_BUDGET = 60_000_000;
+export const SPILL_PLACEMENT_BUDGET = 8_000_000;
+
 /**
  * The host's memory in GB: the host's own figure when it gives one, else Chrome's
  * `navigator.deviceMemory`, else an assumed 4 (every other runtime lacks it).