rayzee 10.0.0 → 11.1.0

package/src/Processor/Workers/BVHSubtreeWorker.js

@@ -1,5 +1,4 @@
 import { BVHBuilder } from '../BVHBuilder.js';
-import { TreeletOptimizer } from '../TreeletOptimizer.js';
 import { ReinsertionOptimizer } from '../ReinsertionOptimizer.js';
 
 self.onmessage = function ( e ) {
@@ -9,7 +8,6 @@ self.onmessage = function ( e ) {
 		sharedTriangleData, sharedCentroids, sharedBMin, sharedBMax, sharedIndices,
 		triangleCount,
 		maxLeafSize, numBins, maxBins, minBins,
-		treeletConfig,
 		reinsertionConfig,
 		reportProgress
 	} = e.data;
@@ -46,8 +44,7 @@ self.onmessage = function ( e ) {
 			builder.splitStats = {
 				sahSplits: 0, objectMedianSplits: 0, spatialMedianSplits: 0,
 				failedSplits: 0, avgBinsUsed: 0, totalSplitAttempts: 0,
-				mortonSortTime: 0, totalBuildTime: 0, treeletOptimizationTime: 0,
-				treeletsProcessed: 0, treeletsImproved: 0, averageSAHImprovement: 0,
+				mortonSortTime: 0, totalBuildTime: 0,
 				initTime: 0, sahBuildTime: 0, reorderTime: 0
 			};
 
@@ -70,36 +67,6 @@ self.onmessage = function ( e ) {
 				task.preMaxX, task.preMaxY, task.preMaxZ
 			);
 
-			// Treelet optimization on subtree
-			if ( treeletConfig && treeletConfig.enabled && ( task.end - task.start ) > 1000 ) {
-
-				const isLargeSubtree = ( task.end - task.start ) > 50000;
-				const adaptiveSize = isLargeSubtree ? 3 : ( treeletConfig.size || 5 );
-				const adaptiveMax = isLargeSubtree ? 10 : 20;
-
-				const optimizer = new TreeletOptimizer( builder.traversalCost, builder.intersectionCost );
-				optimizer.setTreeletSize( adaptiveSize );
-				optimizer.setMinImprovement( treeletConfig.minImprovement || 0.02 );
-				optimizer.setMaxTreelets( adaptiveMax );
-
-				const passes = treeletConfig.passes || 1;
-				for ( let pass = 0; pass < passes; pass ++ ) {
-
-					try {
-
-						optimizer.optimizeBVH( root, null );
-
-					} catch ( err ) {
-
-						console.error( `[BVHSubtreeWorker] Treelet pass ${pass + 1} error:`, err );
-						break;
-
-					}
-
-				}
-
-			}
-
 			// Reinsertion optimization on subtree
 			if ( reinsertionConfig && reinsertionConfig.enabled && ( task.end - task.start ) > 1000 ) {
 

package/src/Processor/Workers/BVHWorker.js

@@ -41,19 +41,13 @@ function handlePhase1( data ) {
 		sharedTriangleData, sharedCentroids, sharedBMin, sharedBMax,
 		sharedIndices, sharedMortonCodes,
 		triangleCount, depth, parallelDepth,
-		reportProgress, treeletOptimization
+		reportProgress
 	} = data;
 
 	try {
 
 		const builder = new BVHBuilder();
 
-		if ( treeletOptimization ) {
-
-			builder.setTreeletConfig( treeletOptimization );
-
-		}
-
 		const progressCallback = reportProgress ? ( progress ) => {
 
 			self.postMessage( { type: 'progress', progress } );
@@ -77,8 +71,7 @@ function handlePhase1( data ) {
 		builder.splitStats = {
 			sahSplits: 0, objectMedianSplits: 0, spatialMedianSplits: 0,
 			failedSplits: 0, avgBinsUsed: 0, totalSplitAttempts: 0,
-			mortonSortTime: 0, totalBuildTime: 0, treeletOptimizationTime: 0,
-			treeletsProcessed: 0, treeletsImproved: 0, averageSAHImprovement: 0,
+			mortonSortTime: 0, totalBuildTime: 0,
 			initTime: 0, sahBuildTime: 0, reorderTime: 0
 		};
 
@@ -193,7 +186,7 @@ function handleAssemble( data ) {
 
 function handleFullBuild( data ) {
 
-	const { triangleData, triangleByteOffset, triangleByteLength, depth, reportProgress, treeletOptimization, reinsertionOptimization, sharedReorderBuffer, maxLeafSize, numBins, maxBins, minBins, foldLeaves: fold } = data;
+	const { triangleData, triangleByteOffset, triangleByteLength, depth, reportProgress, reinsertionOptimization, sharedReorderBuffer, maxLeafSize, numBins, maxBins, minBins, foldLeaves: fold } = data;
 	const builder = new BVHBuilder();
 	// Honor the build params forwarded from SceneProcessor (previously ignored → default leaf 8).
 	if ( maxLeafSize !== undefined ) builder.maxLeafSize = maxLeafSize;
@@ -203,12 +196,6 @@ function handleFullBuild( data ) {
 
 	try {
 
-		if ( treeletOptimization ) {
-
-			builder.setTreeletConfig( treeletOptimization );
-
-		}
-
 		if ( reinsertionOptimization ) {
 
 			builder.setReinsertionConfig( reinsertionOptimization );
@@ -248,7 +235,7 @@ function handleFullBuild( data ) {
 				bvhData,
 				originalToBvh,
 				triangleCount: inputTriangles.length / FPT,
-				treeletStats: builder.splitStats
+				splitStats: builder.splitStats
 			}, transferables );
 
 		} else {
@@ -264,7 +251,7 @@ function handleFullBuild( data ) {
 				triangles: reordered,
 				originalToBvh,
 				triangleCount,
-				treeletStats: builder.splitStats
+				splitStats: builder.splitStats
 			}, transferables );
 
 		}

package/src/Processor/Workers/CDFWorker.js

@@ -1,179 +1,11 @@
 /**
- * Web Worker for computing environment map CDF (Cumulative Distribution Function)
- * for importance sampling. Pure math — no Three.js dependencies.
+ * Web Worker for an environment map's sampling table (EnvironmentExactTable.js). Pure math — no Three.js dependencies.
  *
  * Input:  { floatData: Float32Array, width, height }
- * Output: { marginalData: Float32Array, conditionalData: Float32Array, totalSum, width, height }
+ * Output: { width, height } and the table
  */
 
-function binarySearchFindClosestIndexOf( array, targetValue, offset, count ) {
-
-	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;
-
-}
-
-function buildCDF( 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 r = floatData[ 4 * i ];
-			const g = floatData[ 4 * i + 1 ];
-			const b = floatData[ 4 * i + 2 ];
-
-			// Luminance (Rec. 709) weighted by solid angle factor
-			const w = ( 0.2126 * r + 0.7152 * g + 0.0722 * b ) * 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 ) {
-
-		// Restore raw sin-weighted luminance
-		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 r = floatData[ 4 * i ];
-				const g = floatData[ 4 * i + 1 ];
-				const b = floatData[ 4 * i + 2 ];
-				pixelWeights[ i ] = ( 0.2126 * r + 0.7152 * g + 0.0722 * b ) * 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;
-
-		}
-
-	}
-
-	// Invert marginal CDF
-	const marginalData = new Float32Array( height );
-	for ( let i = 0; i < height; i ++ ) {
-
-		const dist = ( i + 1 ) / height;
-		const row = binarySearchFindClosestIndexOf( cdfMarginal, dist, 0, height );
-		marginalData[ i ] = ( row + 0.5 ) / height;
-
-	}
-
-	// Invert conditional CDFs
-	const conditionalData = new Float32Array( width * height );
-	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 };
-
-}
+import { buildExactEnvironmentTable } from '../EnvironmentExactTable.js';
 
 self.onmessage = function ( e ) {
 
@@ -181,19 +13,10 @@ self.onmessage = function ( e ) {
 
 	try {
 
-		const result = buildCDF( floatData, width, height );
-
-		// Transfer arrays back zero-copy
+		const table = buildExactEnvironmentTable( floatData, width, height );
 		self.postMessage(
-			{
-				marginalData: result.marginalData,
-				conditionalData: result.conditionalData,
-				totalSum: result.totalSum,
-				compensationDelta: result.compensationDelta,
-				width,
-				height,
-			},
-			[ result.marginalData.buffer, result.conditionalData.buffer ]
+			{ width, height, ...table },
+			[ table.exactConditional.buffer, table.exactMarginal.buffer, table.exactRowGuide.buffer, table.exactMarginalGuide.buffer ]
 		);
 
 	} catch ( error ) {

package/src/Processor/Workers/TexturesWorker.js

@@ -1,16 +1,114 @@
+import { TEXTURE_CONSTANTS, alignBucketWidth } from '../TextureBuckets.js';
+
 let canvas, ctx;
 
 // Memory limits and chunking configuration
 const MEMORY_LIMITS = {
-	MAX_BYTES_PER_TEXTURE: 256 * 1024 * 1024, // 256MB per texture array
-	MAX_TEXTURE_DIMENSION: 8192, // Hardware ceiling (WebGPU maxTextureDimension2D guaranteed min); the per-scene maxTextureSize setting is the actual knob
 	CHUNK_SIZE: 8, // Optimized: Process textures in chunks of 8 for better memory locality
 	ADAPTIVE_CHUNK_SIZE: true, // Enable adaptive chunk sizing based on texture dimensions
 	MEMORY_SAFETY_FACTOR: 0.8 // Use only 80% of estimated available memory
 };
 
+let stream = null;
+
+function handleStream( msg ) {
+
+	if ( msg.stream === 'begin' ) {
+
+		const { width, height, depth } = msg;
+		const target = new OffscreenCanvas( width, height );
+		const context = target.getContext( '2d', { willReadFrequently: true, alpha: true, desynchronized: true } );
+		stream = { width, height, depth, context, data: new Uint8Array( width * height * depth * 4 ) };
+		return;
+
+	}
+
+	const { width, height, depth, context, data } = stream;
+
+	if ( msg.stream === 'layer' ) {
+
+		context.clearRect( 0, 0, width, height );
+		context.drawImage( msg.bitmap, 0, 0 );
+		msg.bitmap.close();
+		data.set( context.getImageData( 0, 0, width, height ).data, width * height * 4 * msg.index );
+		self.postMessage( { stream: 'ack', index: msg.index } );
+		return;
+
+	}
+
+	stream = null;
+	self.postMessage( { data: data.buffer, width, height, depth }, [ data.buffer ] );
+
+}
+
+async function processIntoShared( { shared, width, height, layers } ) {
+
+	if ( canvas.width !== width || canvas.height !== height ) {
+
+		canvas.width = width;
+		canvas.height = height;
+
+	}
+
+	ctx.imageSmoothingEnabled = true;
+	ctx.imageSmoothingQuality = 'high';
+
+	const data = new Uint8Array( shared );
+	const bytes = width * height * 4;
+
+	for ( const { index, texture } of layers ) {
+
+		try {
+
+			await processSingleTextureOptimized( texture, data, index * bytes, width, height );
+
+		} catch ( error ) {
+
+			console.warn( `Failed to process texture ${index}:`, error );
+			data.fill( 0, index * bytes, ( index + 1 ) * bytes );
+
+		}
+
+	}
+
+}
+
 self.onmessage = async function ( e ) {
 
+	if ( e.data.shared ) {
+
+		try {
+
+			if ( ! canvas ) initializeWorker( e.data.maxTextureSize );
+			await processIntoShared( e.data );
+			self.postMessage( { done: true } );
+
+		} catch ( error ) {
+
+			self.postMessage( { error: error.message } );
+
+		}
+
+		return;
+
+	}
+
+	if ( e.data.stream ) {
+
+		try {
+
+			handleStream( e.data );
+
+		} catch ( error ) {
+
+			self.postMessage( { error: error.message } );
+
+		}
+
+		return;
+
+	}
+
 	const { textures, maxTextureSize, method = 'direct-transfer' } = e.data;
 
 	try {
@@ -39,7 +137,7 @@ self.onmessage = async function ( e ) {
 function initializeWorker( maxTextureSize ) {
 
 	// Initialize OffscreenCanvas with optimal settings
-	const size = Math.min( maxTextureSize, MEMORY_LIMITS.MAX_TEXTURE_DIMENSION );
+	const size = Math.min( maxTextureSize, TEXTURE_CONSTANTS.MAX_TEXTURE_SIZE );
 	canvas = new OffscreenCanvas( size, size );
 	ctx = canvas.getContext( '2d', {
 		willReadFrequently: true,
@@ -51,17 +149,6 @@ function initializeWorker( maxTextureSize ) {
 
 async function processTextures( textures, maxTextureSize, method ) {
 
-	// Check if we need to use chunked processing
-	const dimensions = calculateOptimalDimensions( textures, maxTextureSize );
-	const estimatedBytes = dimensions.maxWidth * dimensions.maxHeight * textures.length * 4;
-
-	if ( estimatedBytes > MEMORY_LIMITS.MAX_BYTES_PER_TEXTURE ) {
-
-		console.log( `Large texture array detected (${( estimatedBytes / 1024 / 1024 ).toFixed( 2 )}MB), using chunked processing` );
-		return await processTexturesInChunks( textures, maxTextureSize, method );
-
-	}
-
 	switch ( method ) {
 
 		case 'direct-transfer':
@@ -620,7 +707,7 @@ function calculateOptimalDimensions( textures, maxTextureSize ) {
 	}
 
 	// Scale down proportionally only when the cap is exceeded; native res is kept below it.
-	const cap = Math.min( maxTextureSize, MEMORY_LIMITS.MAX_TEXTURE_DIMENSION );
+	const cap = Math.min( maxTextureSize, TEXTURE_CONSTANTS.MAX_TEXTURE_SIZE );
 	const longest = Math.max( maxWidth, maxHeight );
 	if ( longest > cap ) {
 
@@ -630,9 +717,7 @@ function calculateOptimalDimensions( textures, maxTextureSize ) {
 
 	}
 
-	// An RGBA8 row upload must be a multiple of 256 bytes, so widths land on 64 texels.
-	// Mirrors alignBucketWidth in EngineDefaults (not importable from worker context).
-	maxWidth = Math.min( cap, Math.max( 4, Math.ceil( Math.max( 1, maxWidth ) / 64 ) * 64 ) );
+	maxWidth = alignBucketWidth( maxWidth, cap );
 
 	return { maxWidth, maxHeight: Math.max( 1, maxHeight ) };
 

package/src/Processor/archiveFormats.js

@@ -0,0 +1,7 @@
+/** What the archive add-on reads, known before its code loads (rayzee/addons/archives; PathTracerApp loads it on first use). */
+export const ARCHIVE_FORMATS = Object.freeze( {
+	'zip': { type: 'archive', name: 'ZIP Archive' },
+	'gz': { type: 'archive', name: 'Gzipped TAR Archive' },
+	'tgz': { type: 'archive', name: 'Gzipped TAR Archive' },
+	'tar': { type: 'archive', name: 'TAR Archive' },
+} );

package/src/Processor/utils.js

@@ -63,7 +63,8 @@ export function disposeMaterialTextures( material ) {
 	const textures = [
 		'alphaMap', 'aoMap', 'bumpMap', 'clearcoatMap', 'clearcoatNormalMap', 'clearcoatRoughnessMap', 'displacementMap',
 		'emissiveMap', 'envMap', 'gradientMap', 'lightMap', 'map', 'metalnessMap', 'normalMap', 'roughnessMap', 'specularMap',
-		'sheenColorMap', 'sheenRoughnessMap', 'specularIntensityMap', 'specularColorMap', 'thicknessMap', 'transmissionMap'
+		'sheenColorMap', 'sheenRoughnessMap', 'specularIntensityMap', 'specularColorMap', 'thicknessMap', 'transmissionMap',
+		'diffuseTransmissionMap', 'diffuseTransmissionColorMap',
 	];
 
 	textures.forEach( texture => {