rayzee 7.16.0 → 7.18.0

package/src/Processor/Workers/BVHWorker.js

@@ -1,4 +1,7 @@
 import { BVHBuilder } from '../BVHBuilder.js';
+import { createLogger, fmt, applyWorkerLogLevel } from '../../utils/Logger.js';
+
+const log = createLogger( 'bvh' );
 
 const FPT = 32; // FLOATS_PER_TRIANGLE
 
@@ -9,6 +12,9 @@ self.onmessage = function ( e ) {
 	const data = e.data;
 	const type = data.type;
 
+	// Workers get their own globals, so the main thread forwards its level per message.
+	applyWorkerLogLevel( data.logLevel );
+
 	if ( type === 'buildPhase1' ) {
 
 		handlePhase1( data );
@@ -100,7 +106,7 @@ function handlePhase1( data ) {
 		const flattenTime = performance.now() - flattenStart;
 
 		const totalTime = performance.now() - startTime;
-		console.log( `[BVHWorker] Phase 1: ${Math.round( totalTime )}ms (init: ${Math.round( builder.splitStats.initTime )}ms, morton: ${Math.round( builder.splitStats.mortonSortTime )}ms, SAH: ${Math.round( builder.splitStats.sahBuildTime )}ms, flatten: ${Math.round( flattenTime )}ms), ${builder.frontierTasks.length} frontier tasks` );
+		log.debug( `phase 1 ${fmt.ms( totalTime )} (init ${fmt.ms( builder.splitStats.initTime )} · morton ${fmt.ms( builder.splitStats.mortonSortTime )} · SAH ${fmt.ms( builder.splitStats.sahBuildTime )} · flatten ${fmt.ms( flattenTime )}) · ${builder.frontierTasks.length} frontier tasks` );
 
 		self.postMessage( {
 			type: 'phase1Result',
@@ -113,7 +119,7 @@ function handlePhase1( data ) {
 
 	} catch ( error ) {
 
-		console.error( '[BVHWorker] Phase 1 error:', error );
+		log.error( 'phase 1 failed:', error );
 		self.postMessage( { type: 'error', error: error.message } );
 
 	}
@@ -162,7 +168,7 @@ function handleAssemble( data ) {
 		}
 
 		const totalTime = performance.now() - startTime;
-		console.log( `[BVHWorker] Phase 3 (assemble + reorder): ${Math.round( totalTime )}ms (${( bvhData.byteLength / 1024 / 1024 ).toFixed( 1 )}MB BVH)` );
+		log.debug( `phase 3 assemble + reorder ${fmt.ms( totalTime )} (${fmt.mb( bvhData.byteLength )} BVH)` );
 
 		self.postMessage( {
 			type: 'assembleResult',
@@ -173,7 +179,7 @@ function handleAssemble( data ) {
 
 	} catch ( error ) {
 
-		console.error( '[BVHWorker] Assembly error:', error );
+		log.error( 'assembly failed:', error );
 		self.postMessage( { type: 'error', error: error.message } );
 
 	}
@@ -225,7 +231,7 @@ function handleFullBuild( data ) {
 		const flattenStart = performance.now();
 		const bvhData = builder.flattenBVH( bvhRoot );
 		const flattenTime = performance.now() - flattenStart;
-		console.log( `[BVHWorker] Flatten BVH: ${Math.round( flattenTime )}ms (${( bvhData.byteLength / 1024 / 1024 ).toFixed( 1 )}MB)` );
+		log.debug( `flatten ${fmt.ms( flattenTime )} (${fmt.mb( bvhData.byteLength )})` );
 
 		const originalToBvh = builder.originalToBvhMap || null;
 
@@ -261,7 +267,7 @@ function handleFullBuild( data ) {
 
 	} catch ( error ) {
 
-		console.error( '[BVHWorker] Error:', error );
+		log.error( 'build failed:', error );
 		self.postMessage( { error: error.message } );
 
 	}

package/src/RenderSettings.js

@@ -18,6 +18,7 @@ const SETTING_ROUTES = {
 	maxBounces: { uniform: 'maxBounces', reset: true },
 	transmissiveBounces: { uniform: 'transmissiveBounces', reset: true },
 	maxSubsurfaceSteps: { uniform: 'maxSubsurfaceSteps', reset: true },
+	maxTransparentBounces: { uniform: 'maxTransparentBounces', reset: true },
 	environmentIntensity: { uniform: 'environmentIntensity', reset: true },
 	backgroundIntensity: { uniform: 'backgroundIntensity', reset: true },
 	backgroundBlurriness: { uniform: 'backgroundBlurriness', reset: true },
@@ -43,7 +44,6 @@ const SETTING_ROUTES = {
 	// Adaptive sampling — whole-frame early-stop (useAdaptiveSampling) + per-pixel freeze (usePixelFreeze)
 	useAdaptiveSampling: { uniform: 'useAdaptiveSampling', reset: true },
 	noiseThreshold: { uniform: 'noiseThreshold', reset: true },
-	darkNoiseFloor: { uniform: 'darkNoiseFloor', reset: true },
 	adaptiveMinSamples: { uniform: 'adaptiveMinSamples', reset: true },
 	adaptiveStopFraction: { uniform: 'adaptiveStopFraction', reset: true },
 	usePixelFreeze: { uniform: 'usePixelFreeze', reset: true },

package/src/Stages/ASVGF.js

@@ -796,6 +796,44 @@ export class ASVGF extends RenderStage {
 
 	}
 
+	// Reserved-storage change (e.g. 4K toggle): recreate the MAX-preallocated StorageTextures at the new live
+	// reserved size + rebuild all compute nodes in place. Same stage object, so refs/wiring stay valid. Fresh
+	// build ⇒ the first-render warmup re-runs (no aliasing — the nodes are new, matching initial construction).
+	reallocateReservedStorage() {
+
+		this._gradientNode?.dispose();
+		this._temporalNodeA?.dispose();
+		this._temporalNodeB?.dispose();
+		this._heatmapComputeNode?.dispose();
+		this._temporalTexA?.dispose();
+		this._temporalTexB?.dispose();
+		this._outputModulatedTex?.dispose();
+		this._gradientStorageTex?.dispose();
+		this._heatmapStorageTex?.dispose();
+
+		const mk = ( type, filter ) => {
+
+			const t = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
+			t.type = type; t.format = RGBAFormat; t.minFilter = filter; t.magFilter = filter;
+			return t;
+
+		};
+
+		this._temporalTexA = mk( FloatType, LinearFilter );
+		this._temporalTexB = mk( FloatType, LinearFilter );
+		this._outputModulatedTex = mk( FloatType, LinearFilter );
+		this._gradientStorageTex = mk( HalfFloatType, LinearFilter );
+		this._heatmapStorageTex = mk( FloatType, NearestFilter );
+
+		this._buildGradientCompute();
+		this._buildTemporalCompute();
+		this._buildHeatmapCompute();
+		this._compiled = false;
+		this.currentMoments = 0;
+		this._needsWarmReset = true;
+
+	}
+
 	setSize( width, height ) {
 
 		// StorageTextures stay at max alloc — see resize crash fix (three.js #33061).

package/src/Stages/BilateralFilter.js

@@ -385,6 +385,29 @@ export class BilateralFilter extends RenderStage {
 
 	}
 
+	// Reserved-storage change (e.g. 4K toggle): recreate the MAX-preallocated StorageTextures at the new live
+	// reserved size + rebuild the compute nodes in place. Same stage object, so refs/wiring stay valid.
+	reallocateReservedStorage() {
+
+		this._computeNodeA?.dispose();
+		this._computeNodeB?.dispose();
+		this._storageTexA?.dispose();
+		this._storageTexB?.dispose();
+		const mk = () => {
+
+			const t = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
+			t.type = HalfFloatType; t.format = RGBAFormat; t.minFilter = LinearFilter; t.magFilter = LinearFilter;
+			return t;
+
+		};
+
+		this._storageTexA = mk();
+		this._storageTexB = mk();
+		this._buildCompute();
+		this._compiled = false;
+
+	}
+
 	dispose() {
 
 		this._computeNodeA?.dispose();

package/src/Stages/EdgeFilter.js

@@ -454,6 +454,24 @@ export class EdgeFilter extends RenderStage {
 
 	}
 
+	// Reserved-storage change (e.g. 4K toggle): recreate the MAX-preallocated StorageTextures at the new live
+	// reserved size + rebuild the compute nodes in place. Same stage object, so refs/wiring stay valid.
+	reallocateReservedStorage() {
+
+		this._computeDemod?.dispose();
+		this._computeAtrousA?.dispose();
+		this._computeAtrousB?.dispose();
+		this._demodTex?.dispose();
+		this._storageTexA?.dispose();
+		this._storageTexB?.dispose();
+		this._demodTex = this._makeStorageTex();
+		this._storageTexA = this._makeStorageTex();
+		this._storageTexB = this._makeStorageTex();
+		this._buildCompute();
+		this._compiled = false;
+
+	}
+
 	dispose() {
 
 		this._computeDemod?.dispose();

package/src/Stages/MotionVector.js

@@ -556,6 +556,29 @@ export class MotionVector extends RenderStage {
 
 	}
 
+	// Reserved-storage change (e.g. 4K toggle): recreate the MAX-preallocated StorageTextures at the new live
+	// reserved size + rebuild the compute nodes in place. Same stage object, so refs/wiring stay valid.
+	reallocateReservedStorage() {
+
+		this._screenSpaceComputeNode?.dispose();
+		this._worldSpaceComputeNode?.dispose();
+		this._screenSpaceStorageTex?.dispose();
+		this._worldSpaceStorageTex?.dispose();
+		const mk = () => {
+
+			const t = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
+			t.type = HalfFloatType; t.format = RGBAFormat; t.minFilter = NearestFilter; t.magFilter = NearestFilter;
+			return t;
+
+		};
+
+		this._screenSpaceStorageTex = mk();
+		this._worldSpaceStorageTex = mk();
+		this._buildScreenSpaceCompute();
+		this._buildWorldSpaceCompute();
+
+	}
+
 	dispose() {
 
 		this._screenSpaceComputeNode?.dispose();

package/src/Stages/NormalDepth.js

@@ -405,6 +405,28 @@ export class NormalDepth extends RenderStage {
 
 	}
 
+	// Reserved-storage change (e.g. 4K toggle): recreate the MAX-preallocated StorageTextures at the new live
+	// reserved size. The compute node rebuilds lazily on the next execute (guarded by _computeBuilt).
+	reallocateReservedStorage() {
+
+		this._computeNode?.dispose();
+		this._computeNode = null;
+		this._outputStorageTex?.dispose();
+		this._shadingStorageTex?.dispose();
+		const mk = () => {
+
+			const t = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
+			t.type = HalfFloatType; t.format = RGBAFormat; t.minFilter = NearestFilter; t.magFilter = NearestFilter;
+			return t;
+
+		};
+
+		this._outputStorageTex = mk();
+		this._shadingStorageTex = mk();
+		this._computeBuilt = false;
+
+	}
+
 	dispose() {
 
 		this._computeNode?.dispose();