rayzee 7.7.0 → 7.9.0

package/src/Processor/SceneProcessor.js

@@ -9,7 +9,8 @@ import { GeometryExtractor } from './GeometryExtractor.js';
 import { EmissiveTriangleBuilder } from './EmissiveTriangleBuilder.js';
 import { updateLoading } from '../Processor/utils.js';
 import { BuildTimer } from './BuildTimer.js';
-import { TRIANGLE_DATA_LAYOUT, TEXTURE_CONSTANTS } from '../EngineDefaults.js';
+import { SRGBColorSpace } from 'three';
+import { TRIANGLE_DATA_LAYOUT, TEXTURE_CONSTANTS, getTextureBucketId, packTextureIndex } from '../EngineDefaults.js';
 import { fetchAsWorker } from './Workers/fetchAsWorker.js';
 import BVH_WORKER_URL from './Workers/BVHWorker.js?worker&url';
 import BVH_REFIT_WORKER_URL from './Workers/BVHRefitWorker.js?worker&url';
@@ -79,14 +80,13 @@ export class SceneProcessor {
 		this._rebuildGeneration = 0; // Monotonic counter to discard stale background rebuilds
 		this._pendingRebuilds = new Map(); // meshIndex → worker
 
-		// Initialize texture references
-		this.albedoTextures = null;
-		this.normalTextures = null;
-		this.bumpTextures = null;
-		this.roughnessTextures = null;
-		this.metalnessTextures = null;
-		this.emissiveTextures = null;
-		this.displacementTextures = null;
+		// Initialize texture references.
+		// Material maps are packed into consolidated size-bucketed arrays (see _bucketTextures):
+		//   srgbBucketTextures[K]  — albedo + emissive  (SRGBColorSpace)
+		//   linearBucketTextures[K] — normal/bump/roughness/metalness/displacement
+		// A material's per-map index encodes (bucket, layer) via packTextureIndex.
+		this.srgbBucketTextures = null;
+		this.linearBucketTextures = null;
 		this.emissiveTriangleData = null;
 		this.emissiveTriangleCount = 0;
 		this.lightBVHNodeData = null;
@@ -422,7 +422,13 @@ export class SceneProcessor {
 					enabled: this.bvhBuilder.enableReinsertionOptimization,
 					batchSizeRatio: this.bvhBuilder.reinsertionBatchSizeRatio,
 					maxIterations: this.bvhBuilder.reinsertionMaxIterations
-				}
+				},
+				// BVH build params — previously omitted, so the pool path built at the
+				// BVHBuilder default (leaf 8) instead of the configured value.
+				maxLeafSize: this.bvhBuilder.maxLeafSize,
+				numBins: this.bvhBuilder.numBins,
+				maxBins: this.bvhBuilder.maxBins,
+				minBins: this.bvhBuilder.minBins,
 			};
 
 			const totalTasks = poolTasks.length + parallelTasks.length;
@@ -630,6 +636,10 @@ export class SceneProcessor {
 					sharedReorderBuffer: null,
 					treeletOptimization: treeletOpts,
 					reinsertionOptimization: opts.reinsertionOptimization,
+					maxLeafSize: opts.maxLeafSize,
+					numBins: opts.numBins,
+					maxBins: opts.maxBins,
+					minBins: opts.minBins,
 				}, [ meshTriData.buffer ] );
 
 			};
@@ -762,40 +772,45 @@ export class SceneProcessor {
 
 		try {
 
-			// Material raw data for storage buffers (sync, ~1-5ms)
+			// Group the extractor's per-type arrays into consolidated colorSpace×size-bucket
+			// pools, and rewrite each material's per-map index to the packed (bucket, layer)
+			// form. Must run BEFORE createMaterialRawData (which reads mat.map etc.).
+			const { srgbLists, linearLists, remap } = this._bucketTextures();
+			this._remapMaterialTextureIndices( remap );
+
+			// Material raw data for storage buffers (sync, ~1-5ms) — now holds packed indices.
 			if ( this.materials?.length ) {
 
 				this.materialData = this.textureCreator.createMaterialRawData( this.materials );
 
 			}
 
-			// Material texture arrays → GPU DataArrayTextures
-			// All 7 map types are independent — process in parallel
-			const mapTypesList = [
-				{ data: this.maps, prop: 'albedoTextures' },
-				{ data: this.normalMaps, prop: 'normalTextures' },
-				{ data: this.bumpMaps, prop: 'bumpTextures' },
-				{ data: this.roughnessMaps, prop: 'roughnessTextures' },
-				{ data: this.metalnessMaps, prop: 'metalnessTextures' },
-				{ data: this.emissiveMaps, prop: 'emissiveTextures' },
-				{ data: this.displacementMaps, prop: 'displacementTextures' },
-			];
-
-			await Promise.all(
-				mapTypesList
-					.filter( ( { data } ) => data?.length > 0 )
-					.map( ( { data, prop } ) =>
-						this.textureCreator.createTexturesToDataTexture( data )
-							.then( result => {
-
-								this[ prop ] = result;
-
-							} )
-					)
-			);
+			// One DataArrayTexture per non-empty bucket. The sRGB pool (albedo + emissive — both
+			// authored in sRGB per glTF) carries SRGBColorSpace so the GPU decodes sRGB→linear
+			// before lighting; the linear pool (normal/roughness/metalness/bump/displacement —
+			// data textures) stays linear. Applied consistently across load AND rebuildMaterials
+			// (the prior model-load path omitted this, leaving albedo un-decoded / too bright).
+			const buildBucket = ( list, srgb ) => list.length === 0
+				? Promise.resolve( null )
+				: this.textureCreator.createTexturesToDataTexture( list ).then( tex => {
+
+					if ( tex && srgb ) tex.colorSpace = SRGBColorSpace;
+					return tex;
+
+				} );
+
+			const [ srgbTextures, linearTextures ] = await Promise.all( [
+				Promise.all( srgbLists.map( list => buildBucket( list, true ) ) ),
+				Promise.all( linearLists.map( list => buildBucket( list, false ) ) ),
+			] );
+
+			this.srgbBucketTextures = srgbTextures;
+			this.linearBucketTextures = linearTextures;
 
 			this._log( 'Material textures complete', {
 				materialData: !! this.materialData,
+				srgbBuckets: srgbTextures.map( t => ( t ? `${t.image.width}x${t.image.height}x${t.image.depth}` : '-' ) ).join( ',' ),
+				linearBuckets: linearTextures.map( t => ( t ? `${t.image.width}x${t.image.height}x${t.image.depth}` : '-' ) ).join( ',' ),
 			} );
 
 		} catch ( error ) {
@@ -807,6 +822,96 @@ export class SceneProcessor {
 
 	}
 
+	/**
+	 * Group the extractor's seven per-type texture arrays into two consolidated colorSpace
+	 * pools (sRGB: albedo+emissive; linear: normal/bump/roughness/metalness/displacement),
+	 * each split into MATERIAL_BUCKET_COUNT longest-edge size buckets. Textures are deduped
+	 * across types within a (pool, bucket) so a shared image (e.g. ORM) costs one layer.
+	 * @returns {{ srgbLists: Array<Array>, linearLists: Array<Array>, remap: Object }}
+	 *          bucket lists + per-type remap arrays (old per-type layer → packed bucket index).
+	 * @private
+	 */
+	_bucketTextures() {
+
+		const cap = this.config.maxTextureSize;
+		const K = TEXTURE_CONSTANTS.MATERIAL_BUCKET_COUNT;
+		const STRIDE = TEXTURE_CONSTANTS.BUCKET_LAYER_STRIDE;
+
+		const srgbLists = Array.from( { length: K }, () => [] );
+		const linearLists = Array.from( { length: K }, () => [] );
+		const srgbDedup = Array.from( { length: K }, () => new Map() );
+		const linearDedup = Array.from( { length: K }, () => new Map() );
+
+		// Persistent uuid → packed maps so runtime material edits (updateMaterial) can re-pack
+		// a texture's index against the CURRENT bucket layout instead of the stale per-type index.
+		this._srgbTexPacked = new Map();
+		this._linearTexPacked = new Map();
+
+		// Assign one texture to its (bucket, layer) within a pool; dedup by source uuid.
+		const assign = ( tex, lists, dedup, flat ) => {
+
+			if ( ! tex || ! tex.image ) return - 1;
+			const bucket = getTextureBucketId( tex.image.width, tex.image.height, cap, K );
+			const uuid = tex.source?.uuid ?? tex.uuid;
+			const seen = dedup[ bucket ].get( uuid );
+			if ( seen !== undefined ) return packTextureIndex( bucket, seen );
+			if ( lists[ bucket ].length >= STRIDE ) {
+
+				console.warn( `[SceneProcessor] Texture bucket ${bucket} full (${STRIDE}); dropping a map.` );
+				return - 1;
+
+			}
+
+			lists[ bucket ].push( tex );
+			const layer = lists[ bucket ].length - 1;
+			dedup[ bucket ].set( uuid, layer );
+			const packed = packTextureIndex( bucket, layer );
+			flat.set( uuid, packed );
+			return packed;
+
+		};
+
+		// Per-type arrays hold unique textures indexed by the layer the extractor assigned
+		// (= array position), so remap[type][oldLayer] = packed index.
+		const remapType = ( arr, lists, dedup, flat ) => ( arr || [] ).map( tex => assign( tex, lists, dedup, flat ) );
+
+		const remap = {
+			albedo: remapType( this.maps, srgbLists, srgbDedup, this._srgbTexPacked ),
+			emissive: remapType( this.emissiveMaps, srgbLists, srgbDedup, this._srgbTexPacked ),
+			normal: remapType( this.normalMaps, linearLists, linearDedup, this._linearTexPacked ),
+			bump: remapType( this.bumpMaps, linearLists, linearDedup, this._linearTexPacked ),
+			roughness: remapType( this.roughnessMaps, linearLists, linearDedup, this._linearTexPacked ),
+			metalness: remapType( this.metalnessMaps, linearLists, linearDedup, this._linearTexPacked ),
+			displacement: remapType( this.displacementMaps, linearLists, linearDedup, this._linearTexPacked ),
+		};
+
+		return { srgbLists, linearLists, remap };
+
+	}
+
+	/**
+	 * Rewrite each material's per-map index from the extractor's per-type layer to the
+	 * packed (bucket, layer) index. Idempotency is NOT guaranteed — call exactly once per
+	 * extraction (materials are freshly extracted on each process/rebuild).
+	 * @private
+	 */
+	_remapMaterialTextureIndices( remap ) {
+
+		const fix = ( v, table ) => ( v >= 0 && v < table.length ? table[ v ] : - 1 );
+		for ( const mat of this.materials ) {
+
+			mat.map = fix( mat.map, remap.albedo );
+			mat.emissiveMap = fix( mat.emissiveMap, remap.emissive );
+			mat.normalMap = fix( mat.normalMap, remap.normal );
+			mat.bumpMap = fix( mat.bumpMap, remap.bump );
+			mat.roughnessMap = fix( mat.roughnessMap, remap.roughness );
+			mat.metalnessMap = fix( mat.metalnessMap, remap.metalness );
+			mat.displacementMap = fix( mat.displacementMap, remap.displacement );
+
+		}
+
+	}
+
 	/**
 	 * Extract emissive triangles and build Light BVH.
 	 * MUST run after BVH reordering — emissive data stores triangle indices
@@ -905,27 +1010,42 @@ export class SceneProcessor {
      */
 	_disposeTextures() {
 
-		const textureProps = [
-			'albedoTextures', 'normalTextures', 'bumpTextures', 'roughnessTextures',
-			'metalnessTextures', 'emissiveTextures', 'displacementTextures'
-		];
+		this._disposeBucketTextures();
+
+	}
+
+	/**
+	 * Dispose the consolidated bucket arrays (srgb/linear), each an Array<K> of
+	 * DataArrayTexture | null.
+	 * @private
+	 */
+	_disposeBucketTextures() {
 
-		// Dispose each texture if it exists
-		textureProps.forEach( prop => {
+		for ( const prop of [ 'srgbBucketTextures', 'linearBucketTextures' ] ) {
 
-			if ( this[ prop ] ) {
+			const arr = this[ prop ];
+			if ( ! arr ) continue;
+			for ( const tex of arr ) {
 
-				if ( typeof this[ prop ].dispose === 'function' ) {
+				if ( tex && typeof tex.dispose === 'function' ) {
 
-					this[ prop ].dispose();
+					try {
 
-				}
+						tex.dispose();
+
+					} catch ( error ) {
 
-				this[ prop ] = null;
+						console.warn( `[SceneProcessor] Error disposing ${prop}:`, error );
+
+					}
+
+				}
 
 			}
 
-		} );
+			this[ prop ] = null;
+
+		}
 
 	}
 
@@ -969,34 +1089,9 @@ export class SceneProcessor {
 			this.displacementMaps = extractedData.displacementMaps;
 			this.sceneFeatures = extractedData.sceneFeatures; // Update material feature flags
 
-			// Create new material and texture data only
-			const params = {
-				materials: this.materials,
-				triangles: this.triangleData, // Reuse existing triangle data
-				maps: this.maps,
-				normalMaps: this.normalMaps,
-				bumpMaps: this.bumpMaps,
-				roughnessMaps: this.roughnessMaps,
-				metalnessMaps: this.metalnessMaps,
-				emissiveMaps: this.emissiveMaps,
-				displacementMaps: this.displacementMaps,
-				bvhRoot: this.bvhRoot // Reuse existing BVH
-			};
-
-			// Create only material and texture-related textures
-			const textures = await this.textureCreator.createMaterialTextures( params );
-
-			// Regenerate raw material data for storage buffers
-			this.materialData = this.textureCreator.createMaterialRawData( this.materials );
-
-			// Update texture references (keep triangle and BVH data unchanged)
-			this.albedoTextures = textures.albedoTexture;
-			this.normalTextures = textures.normalTexture;
-			this.bumpTextures = textures.bumpTexture;
-			this.roughnessTextures = textures.roughnessTexture;
-			this.metalnessTextures = textures.metalnessTexture;
-			this.emissiveTextures = textures.emissiveTexture;
-			this.displacementTextures = textures.displacementTexture;
+			// Bucket textures, remap material indices, regenerate raw material data, and
+			// build the consolidated bucket arrays — same path as the initial build.
+			await this._createMaterialTextures();
 
 			const duration = performance.now() - startTime;
 			this._log( `Material rebuild complete (${duration.toFixed( 2 )}ms)`, {
@@ -1026,37 +1121,7 @@ export class SceneProcessor {
      */
 	_disposeMaterialTextures() {
 
-		const materialTextureProps = [
-			'albedoTextures', 'normalTextures',
-			'bumpTextures', 'roughnessTextures', 'metalnessTextures', 'emissiveTextures',
-			'displacementTextures'
-		];
-
-		materialTextureProps.forEach( prop => {
-
-			if ( this[ prop ] ) {
-
-				try {
-
-					if ( typeof this[ prop ].dispose === 'function' ) {
-
-						this[ prop ].dispose();
-
-					}
-
-				} catch ( error ) {
-
-					console.warn( `[SceneProcessor] Error disposing ${prop}:`, error );
-
-				} finally {
-
-					this[ prop ] = null;
-
-				}
-
-			}
-
-		} );
+		this._disposeBucketTextures();
 
 		// Clear texture creator cache to prevent stale references
 		if ( this.textureCreator && this.textureCreator.textureCache ) {
@@ -1407,14 +1472,12 @@ export class SceneProcessor {
 		}
 
 		pathTracer.materialData.setMaterialTextures( {
-			albedoMaps: this.albedoTextures,
-			normalMaps: this.normalTextures,
-			bumpMaps: this.bumpTextures,
-			roughnessMaps: this.roughnessTextures,
-			metalnessMaps: this.metalnessTextures,
-			emissiveMaps: this.emissiveTextures,
-			displacementMaps: this.displacementTextures,
+			srgbBuckets: this.srgbBucketTextures,
+			linearBuckets: this.linearBucketTextures,
 		} );
+		// Hand the uuid→packed maps to materialData so runtime edits (updateMaterial) can
+		// re-pack a texture's index against this scene's bucket layout.
+		pathTracer.materialData.setTexturePackMaps?.( this._srgbTexPacked, this._linearTexPacked );
 
 		if ( this.emissiveTriangleData ) {
 

package/src/Processor/ShaderBuilder.js

@@ -9,7 +9,7 @@
 
 import { texture } from 'three/tsl';
 import { LinearFilter, DataArrayTexture } from 'three';
-import { setShadowAlbedoMaps, setAlphaShadowsUniform } from '../TSL/LightsDirect.js';
+import { setAlphaShadowsUniform } from '../TSL/LightsDirect.js';
 import { setGoboMapsTexture, setIESProfilesTexture } from '../TSL/LightsCore.js';
 
 export class ShaderBuilder {
@@ -30,7 +30,6 @@ export class ShaderBuilder {
 		const nodes = this._sceneTextureNodes;
 
 		const env = stage.environment;
-		const mat = stage.materialData;
 
 		if ( env.environmentTexture && nodes.envTex ) {
 
@@ -38,13 +37,8 @@ export class ShaderBuilder {
 
 		}
 
-		if ( mat.albedoMaps && nodes.albedoMapsTex ) nodes.albedoMapsTex.value = mat.albedoMaps;
-		if ( mat.normalMaps && nodes.normalMapsTex ) nodes.normalMapsTex.value = mat.normalMaps;
-		if ( mat.bumpMaps && nodes.bumpMapsTex ) nodes.bumpMapsTex.value = mat.bumpMaps;
-		if ( mat.metalnessMaps && nodes.metalnessMapsTex ) nodes.metalnessMapsTex.value = mat.metalnessMaps;
-		if ( mat.roughnessMaps && nodes.roughnessMapsTex ) nodes.roughnessMapsTex.value = mat.roughnessMaps;
-		if ( mat.emissiveMaps && nodes.emissiveMapsTex ) nodes.emissiveMapsTex.value = mat.emissiveMaps;
-		if ( mat.displacementMaps && nodes.displacementMapsTex ) nodes.displacementMapsTex.value = mat.displacementMaps;
+		// Material bucket arrays are owned by PathTracer's independent wavefront nodes
+		// (_refreshWfTextureNodes); nothing to swap here.
 		if ( stage.goboMaps && nodes.goboMapsTex ) nodes.goboMapsTex.value = stage.goboMaps;
 		if ( stage.iesProfiles && nodes.iesProfilesTex ) nodes.iesProfilesTex.value = stage.iesProfiles;
 
@@ -116,14 +110,9 @@ export class ShaderBuilder {
 
 		};
 
-		const mat = stage.materialData;
-		const albedoMapsTex = mat.albedoMaps ? texture( mat.albedoMaps ) : createArrayPlaceholder();
-		const normalMapsTex = mat.normalMaps ? texture( mat.normalMaps ) : createArrayPlaceholder();
-		const bumpMapsTex = mat.bumpMaps ? texture( mat.bumpMaps ) : createArrayPlaceholder();
-		const metalnessMapsTex = mat.metalnessMaps ? texture( mat.metalnessMaps ) : createArrayPlaceholder();
-		const roughnessMapsTex = mat.roughnessMaps ? texture( mat.roughnessMaps ) : createArrayPlaceholder();
-		const emissiveMapsTex = mat.emissiveMaps ? texture( mat.emissiveMaps ) : createArrayPlaceholder();
-		const displacementMapsTex = mat.displacementMaps ? texture( mat.displacementMaps ) : createArrayPlaceholder();
+		// Material map arrays (consolidated size buckets) are owned by PathTracer's
+		// independent wavefront nodes + setMaterialBucketTextures/setShadowAlbedoMaps —
+		// see PathTracer._buildWavefrontKernels. Nothing material-map related is bound here.
 
 		// Spot light gobo array — placeholder until GoboManager populates it.
 		const goboMapsTex = stage.goboMaps ? texture( stage.goboMaps ) : createArrayPlaceholder();
@@ -133,16 +122,9 @@ export class ShaderBuilder {
 		const iesProfilesTex = stage.iesProfiles ? texture( stage.iesProfiles ) : createArrayPlaceholder();
 		setIESProfilesTexture( iesProfilesTex );
 
-		// Set albedo texture array for alpha-aware shadow rays (module-level in LightsDirect.js).
-		// Always pass the texture node (real or placeholder) so alpha-cutout code is emitted
-		// into the shader at graph construction time. Runtime albedoMapIndex >= 0 guards sampling.
-		setShadowAlbedoMaps( albedoMapsTex );
-
 		const result = {
 			triStorage, bvhStorage, matStorage, lightBufferStorage,
 			envTex,
-			albedoMapsTex, normalMapsTex, bumpMapsTex,
-			metalnessMapsTex, roughnessMapsTex, emissiveMapsTex, displacementMapsTex,
 			goboMapsTex, iesProfilesTex,
 		};
 

package/src/Processor/TextureCreator.js

@@ -537,9 +537,6 @@ export class TextureCreator {
 				case 'worker-direct':
 					result = await this.processWithWorkerDirect( normalized );
 					break;
-				case 'worker-chunked':
-					result = await this.processWithWorkerChunked( normalized, strategy.chunkSize );
-					break;
 				case 'main-batch':
 					result = await this.processOnMainThreadBatch( normalized, strategy.batchSize );
 					break;
@@ -587,10 +584,10 @@ export class TextureCreator {
 
 		if ( this.capabilities.workers && estimatedMemory > MEMORY_CONSTANTS.MAX_TEXTURE_MEMORY ) {
 
-			return {
-				method: 'worker-chunked',
-				chunkSize: Math.max( 1, Math.floor( textures.length / 4 ) )
-			};
+			// Very large texture set: stream on the main thread (GC-yielding, builds the
+			// full array correctly). The former 'worker-chunked' path combined its chunks
+			// by returning only the first, silently dropping the rest — removed.
+			return { method: 'main-streaming' };
 
 		} else if ( this.capabilities.workers && totalPixels > 2097152 ) {
 
@@ -710,8 +707,18 @@ export class TextureCreator {
 
 			try {
 
-				// Option 1: Direct ImageBitmap transfer (when supported)
-				if ( typeof createImageBitmap !== 'undefined' && texture.image instanceof HTMLImageElement ) {
+				// Option 1: Direct ImageBitmap transfer (when supported). Covers HTMLImageElement
+				// AND ImageBitmap (what GLTFLoader's ImageBitmapLoader produces) and canvases — the
+				// worker extracts pixels on its OffscreenCanvas, so this keeps the full-res
+				// getImageData off the main thread (Option 2 blocks it per texture).
+				const img = texture.image;
+				const canDirect = typeof createImageBitmap !== 'undefined' && (
+					img instanceof HTMLImageElement
+					|| ( typeof ImageBitmap !== 'undefined' && img instanceof ImageBitmap )
+					|| ( typeof HTMLCanvasElement !== 'undefined' && img instanceof HTMLCanvasElement )
+					|| ( typeof OffscreenCanvas !== 'undefined' && img instanceof OffscreenCanvas )
+				);
+				if ( canDirect ) {
 
 					const bitmap = await createImageBitmap( texture.image, {
 						imageOrientation: flipY ? 'flipY' : 'none',
@@ -760,21 +767,6 @@ export class TextureCreator {
 
 	}
 
-	async processWithWorkerChunked( textures, chunkSize ) {
-
-		const results = [];
-		for ( let i = 0; i < textures.length; i += chunkSize ) {
-
-			const chunk = textures.slice( i, i + chunkSize );
-			const chunkResult = await this.processWithWorkerDirect( chunk );
-			results.push( chunkResult );
-
-		}
-
-		return this.combineTextureResults( results );
-
-	}
-
 	async processOnMainThreadBatch( textures, batchSize ) {
 
 		const validTextures = textures.filter( tex => tex?.image );
@@ -1451,14 +1443,6 @@ export class TextureCreator {
 
 	}
 
-	combineTextureResults( results ) {
-
-		// Combine multiple texture array results into one
-		// This is a simplified implementation - you may need more sophisticated merging
-		return results[ 0 ]; // For now, return first result
-
-	}
-
 	dispose() {
 
 		this.canvasPool.dispose();

package/src/Processor/Workers/BVHWorker.js

@@ -184,8 +184,13 @@ function handleAssemble( data ) {
 
 function handleFullBuild( data ) {
 
-	const { triangleData, triangleByteOffset, triangleByteLength, depth, reportProgress, treeletOptimization, reinsertionOptimization, sharedReorderBuffer } = data;
+	const { triangleData, triangleByteOffset, triangleByteLength, depth, reportProgress, treeletOptimization, reinsertionOptimization, sharedReorderBuffer, maxLeafSize, numBins, maxBins, minBins } = data;
 	const builder = new BVHBuilder();
+	// Honor the build params forwarded from SceneProcessor (previously ignored → default leaf 8).
+	if ( maxLeafSize !== undefined ) builder.maxLeafSize = maxLeafSize;
+	if ( numBins !== undefined ) builder.numBins = numBins;
+	if ( maxBins !== undefined ) builder.maxBins = maxBins;
+	if ( minBins !== undefined ) builder.minBins = minBins;
 
 	try {
 

package/src/Stages/EdgeFilter.js

@@ -105,10 +105,11 @@ export class EdgeFilter extends RenderStage {
 				const center = textureLoad( inputTex, coord ).xyz;
 				const centerLum = dot( center, REC709_LUMINANCE_COEFFICIENTS );
 
-				// NormalDepth writes (0,0,0, 1e6) for miss rays. Decoded normal
+				// NormalDepth writes (0,0,0, 65504) for miss rays. Decoded normal
 				// (-1,-1,-1) is non-unit and explodes pow(dot, phi); use the depth
-				// sentinel as a 0/1 hit flag and zero out cross-kind weights.
-				const MISS_THRESHOLD = 1e5;
+				// sentinel as a 0/1 hit flag and zero out cross-kind weights. Threshold
+				// sits below the 65504 sentinel (and above any real depth).
+				const MISS_THRESHOLD = 6e4;
 				const centerND = textureLoad( ndTex, coord );
 				const centerNormal = centerND.xyz.mul( 2.0 ).sub( 1.0 );
 				const centerDepth = centerND.w;

package/src/Stages/MotionVector.js

@@ -172,8 +172,8 @@ export class MotionVector extends RenderStage {
 
 				const result = vec4( 0.0, 0.0, linearDepth, 1.0 ).toVar();
 
-				// Sky / background (depth >= 1e5) — no motion
-				If( linearDepth.lessThan( float( 1e5 ) ), () => {
+				// Sky / background (depth >= 65504 sentinel) — no motion
+				If( linearDepth.lessThan( float( 6e4 ) ), () => {
 
 					// Pixel coordinate → NDC
 					// Negate Y to match PathTracer convention
@@ -275,8 +275,8 @@ export class MotionVector extends RenderStage {
 
 				const result = vec4( 0.0, 0.0, 0.0, 0.0 ).toVar();
 
-				// Skip first frame and sky
-				If( isFirstFrameU.lessThan( 0.5 ).and( linearDepth.lessThan( float( 1e5 ) ) ), () => {
+				// Skip first frame and sky (depth >= 65504 sentinel)
+				If( isFirstFrameU.lessThan( 0.5 ).and( linearDepth.lessThan( float( 6e4 ) ) ), () => {
 
 					// Pixel coordinate → NDC
 					// Negate Y to match PathTracer convention