rayzee 7.8.0 → 7.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "7.8.0",
+  "version": "7.9.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/EngineEvents.js

@@ -54,4 +54,5 @@ export const EngineEvents = {
 
 	// Lifecycle
 	DISPOSE: 'engine:dispose',
+	DEVICE_LOST: 'engine:deviceLost',
 };

package/src/Passes/OIDNDenoiser.js

@@ -142,6 +142,9 @@ export class OIDNDenoiser extends EventDispatcher {
 
 		this.currentTZAUrl = null;
 		this.unet = null;
+		// A start() requested while the UNet is still loading is deferred here and fired
+		// once loading finishes, instead of being silently dropped.
+		this._pendingStart = false;
 
 		// Initialize asynchronously
 		this._initialize().catch( error => {
@@ -257,6 +260,15 @@ export class OIDNDenoiser extends EventDispatcher {
 
 			this.state.isLoading = false;
 
+			// Fire a start() that arrived mid-load. Guard on unet+enabled so a failed load
+			// or a disable during loading doesn't kick off a denoise.
+			if ( this._pendingStart && this.unet && this.enabled ) {
+
+				this._pendingStart = false;
+				this.start();
+
+			}
+
 		}
 
 	}
@@ -302,8 +314,17 @@ export class OIDNDenoiser extends EventDispatcher {
 
 	async start() {
 
-		if ( ! this.enabled || this.state.isDenoising || this.state.isLoading ) {
+		if ( ! this.enabled || this.state.isDenoising ) {
+
+			return false;
+
+		}
 
+		// UNet weights still loading — defer the start (fired from _setupUNetDenoiser's
+		// finally) rather than silently dropping this frame's denoise request.
+		if ( this.state.isLoading ) {
+
+			this._pendingStart = true;
 			return false;
 
 		}
@@ -870,6 +891,9 @@ export class OIDNDenoiser extends EventDispatcher {
 
 	abort() {
 
+		// Cancel any start deferred during loading so a reset supersedes it.
+		this._pendingStart = false;
+
 		if ( ! this.enabled || ! this.state.isDenoising ) return;
 
 		// Signal abort to current operation

package/src/PathTracerApp.js

@@ -157,6 +157,7 @@ export class PathTracerApp extends EventDispatcher {
 		// Tracked listeners for clean dispose()
 		this._trackedListeners = [];
 		this._disposed = false;
+		this._deviceLost = false;
 
 	}
 
@@ -230,6 +231,9 @@ export class PathTracerApp extends EventDispatcher {
 	 */
 	animate() {
 
+		// Device lost: stop the loop rather than rescheduling render() on a dead device.
+		if ( this._deviceLost ) return;
+
 		this.animationManagerId = requestAnimationFrame( () => this.animate() );
 
 		if ( this._loadingInProgress || this._sdf?.isProcessing ) {
@@ -368,9 +372,25 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	/**
+	 * Handle GPU device loss: halt the render loop and notify hosts so they can surface a
+	 * "renderer lost — reload" prompt. Full auto-recovery would require rebuilding every GPU
+	 * resource, so this deliberately stops cleanly rather than attempting to re-init.
+	 */
+	_handleDeviceLost( info ) {
+
+		if ( this._deviceLost ) return;
+		this._deviceLost = true;
+		console.error( `WebGPU device lost (${info?.reason || 'unknown'}): ${info?.message || ''}` );
+		this.stopAnimation();
+		this.dispatchEvent( { type: EngineEvents.DEVICE_LOST, reason: info?.reason, message: info?.message } );
+
+	}
+
 	/** Wakes the animation loop if it was stopped due to idle. */
 	wake() {
 
+		if ( this._deviceLost ) return;
 		if ( ! this.animationManagerId && this.isInitialized && ! this._paused ) this.animate();
 
 	}
@@ -1385,6 +1405,22 @@ export class PathTracerApp extends EventDispatcher {
 
 		await this.renderer.init();
 
+		// Detect GPU device loss (dGPU/iGPU switch, driver reset, TDR watchdog on heavy
+		// compute). Without this the rAF loop keeps calling render() on a dead device,
+		// spewing errors forever. reason 'destroyed' during dispose() is intentional teardown.
+		const gpuDevice = this.renderer.backend?.device;
+		if ( gpuDevice?.lost ) {
+
+			gpuDevice.lost.then( ( info ) => {
+
+				if ( this._disposed ) return;
+				this._handleDeviceLost( info );
+
+			} );
+			gpuDevice.onuncapturederror = ( event ) => console.error( 'WebGPU uncaptured error:', event.error );
+
+		}
+
 		RectAreaLightNode.setLTC( RectAreaLightTexturesLib.init() );
 
 		this.renderer.outputColorSpace = SRGBColorSpace;

package/src/Processor/AssetLoader.js

@@ -292,6 +292,9 @@ export class AssetLoader extends EventDispatcher {
 
 			if ( ! this.loaderCache.texture ) this.loaderCache.texture = new TextureLoader();
 			texture = await this.loaderCache.texture.loadAsync( url );
+			// LDR env maps (jpg/png/webp) are authored in sRGB; tag them so the backend
+			// decodes to linear. HDR/EXR are already linear and keep the loader's setting.
+			texture.colorSpace = SRGBColorSpace;
 
 		}
 

package/src/Processor/GeometryExtractor.js

@@ -45,8 +45,12 @@ export class GeometryExtractor {
 
 		this.resetArrays();
 
-		// Single-pass: allocate with initial capacity, grow dynamically as needed
-		this._triangleCapacity = 1024;
+		// Pre-count the exact triangle total so the buffer is allocated once.
+		// Doubling-with-copy rounded up to the next power of two (wasting ~1GB on
+		// an 8.5M-tri scene) and held old+new during the copy (~3GB transient),
+		// which overflowed the browser's ArrayBuffer allocator. Exact avoids both.
+		const totalTriangles = this._countTriangles( object );
+		this._triangleCapacity = Math.max( 1024, totalTriangles );
 		this.triangleData = new Float32Array( this._triangleCapacity * TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE );
 		this.currentTriangleIndex = 0;
 
@@ -58,19 +62,41 @@ export class GeometryExtractor {
 
 	}
 
-	// Ensure triangleData has capacity for at least `needed` triangles
+	// Sum the exact triangle count over every mesh extract() will process
+	// (mirrors traverseObject/processMesh guards) so we can allocate once.
+	_countTriangles( object ) {
+
+		let count = 0;
+
+		if ( object.isMesh && object.geometry && object.material ) {
+
+			const indices = object.geometry.index;
+			const positions = object.geometry.attributes.position;
+			if ( indices ) count += Math.ceil( indices.count / 3 );
+			else if ( positions ) count += Math.ceil( positions.count / 3 );
+
+		}
+
+		if ( object.children ) {
+
+			for ( const child of object.children ) count += this._countTriangles( child );
+
+		}
+
+		return count;
+
+	}
+
+	// Safety net only: extract() pre-counts and allocates exactly, so this should
+	// not fire. Grow to exactly `needed` (never double) to avoid a memory spike.
 	_ensureCapacity( needed ) {
 
 		if ( needed <= this._triangleCapacity ) return;
 
-		// Double until sufficient
-		let newCapacity = this._triangleCapacity;
-		while ( newCapacity < needed ) newCapacity *= 2;
-
-		const newData = new Float32Array( newCapacity * TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE );
+		const newData = new Float32Array( needed * TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE );
 		newData.set( this.triangleData );
 		this.triangleData = newData;
-		this._triangleCapacity = newCapacity;
+		this._triangleCapacity = needed;
 
 	}
 

package/src/Processor/PackedRayBuffer.js

@@ -38,6 +38,16 @@ let _cap = 0;
 
 const soa = ( id, slot ) => ( slot === 0 ? id : id.add( slot * _cap ) );
 
+// Free a compute storage attribute's GPU buffer. Nulling the JS reference alone leaks it —
+// these attributes hang off no geometry, so nothing triggers the renderer's attribute cleanup.
+// Deleting from the renderer's attribute map calls backend.destroyAttribute(). Guarded no-op
+// when the attribute was never uploaded or no renderer was provided (e.g. unit tests).
+export function freeStorageAttribute( renderer, attr ) {
+
+	if ( attr ) renderer?._attributes?.delete?.( attr );
+
+}
+
 export class PackedRayBuffer {
 
 	// Capacity maxRays would allocate (mirrors allocate()/resize()). 1.25× headroom, NO pow2 rounding —
@@ -49,9 +59,10 @@ export class PackedRayBuffer {
 
 	}
 
-	constructor( maxRays = 0 ) {
+	constructor( maxRays = 0, renderer = null ) {
 
 		this.capacity = 0;
+		this._renderer = renderer;
 		this._attrs = {};
 
 		// Each: { rw: StorageBufferNode, ro: StorageBufferNode } over one shared GPU buffer.
@@ -118,6 +129,9 @@ export class PackedRayBuffer {
 
 	dispose() {
 
+		freeStorageAttribute( this._renderer, this._attrs.ray );
+		freeStorageAttribute( this._renderer, this._attrs.rng );
+		freeStorageAttribute( this._renderer, this._attrs.hit );
 		this._attrs = {};
 		this.rayBuffer = null;
 		this.rngBuffer = null;

package/src/Processor/QueueManager.js

@@ -4,6 +4,7 @@
 
 import { storage } from 'three/tsl';
 import { StorageInstancedBufferAttribute } from 'three/webgpu';
+import { freeStorageAttribute } from './PackedRayBuffer.js';
 
 /** Counter indices — must match ResetCounters kernel */
 export const COUNTER = {
@@ -33,8 +34,9 @@ export class QueueManager {
 	/**
 	 * @param {number} maxRays - Maximum number of rays (typically width * height)
 	 */
-	constructor( maxRays = 0 ) {
+	constructor( maxRays = 0, renderer = null ) {
 
+		this._renderer = renderer;
 		this.capacity = 0;
 		this.counters = null;
 		// A/B alternate: one read by current bounce, other written by compaction
@@ -197,6 +199,16 @@ export class QueueManager {
 
 	dispose() {
 
+		// Free the GPU buffers before dropping the node references (nulling alone leaks them).
+		freeStorageAttribute( this._renderer, this._countersAttr );
+		freeStorageAttribute( this._renderer, this._bounceCountsAttr );
+		freeStorageAttribute( this._renderer, this._attrA );
+		freeStorageAttribute( this._renderer, this._attrB );
+		freeStorageAttribute( this._renderer, this._sortAttr );
+		freeStorageAttribute( this._renderer, this._sortGlobalHistAttr );
+		this._countersAttr = this._bounceCountsAttr = null;
+		this._attrA = this._attrB = this._sortAttr = this._sortGlobalHistAttr = null;
+
 		this.counters = null;
 		this.activeIndices = null;
 		this.activeIndicesRO = null;

package/src/Processor/SceneProcessor.js

@@ -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 ] );
 
 			};

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

package/src/Stages/NormalDepth.js

@@ -12,7 +12,8 @@ import { computeUVCache, processNormal, processBump, buildBucketTextureNodes, re
 /**
  * NormalDepth — primary-ray G-buffer for SVGF gates.
  *
- * RGB = geometric world normal · 0.5 + 0.5, A = linear ray distance (sky=1e6).
+ * RGB = geometric world normal · 0.5 + 0.5, A = linear ray distance (sky=65504, the
+ * max HalfFloat value — a finite sentinel so miss−miss depth diffs stay 0, not Inf−Inf=NaN).
  * Geometric (not shading) normals because shading normals carry sub-pixel
  * jitter that breaks the temporal gate's same-pixel-across-frames comparison.
  * The path tracer's MRT already carries shading normals for OIDN; this stage
@@ -237,7 +238,7 @@ export class NormalDepth extends RenderStage {
 
 				const result = hit.didHit.select(
 					vec4( encodedNormal, depth ),
-					vec4( 0.0, 0.0, 0.0, float( 1e6 ) )
+					vec4( 0.0, 0.0, 0.0, float( 65504.0 ) )
 				);
 
 				textureStore(
@@ -262,7 +263,7 @@ export class NormalDepth extends RenderStage {
 
 				const shadingResult = hit.didHit.select(
 					vec4( shadingNormal.mul( 0.5 ).add( 0.5 ), depth ),
-					vec4( 0.0, 0.0, 0.0, float( 1e6 ) )
+					vec4( 0.0, 0.0, 0.0, float( 65504.0 ) )
 				);
 
 				textureStore(

package/src/Stages/PathTracer.js

@@ -7,7 +7,7 @@
 import { uniform, texture, storage } from 'three/tsl';
 import { StorageInstancedBufferAttribute } from 'three/webgpu';
 import { PathTracerStage } from './PathTracerStage.js';
-import { PackedRayBuffer, GBUFFER_STRIDE } from '../Processor/PackedRayBuffer.js';
+import { PackedRayBuffer, GBUFFER_STRIDE, freeStorageAttribute } from '../Processor/PackedRayBuffer.js';
 import { QueueManager, COUNTER } from '../Processor/QueueManager.js';
 import { VRAMTracker } from '../Processor/VRAMTracker.js';
 import { KernelManager } from '../Processor/KernelManager.js';
@@ -524,7 +524,7 @@ export class PathTracer extends PathTracerStage {
 
 		if ( ! this._packedBuffers ) {
 
-			this._packedBuffers = new PackedRayBuffer( maxRays );
+			this._packedBuffers = new PackedRayBuffer( maxRays, this.renderer );
 
 		} else {
 
@@ -538,13 +538,14 @@ export class PathTracer extends PathTracerStage {
 		// per-pixel, written by Generate/Shade bounce-0 and read only by FinalWrite.
 		// 1.25× margin (same as the per-ray buffers) so it survives the in-place-resize range.
 		const gBufferVec4s = PackedRayBuffer.requiredCapacity( maxRays ) * GBUFFER_STRIDE;
+		freeStorageAttribute( this.renderer, this._gBufferAttr ); // free the outgoing G-buffer on capacity growth
 		this._gBufferAttr = new StorageInstancedBufferAttribute( new Uint32Array( gBufferVec4s * 4 ), 4 );
 		const gBufferRW = storage( this._gBufferAttr, 'uvec4' );
 		const gBufferRO = storage( this._gBufferAttr, 'uvec4' ).toReadOnly();
 
 		if ( ! this._queueManager ) {
 
-			this._queueManager = new QueueManager( this._packedBuffers.capacity );
+			this._queueManager = new QueueManager( this._packedBuffers.capacity, this.renderer );
 
 		} else {
 

package/src/TSL/GenerateKernel.js

@@ -58,7 +58,11 @@ export function buildGenerateKernel( params ) {
 			const baseSeed = getDecorrelatedSeed( { pixelCoord, rayIndex: int( 0 ), frame } ).toVar();
 			const seed = pcgHash( { state: baseSeed } ).toVar();
 
-			const stratifiedJitter = getStratifiedSample( pixelCoord, int( 0 ), int( 1 ), seed, resolution, frame ).toVar();
+			// Sample index 1 (not 0) so the AA sub-pixel jitter draws a DIFFERENT STBN cell
+			// than the first-bounce BSDF sample (ShadeKernel uses sampleIndex 0). Every bounce
+			// samples at index 0, so index 1 is collision-free — this decorrelates the sub-pixel
+			// position from the first scatter direction (they were reading the identical cell).
+			const stratifiedJitter = getStratifiedSample( pixelCoord, int( 1 ), int( 1 ), seed, resolution, frame ).toVar();
 
 			const jitterScale = vec2( 2.0 ).div( resolution );
 			const jitter = stratifiedJitter.sub( 0.5 ).mul( jitterScale );

package/src/TSL/LightsIndirect.js

@@ -290,6 +290,9 @@ export const calculateIndirectLighting = Fn( ( [
 		const sampleDir = vec3( 0.0 ).toVar();
 		const samplePdf = float( 0.0 ).toVar();
 		const sampleBrdfValue = vec3( 0.0 ).toVar();
+		// Transmission lobe uses this weight instead of a reflection-BRDF eval, which is
+		// invalid for the below-surface refraction direction.
+		const transColorWeight = vec3( 1.0 ).toVar();
 
 		// Execute selected strategy (chained If/ElseIf/Else for exclusive branches)
 		// Environment removed — handled via deterministic NEE in direct lighting
@@ -312,13 +315,16 @@ export const calculateIndirectLighting = Fn( ( [
 
 			// Strategy 3: Transmission
 			const entering = dot( V, N ).greaterThan( 0.0 );
-			// pathWavelength=0 — MIS evaluation reads only direction/PDF, no spectral tint
 			const mtResult = MicrofacetTransmissionResult.wrap( sampleMicrofacetTransmission(
 				V, N, material.ior, material.roughness, entering, material.dispersion, sampleRand, rngState, float( 0.0 )
 			).toVar() );
 			sampleDir.assign( mtResult.direction );
 			samplePdf.assign( mtResult.pdf );
-			sampleBrdfValue.assign( evaluateMaterialResponse( V, sampleDir, N, material ) );
+			// evaluateMaterialResponse is reflection-only and returns a non-physical value for
+			// the below-surface refraction direction (its dots are floored to 0.001). Carry the
+			// sampler's spectral tint and apply an energy-consistent transmission throughput
+			// below (mirrors handleTransmission's material.color × colorWeight convention).
+			transColorWeight.assign( mtResult.colorWeight );
 
 		} ).Else( () => {
 
@@ -329,10 +335,7 @@ export const calculateIndirectLighting = Fn( ( [
 
 		} );
 
-		// For transmission directions (below surface), use |cos| instead of max(cos, 0)
-		const rawNoL = dot( N, sampleDir ).toVar();
-		const NoL = max( rawNoL, 0.0 ).toVar();
-		const absNoL = abs( rawNoL );
+		const NoL = max( dot( N, sampleDir ), 0.0 ).toVar();
 
 		// Calculate combined PDF for MIS (material strategies only)
 		const combinedPdf = float( 0.0 ).toVar();
@@ -380,11 +383,14 @@ export const calculateIndirectLighting = Fn( ( [
 		// MIS weight calculation
 		const misWeight = samplePdf.div( combinedPdf ).toVar();
 
-		// Throughput calculation: use |cos| for transmission, max(cos,0) for reflection strategies
-		const cosineWeight = select( selectedStrategy.equal( int( 3 ) ), absNoL, NoL );
+		// Reflection lobes: f·NoL·mis/pdf. Transmission lobe: the sampler's energy-consistent
+		// weight (material tint × dispersion colorWeight × mis) — the reflection BRDF value is
+		// invalid below the surface, so it is not used for transmission.
+		const reflThroughput = sampleBrdfValue.mul( NoL ).mul( misWeight ).div( samplePdf );
+		const transThroughput = material.color.xyz.mul( transColorWeight ).mul( misWeight );
 
 		r_direction.assign( sampleDir );
-		r_throughput.assign( sampleBrdfValue.mul( cosineWeight ).mul( misWeight ).div( samplePdf ) );
+		r_throughput.assign( select( selectedStrategy.equal( int( 3 ) ), transThroughput, reflThroughput ) );
 		r_misWeight.assign( misWeight );
 		r_pdf.assign( samplePdf );
 		r_combinedPdf.assign( combinedPdf );