rayzee 5.4.1 → 5.4.3

package/package.json

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

package/src/PathTracerApp.js

@@ -1,4 +1,5 @@
 import { WebGPURenderer, RectAreaLightNode } from 'three/webgpu';
+import { texture as _tslTexture, cubeTexture as _tslCubeTexture } from 'three/tsl';
 import {
 	ACESFilmicToneMapping, Scene, EventDispatcher, TimestampQuery
 } from 'three';
@@ -400,22 +401,100 @@ export class PathTracerApp extends EventDispatcher {
 
 		this.stopAnimation();
 		clearTimeout( this._resizeDebounceTimer );
+		this._resizeDebounceTimer = null;
 
-		// Remove all tracked listeners (app-owned subscriptions across managers/DOM)
 		this._removeTrackedListeners();
-
 		setStatusCallback( null );
 
+		this.interactionManager?.deselect?.();
+		this.transformManager?.detach?.();
+
 		this.animationManager?.dispose();
 		this.transformManager?.dispose();
 		this.overlayManager?.dispose();
-		this._sceneHelpers?.clear();
 		this.lightManager?.dispose();
 		this.denoisingManager?.dispose();
-		this.pipeline?.dispose();
 		this.interactionManager?.dispose();
 		this.cameraManager?.dispose();
+
+		this.pipeline?.dispose();
+
+		// _sdf + assetLoader own the heaviest GPU allocations (material texture arrays,
+		// BVH/triangle buffers, loaded GLTF resources, BVH refit worker, loader caches).
+		// They are not referenced by the pipeline, so pipeline.dispose() does not reach them.
+		this._sdf?.dispose();
+		this._sdf = null;
+
+		this.assetLoader?.dispose();
+		this.assetLoader = null;
+
+		if ( this.meshScene ) {
+
+			this.meshScene.environment?.dispose();
+			this.meshScene.environment = null;
+
+			for ( const child of [ ...this.meshScene.children ] ) {
+
+				disposeObjectFromMemory( child );
+
+			}
+
+			this.meshScene.clear();
+			this.meshScene = null;
+
+		}
+
+		this._sceneHelpers?.clear();
+		this._sceneHelpers = null;
+
+		this.scene?.clear();
+		this.scene = null;
+
+		// Three.js 0.184 leaks (confirmed via heap-snapshot retainer analysis):
+		//
+		//   1) Renderer.dispose() does not remove the 'resize' listener it installs on
+		//      _canvasTarget. The bound handler closes over the renderer, pinning the
+		//      entire WebGPU graph (Backend, Nodes, Bindings, Pipelines, GPUDevice,
+		//      every TSL node) alive indefinitely.
+		//      See three/src/renderers/common/Renderer.js:292 (attach) and
+		//      :2503 (dispose — missing removal).
+		//
+		//   2) Textures manager (one per renderer) registers a per-texture 'dispose'
+		//      listener that closes over `this = Textures` — which transitively
+		//      captures backend → renderer. These listeners are removed only when
+		//      the texture itself is destroyed. For module-level singletons like
+		//      EmptyTexture (new Texture in TextureNode.js) and its CubeTexture
+		//      counterpart, the texture is never destroyed, so every renderer ever
+		//      created leaks through the singleton's listener array.
+		//
+		// Both workarounds are safe when only a single PathTracerApp is active at a
+		// time. If you run multiple in parallel, reset listeners only on the renderer
+		// being disposed (not the shared singletons).
+		if ( this.renderer?._canvasTarget && this.renderer._onCanvasTargetResize ) {
+
+			this.renderer._canvasTarget.removeEventListener(
+				'resize',
+				this.renderer._onCanvasTargetResize
+			);
+
+		}
+
+		try {
+
+			const emptyTex = _tslTexture().value;
+			const emptyCube = _tslCubeTexture().value;
+			if ( emptyTex?._listeners?.dispose ) emptyTex._listeners.dispose.length = 0;
+			if ( emptyCube?._listeners?.dispose ) emptyCube._listeners.dispose.length = 0;
+
+		} catch ( err ) {
+
+			console.warn( 'PathTracerApp: failed to clear TSL texture singleton listeners', err );
+
+		}
+
 		this.renderer?.dispose();
+		if ( this.renderer ) this.renderer._canvasTarget = null;
+		this.renderer = null;
 
 		if ( this._stats ) {
 
@@ -424,6 +503,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
+		this.stages = {};
 		this.isInitialized = false;
 
 	}
@@ -460,13 +540,9 @@ export class PathTracerApp extends EventDispatcher {
 		this.interactionManager?.deselect();
 		this.transformManager?.detach?.();
 
-		// Dispose the loaded model (geometries, materials, textures)
-		if ( this.assetLoader?.targetModel ) {
-
-			disposeObjectFromMemory( this.assetLoader.targetModel );
-			this.assetLoader.targetModel = null;
-
-		}
+		// Release the loaded model. If loaded via loadObject3D(), the caller owns it —
+		// we only detach it from the scene. Otherwise dispose geometries/materials/textures.
+		this.assetLoader?.releaseTargetModel();
 
 		// Clear lights in the WebGPU light scene
 		this.lightManager?.clearLights?.();
@@ -1111,8 +1187,6 @@ export class PathTracerApp extends EventDispatcher {
 			}
 		} );
 
-		window.renderer = this.renderer; // For debugging
-
 		await this.renderer.init();
 
 		RectAreaLightNode.setLTC( RectAreaLightTexturesLib.init() );

package/src/Processor/AssetLoader.js

@@ -37,6 +37,7 @@ export class AssetLoader extends EventDispatcher {
 		this.camera = camera;
 		this.controls = controls;
 		this.targetModel = null;
+		this._externalModel = null;
 		this.floorPlane = null;
 		this.sceneScale = 1.0;
 		this.loaderCache = {};
@@ -46,6 +47,31 @@ export class AssetLoader extends EventDispatcher {
 
 	}
 
+	/**
+	 * Releases the current targetModel. If it was supplied by the caller via
+	 * loadObject3D(), we only detach it from its parent — the caller still owns
+	 * that Object3D and may reuse it. Otherwise we disposeObjectFromMemory() to
+	 * free geometry/material/texture GPU resources.
+	 */
+	releaseTargetModel() {
+
+		if ( ! this.targetModel ) return;
+
+		if ( this.targetModel === this._externalModel ) {
+
+			this.targetModel.parent?.remove( this.targetModel );
+
+		} else {
+
+			disposeObjectFromMemory( this.targetModel );
+
+		}
+
+		this.targetModel = null;
+		this._externalModel = null;
+
+	}
+
 	setRenderer( renderer ) {
 
 		this.renderer = renderer;
@@ -173,7 +199,11 @@ export class AssetLoader extends EventDispatcher {
 
 			} else {
 
-				const extension = envUrl.split( '.' ).pop().toLowerCase();
+				// Strip query string + fragment before extracting extension, otherwise
+				// URLs like ".../foo.hdr?v=2" get mis-detected and fall through to the
+				// regular TextureLoader, which can't parse HDR/EXR binary data.
+				const cleanPath = envUrl.split( /[?#]/ )[ 0 ];
+				const extension = cleanPath.split( '.' ).pop().toLowerCase();
 				texture = await this.loadEnvironmentByExtension( envUrl, extension );
 
 			}
@@ -479,7 +509,7 @@ export class AssetLoader extends EventDispatcher {
 					loader.parse( gltfContent, '',
 						gltf => {
 
-							if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+							this.releaseTargetModel();
 							this.targetModel = gltf.scene;
 							this.onModelLoad( this.targetModel ).then( () => resolve( gltf ) );
 
@@ -522,7 +552,7 @@ export class AssetLoader extends EventDispatcher {
 		const object = objLoader.parse( objContent );
 		object.name = filePath;
 
-		if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+		this.releaseTargetModel();
 		this.targetModel = object;
 		await this.onModelLoad( this.targetModel );
 		return object;
@@ -603,7 +633,7 @@ export class AssetLoader extends EventDispatcher {
 		const objContent = strFromU8( objFile.content );
 		const object = objLoader.parse( objContent );
 
-		if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+		this.releaseTargetModel();
 		this.targetModel = object;
 		await this.onModelLoad( this.targetModel );
 
@@ -773,7 +803,7 @@ export class AssetLoader extends EventDispatcher {
 			const data = await loader.loadAsync( modelUrl );
 			updateLoading( { status: "Processing Data...", progress: 10 } );
 
-			if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+			this.releaseTargetModel();
 
 			this.targetModel = data.scene;
 			this.animations = data.animations || [];
@@ -806,7 +836,7 @@ export class AssetLoader extends EventDispatcher {
 
 			const data = await loader.parseAsync( arrayBuffer, '' );
 
-			if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+			this.releaseTargetModel();
 
 			this.targetModel = data.scene;
 			this.animations = data.animations || [];
@@ -845,7 +875,7 @@ export class AssetLoader extends EventDispatcher {
 			}
 
 			const object = this.loaderCache.fbx.parse( arrayBuffer );
-			if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+			this.releaseTargetModel();
 			this.targetModel = object;
 
 			updateLoading( { isLoading: true, status: "Processing Data...", progress: 10 } );
@@ -882,7 +912,7 @@ export class AssetLoader extends EventDispatcher {
 			const object = this.loaderCache.obj.parse( contents );
 			object.name = filename;
 
-			if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+			this.releaseTargetModel();
 			this.targetModel = object;
 
 			updateLoading( { isLoading: true, status: "Processing Data...", progress: 10 } );
@@ -920,7 +950,7 @@ export class AssetLoader extends EventDispatcher {
 			const mesh = new Mesh( geometry, material );
 			mesh.name = filename;
 
-			if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+			this.releaseTargetModel();
 			this.targetModel = mesh;
 
 			updateLoading( { isLoading: true, status: "Processing Data...", progress: 10 } );
@@ -970,7 +1000,7 @@ export class AssetLoader extends EventDispatcher {
 			}
 
 			object.name = filename;
-			if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+			this.releaseTargetModel();
 			this.targetModel = object;
 
 			updateLoading( { isLoading: true, status: "Processing Data...", progress: 10 } );
@@ -1007,7 +1037,7 @@ export class AssetLoader extends EventDispatcher {
 			const collada = this.loaderCache.collada.parse( contents );
 			collada.scene.name = filename;
 
-			if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+			this.releaseTargetModel();
 			this.targetModel = collada.scene;
 
 			updateLoading( { isLoading: true, status: "Processing Data...", progress: 10 } );
@@ -1042,7 +1072,7 @@ export class AssetLoader extends EventDispatcher {
 
 			const object = this.loaderCache.threemf.parse( arrayBuffer );
 
-			if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+			this.releaseTargetModel();
 			this.targetModel = object;
 
 			updateLoading( { isLoading: true, status: "Processing Data...", progress: 10 } );
@@ -1078,7 +1108,7 @@ export class AssetLoader extends EventDispatcher {
 			const object = this.loaderCache.usdz.parse( arrayBuffer );
 			object.name = filename;
 
-			if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+			this.releaseTargetModel();
 			this.targetModel = object;
 
 			updateLoading( { isLoading: true, status: "Processing Data...", progress: 10 } );
@@ -1101,8 +1131,9 @@ export class AssetLoader extends EventDispatcher {
 
 		object3d.name = object3d.name || name;
 
-		if ( this.targetModel ) disposeObjectFromMemory( this.targetModel );
+		this.releaseTargetModel();
 		this.targetModel = object3d;
+		this._externalModel = object3d;
 
 		updateLoading( { isLoading: true, status: "Processing Data...", progress: 10 } );
 		await this.onModelLoad( this.targetModel );
@@ -1379,23 +1410,18 @@ export class AssetLoader extends EventDispatcher {
 		}
 
 		this.loaderCache = {};
-		super.dispose(); // Use EventDispatcher's dispose method
-
-		if ( this.targetModel ) {
 
-			disposeObjectFromMemory( this.targetModel );
-			this.targetModel = null;
-
-		}
+		// Three.js EventDispatcher exposes no dispose()/removeAllEventListeners().
+		// Clear the internal listener map directly so handlers don't retain references.
+		this._listeners = undefined;
 
-		console.log( 'AssetLoader resources disposed' );
+		this.releaseTargetModel();
 
 	}
 
 	removeAllEventListeners() {
 
-		// Use EventDispatcher's dispose method for backward compatibility
-		super.dispose();
+		this._listeners = undefined;
 
 	}
 

package/src/Processor/GeometryExtractor.js

@@ -618,7 +618,22 @@ export class GeometryExtractor {
 		this.triangleData[ offset + TRIANGLE_DATA_LAYOUT.NORMAL_A_OFFSET + 0 ] = normalA.x;
 		this.triangleData[ offset + TRIANGLE_DATA_LAYOUT.NORMAL_A_OFFSET + 1 ] = normalA.y;
 		this.triangleData[ offset + TRIANGLE_DATA_LAYOUT.NORMAL_A_OFFSET + 2 ] = normalA.z;
-		this.triangleData[ offset + TRIANGLE_DATA_LAYOUT.NORMAL_A_OFFSET + 3 ] = 0; // vec4 padding
+		// Repurposed padding: opaque-blocker fast-path flag for shadow rays.
+		// 1.0 = surface fully blocks light (no alpha, transmission, or transparency) →
+		//       traceShadowRay can skip the 7-slot getShadowMaterial fetch.
+		// 0.0 = requires full material evaluation.
+		{
+
+			const mat = this.materials[ materialIndex ];
+			const isOpaqueBlocker = mat
+				&& ( mat.alphaMode | 0 ) === 0
+				&& ( mat.transparent | 0 ) === 0
+				&& ( mat.transmission || 0 ) === 0
+				&& ( mat.opacity ?? 1 ) >= 1
+				? 1.0 : 0.0;
+			this.triangleData[ offset + TRIANGLE_DATA_LAYOUT.NORMAL_A_OFFSET + 3 ] = isOpaqueBlocker;
+
+		}
 
 		this.triangleData[ offset + TRIANGLE_DATA_LAYOUT.NORMAL_B_OFFSET + 0 ] = normalB.x;
 		this.triangleData[ offset + TRIANGLE_DATA_LAYOUT.NORMAL_B_OFFSET + 1 ] = normalB.y;
@@ -628,7 +643,9 @@ export class GeometryExtractor {
 		this.triangleData[ offset + TRIANGLE_DATA_LAYOUT.NORMAL_C_OFFSET + 0 ] = normalC.x;
 		this.triangleData[ offset + TRIANGLE_DATA_LAYOUT.NORMAL_C_OFFSET + 1 ] = normalC.y;
 		this.triangleData[ offset + TRIANGLE_DATA_LAYOUT.NORMAL_C_OFFSET + 2 ] = normalC.z;
-		this.triangleData[ offset + TRIANGLE_DATA_LAYOUT.NORMAL_C_OFFSET + 3 ] = 0; // vec4 padding
+		// Repurposed padding: per-triangle side flag (0=front, 1=back, 2=double).
+		// Lets BVH traversal do side culling without a material-buffer read per hit.
+		this.triangleData[ offset + TRIANGLE_DATA_LAYOUT.NORMAL_C_OFFSET + 3 ] = this.materials[ materialIndex ]?.side ?? 0;
 
 		// UVs and material index (2 vec4s = 8 floats)
 		// First vec4: uvA.x, uvA.y, uvB.x, uvB.y

package/src/Processor/createRenderTargetHelper.js

@@ -206,32 +206,33 @@ export function createRenderTargetHelper( renderer, renderTargetOrTexture, optio
 
 	} );
 
-	window.addEventListener( 'pointermove', ( e ) => {
+	function onPointerMove( e ) {
 
 		if ( ! isDragging ) return;
 
 		const newLeft = e.clientX - dragOffsetX;
 		const newTop = e.clientY - dragOffsetY;
 
-		// Keep within window bounds
 		const maxX = window.innerWidth - container.offsetWidth;
 		const maxY = window.innerHeight - container.offsetHeight;
 
 		container.style.left = `${Math.max( 0, Math.min( newLeft, maxX ) )}px`;
 		container.style.top = `${Math.max( 0, Math.min( newTop, maxY ) )}px`;
 
-		// Reset position properties that would otherwise take precedence
 		container.style.bottom = 'auto';
 		container.style.right = 'auto';
 
-	} );
+	}
 
-	window.addEventListener( 'pointerup', () => {
+	function onPointerUp() {
 
 		isDragging = false;
 		document.body.style.userSelect = '';
 
-	} );
+	}
+
+	window.addEventListener( 'pointermove', onPointerMove );
+	window.addEventListener( 'pointerup', onPointerUp );
 
 	// Optimize resize handling
 	function handleResize() {
@@ -353,19 +354,20 @@ export function createRenderTargetHelper( renderer, renderTargetOrTexture, optio
 
 	};
 
-	// Handle resize events
-	container.addEventListener( 'mousedown', () => {
+	function onContainerMouseDown() {
 
 		window.addEventListener( 'mousemove', handleResize );
 
-	} );
+	}
 
-	window.addEventListener( 'mouseup', () => {
+	function onMouseUp() {
 
 		window.removeEventListener( 'mousemove', handleResize );
 
-	} );
+	}
 
+	container.addEventListener( 'mousedown', onContainerMouseDown );
+	window.addEventListener( 'mouseup', onMouseUp );
 	window.addEventListener( 'resize', handleResize );
 
 	// Auto-update animation frame
@@ -456,20 +458,45 @@ export function createRenderTargetHelper( renderer, renderTargetOrTexture, optio
      */
 	container.dispose = function dispose() {
 
-		if ( config.autoUpdate && animFrameId ) {
+		if ( animFrameId ) {
 
 			cancelAnimationFrame( animFrameId );
+			animFrameId = null;
 
 		}
 
-		// Remove from DOM if attached
+		// Remove window listeners — these close over renderer/renderTarget/container
+		// and pin the entire helper graph alive until the page unloads if not cleaned up.
+		window.removeEventListener( 'pointermove', onPointerMove );
+		window.removeEventListener( 'pointerup', onPointerUp );
+		window.removeEventListener( 'mouseup', onMouseUp );
+		window.removeEventListener( 'mousemove', handleResize );
+		window.removeEventListener( 'resize', handleResize );
+
 		if ( container.parentNode ) {
 
 			container.parentNode.removeChild( container );
 
 		}
 
-		// Clear references
+		// Drop closures attached to the container. These close over `renderer`,
+		// `renderTargetOrTexture`, and the canvas — keeping them around after the
+		// owning stage has been disposed retains the entire Three.js WebGPU graph.
+		container.startAutoUpdate = null;
+		container.stopAutoUpdate = null;
+		container.show = null;
+		container.hide = null;
+		container.toggle = null;
+		container.update = null;
+		container.dispose = null;
+
+		if ( domCanvas ) {
+
+			domCanvas.width = 0;
+			domCanvas.height = 0;
+
+		}
+
 		clampedPixels = null;
 
 	};

package/src/Stages/AdaptiveSampling.js

@@ -485,6 +485,13 @@ export class AdaptiveSampling extends RenderStage {
 		this.heatmapTarget?.dispose();
 		this.helper?.dispose();
 
+		this._computeNode = null;
+		this._heatmapComputeNode = null;
+		this._heatmapStorageTex = null;
+		this._outputStorageTex = null;
+		this.heatmapTarget = null;
+		this.helper = null;
+
 	}
 
 }

package/src/Stages/PathTracer.js

@@ -114,6 +114,19 @@ export class PathTracer extends RenderStage {
 		// Initialize material data manager
 		this.materialData = new MaterialDataManager( this.sdfs );
 		this.materialData.callbacks.onReset = () => this.reset();
+		// Triangle data carries the per-triangle `side` flag (NORMAL_C.w). The
+		// authoritative CPU array is triangleStorageAttr.array (not sdfs.triangleData,
+		// which isn't populated on the PathTracerApp build path). The patch mutates
+		// the array in place — only a dirty flag is needed for GPU re-upload.
+		this.materialData.callbacks.getTriangleData = () => ( {
+			array: this.triangleStorageAttr?.array,
+			count: this.triangleCount,
+		} );
+		this.materialData.callbacks.onTriangleDataChanged = () => {
+
+			if ( this.triangleStorageAttr ) this.triangleStorageAttr.needsUpdate = true;
+
+		};
 
 		// Initialize environment manager
 		this.environment = new EnvironmentManager( this.scene, this.uniforms );

package/src/TSL/BVHTraversal.js

@@ -224,28 +224,34 @@ export const traverseBVH = Fn( ( [
 						const u = triResult.y;
 						const v = triResult.z;
 
-						// Fetch normals + material data for visibility check (4 reads)
+						// Fetch normals for side-culling (3 reads). Slot 7 (uvData2,
+						// carries matIdx + meshIndex) is deferred to post-traversal —
+						// it's only needed for the one winning triangle, not per candidate.
+						// normalCData.w carries the per-triangle side flag (0/1/2).
 						const nA = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 3 ), int( TRI_STRIDE ) ).xyz;
 						const nB = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 4 ), int( TRI_STRIDE ) ).xyz;
-						const nC = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 5 ), int( TRI_STRIDE ) ).xyz;
-						const uvData2 = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 7 ), int( TRI_STRIDE ) );
-
-						const matIdx = int( uvData2.z );
+						const normalCData = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 5 ), int( TRI_STRIDE ) );
+						const nC = normalCData.xyz;
+						const side = int( normalCData.w ).toVar();
 
 						// Interpolate normal
 						const w = float( 1.0 ).sub( u ).sub( v );
 						const normal = normalize( nA.mul( w ).add( nB.mul( u ) ).add( nC.mul( v ) ) ).toVar();
 
-						// Side culling check (per-mesh visibility handled at BLAS-pointer level)
-						If( passesSideCulling( matIdx, rayDirection, normal, materialBuffer ), () => {
+						// Side culling (inline; per-mesh visibility is at the BLAS-pointer level).
+						// 0=front (reject back-facing), 1=back (reject front-facing), 2=double (pass).
+						const rayDotNormal = rayDirection.dot( normal );
+						const sidePass = side.equal( int( 2 ) )
+							.or( side.equal( int( 0 ) ).and( rayDotNormal.lessThan( - 0.0001 ) ) )
+							.or( side.equal( int( 1 ) ).and( rayDotNormal.greaterThan( 0.0001 ) ) );
+						If( sidePass, () => {
 
 							closestHit.didHit.assign( true );
 							closestHit.dst.assign( t );
 							closestHit.normal.assign( normal );
-							closestHit.materialIndex.assign( matIdx );
-							closestHit.meshIndex.assign( int( uvData2.w ) );
 
-							// Defer hitPoint + UV computation to post-traversal
+							// Defer materialIndex/meshIndex/hitPoint/UV to post-traversal
+							// (all re-derived from closestTriIdx with a single uvData2 fetch below).
 							closestTriIdx.assign( triIndex );
 							closestU.assign( u );
 							closestV.assign( v );
@@ -324,7 +330,7 @@ export const traverseBVH = Fn( ( [
 
 	} );
 
-	// Deferred: compute hitPoint and UVs once for the final closest hit
+	// Deferred: compute hitPoint, UVs, and fetch matIdx/meshIndex once for the final closest hit
 	If( closestHit.didHit, () => {
 
 		closestHit.hitPoint.assign( ray.origin.add( ray.direction.mul( closestHit.dst ) ) );
@@ -335,6 +341,8 @@ export const traverseBVH = Fn( ( [
 		closestHit.uv.assign(
 			uvData1.xy.mul( w ).add( uvData1.zw.mul( closestU ) ).add( uvData2.xy.mul( closestV ) )
 		);
+		closestHit.materialIndex.assign( int( uvData2.z ) );
+		closestHit.meshIndex.assign( int( uvData2.w ) );
 		closestHit.triangleIndex.assign( closestTriIdx );
 
 	} );

package/src/TSL/LightsDirect.js

@@ -130,6 +130,19 @@ export const traceShadowRay = Fn( ( [
 
 		} );
 
+		// Opaque fast-path: check the per-triangle blocker flag (NORMAL_A.w, set at
+		// extraction time when alphaMode/transparent/transmission/opacity all indicate
+		// a fully opaque surface). Short-circuits the 7-slot getShadowMaterial fetch
+		// and the entire alpha/transmission/transparent decision tree below.
+		const TRI_STRIDE_SR = int( 8 );
+		const blocker = getDatafromStorageBuffer( triangleBuffer, shadowHit.triangleIndex, int( 3 ), TRI_STRIDE_SR ).w;
+		If( blocker.greaterThan( 0.5 ), () => {
+
+			transmittance.assign( 0.0 );
+			Break();
+
+		} );
+
 		// Fetch material for the hit surface (thin reader: 7 slots instead of 27)
 		const shadowMaterial = ShadowMaterial.wrap( getShadowMaterial( shadowHit.materialIndex, materialBuffer ) );
 

package/src/TSL/TextureSampling.js

@@ -281,7 +281,7 @@ export const processBump = Fn( ( [ bumpMaps, currentNormal, material, uvCache ]
 
 	const result = currentNormal.toVar();
 
-	If( material.bumpMapIndex.greaterThanEqual( int( 0 ) ), () => {
+	If( material.bumpMapIndex.greaterThanEqual( int( 0 ) ).and( material.bumpScale.greaterThan( 0.0 ) ), () => {
 
 		// Approximate texel size
 		const texelSize = vec2( 1.0 / 1024.0 ).toVar();