rayzee 5.0.1 → 5.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "5.0.1",
+  "version": "5.1.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",
@@ -34,7 +34,7 @@
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "three": ">=0.170.0"
+    "three": ">=0.183.2"
   },
   "dependencies": {
     "stats-gl": "^4.0.2"

package/src/PathTracerApp.js

@@ -533,6 +533,11 @@ export class PathTracerApp extends EventDispatcher {
 
 		if ( ! this._sdf.uploadToPathTracer( this.stages.pathTracer, this.lightManager, this.meshScene, environmentTexture ) ) return false;
 
+		// Build per-mesh visibility buffer (must happen before setupMaterial so the
+		// shader graph captures the storage node during compilation)
+		this.stages.pathTracer._meshRefs = this.stages.pathTracer._collectMeshRefs( this.meshScene );
+		this.stages.pathTracer.setMeshVisibilityData( this.stages.pathTracer._meshRefs );
+
 		timer.end( 'GPU data transfer' );
 
 		// Compile shaders
@@ -877,7 +882,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		this.stages.pathTracer?.materialData.updateMaterialProperty( materialIndex, property, value );
 
-		const emissiveAffectingProps = [ 'emissive', 'emissiveIntensity', 'visible' ];
+		const emissiveAffectingProps = [ 'emissive', 'emissiveIntensity' ];
 		if ( emissiveAffectingProps.includes( property )
 			&& this.stages.pathTracer?.enableEmissiveTriangleSampling?.value ) {
 
@@ -896,6 +901,30 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	/**
+	 * Update per-mesh visibility without rebuilding the scene.
+	 * Walks the parent chain to resolve world-space visibility.
+	 * @param {number} meshIndex
+	 * @param {boolean} visible
+	 */
+	setMeshVisibility( meshIndex, visible ) {
+
+		this.stages.pathTracer?.updateMeshVisibility( meshIndex, visible );
+		this.reset();
+
+	}
+
+	/**
+	 * Recompute world-visibility for all meshes.
+	 * Call after changing visibility on groups or parent objects.
+	 */
+	updateAllMeshVisibility() {
+
+		this.stages.pathTracer?.updateAllMeshVisibility();
+		this.reset();
+
+	}
+
 	/**
 	 * Updates a material's texture transform (offset, repeat, rotation).
 	 * @param {number} materialIndex

package/src/Processor/EmissiveTriangleBuilder.js

@@ -50,12 +50,11 @@ export class EmissiveTriangleBuilder {
 			const material = materials[ materialIndex ];
 			if ( ! material ) continue;
 
-			// Check if emissive and visible
+			// Check if emissive
 			const emissive = material.emissive || { r: 0, g: 0, b: 0 };
 			const emissiveIntensity = material.emissiveIntensity || 0;
-			const isVisible = material.visible === undefined || material.visible !== 0;
 
-			const isEmissive = isVisible && emissiveIntensity > 0 && (
+			const isEmissive = emissiveIntensity > 0 && (
 				emissive.r > 0 || emissive.g > 0 || emissive.b > 0
 			);
 
@@ -410,8 +409,7 @@ export class EmissiveTriangleBuilder {
 
 		const emissive = material.emissive || { r: 0, g: 0, b: 0 };
 		const emissiveIntensity = material.emissiveIntensity || 0;
-		const isVisible = material.visible === undefined || material.visible !== 0;
-		const isNowEmissive = isVisible && emissiveIntensity > 0 && ( emissive.r > 0 || emissive.g > 0 || emissive.b > 0 );
+		const isNowEmissive = emissiveIntensity > 0 && ( emissive.r > 0 || emissive.g > 0 || emissive.b > 0 );
 
 		// Check if this material had any emissive triangles before
 		const hadEmissive = this.emissiveTriangles.some( t => t.materialIndex === materialIndex );

package/src/Processor/GeometryExtractor.js

@@ -114,7 +114,7 @@ export class GeometryExtractor {
 		}
 
 		// Process material and get its index
-		const materialIndex = this.processMaterial( mesh.material, mesh );
+		const materialIndex = this.processMaterial( mesh.material );
 		mesh.userData.materialIndex = materialIndex;
 
 		// Assign mesh index and store mesh reference
@@ -133,7 +133,7 @@ export class GeometryExtractor {
 
 	}
 
-	processMaterial( material, mesh = null ) {
+	processMaterial( material ) {
 
 		// Check if material already exists in our array (O(1) Map lookup)
 		let materialIndex = this._materialUuidMap.get( material.uuid ) ?? - 1;
@@ -148,7 +148,7 @@ export class GeometryExtractor {
 			}
 
 			// Create a new material object and add it to the array
-			const newMaterial = this.createMaterialObject( material, mesh );
+			const newMaterial = this.createMaterialObject( material );
 			this.materials.push( newMaterial );
 			materialIndex = this.materials.length - 1;
 			this._materialUuidMap.set( material.uuid, materialIndex );
@@ -327,7 +327,7 @@ export class GeometryExtractor {
 
 	}
 
-	createMaterialObject( material, mesh = null ) {
+	createMaterialObject( material ) {
 
 		const defaults = this.getPhysicalDefaults();
 		const materialType = this.getMaterialType( material );
@@ -407,8 +407,6 @@ export class GeometryExtractor {
 			// Rendering properties
 			side: this.getMaterialSide( material ),
 			depthWrite: material.depthWrite ?? true ? 1 : 0,
-			// Use mesh visibility if available, otherwise fall back to material or default to true
-			visible: mesh ? ( mesh.visible ? 1 : 0 ) : ( material.visible ?? true ? 1 : 0 ),
 
 			// Texture processing
 			map: this.processTexture( material.map, this.maps ),
@@ -757,7 +755,7 @@ export class GeometryExtractor {
 
 		if ( object.isMesh && object.geometry && object.material ) {
 
-			const materialIndex = this.processMaterial( object.material, object );
+			const materialIndex = this.processMaterial( object.material );
 			object.userData.materialIndex = materialIndex;
 
 			const meshIndex = this.meshes.length;

package/src/Processor/SceneProcessor.js

@@ -1413,7 +1413,7 @@ export class SceneProcessor {
 	 * Returns null if no change, or the updated emissive data for GPU upload.
 	 *
 	 * @param {number} materialIndex
-	 * @param {string} property - 'emissive' | 'emissiveIntensity' | 'visible'
+	 * @param {string} property - 'emissive' | 'emissiveIntensity'
 	 * @param {*} value
 	 * @returns {{ rawData: Float32Array, emissiveCount: number, totalPower: number }|null}
 	 */
@@ -1426,7 +1426,6 @@ export class SceneProcessor {
 
 		if ( property === 'emissive' ) mat.emissive = value;
 		else if ( property === 'emissiveIntensity' ) mat.emissiveIntensity = value;
-		else if ( property === 'visible' ) mat.visible = value;
 
 		const changed = this.emissiveTriangleBuilder.updateMaterialEmissive(
 			materialIndex, mat,

package/src/Processor/ShaderBuilder.js

@@ -16,6 +16,7 @@ import { Fn, texture, vec2, float, int, uniform, If,
 import { TextureNode } from 'three/webgpu';
 import { LinearFilter, DataArrayTexture } from 'three';
 import { pathTracerMain } from '../TSL/PathTracer.js';
+import { setMeshVisibilityBuffer } from '../TSL/BVHTraversal.js';
 import { BuildTimer } from './BuildTimer.js';
 
 const WG_SIZE = 8;
@@ -188,6 +189,9 @@ export class ShaderBuilder {
 		const emissiveTriStorage = stage.emissiveTriangleStorageNode;
 		const lightBVHStorage = stage.lightBVHStorageNode;
 
+		// Set per-mesh visibility buffer (module-level in BVHTraversal.js, read during graph construction)
+		setMeshVisibilityBuffer( stage.meshVisibilityStorageNode );
+
 		const envTex = texture( stage.environment.environmentTexture );
 
 		// Adaptive sampling texture

package/src/Processor/TLASBuilder.js

@@ -268,7 +268,7 @@ export class TLASBuilder {
 				// Leaf node — BLAS pointer
 				const entry = entries[ n.entryIndex ];
 				data[ o ] = entry.blasOffset; // Absolute node index of BLAS root in combined buffer
-				// data[o+1] = 0
+				data[ o + 1 ] = n.entryIndex; // meshIndex for per-mesh visibility check
 				// data[o+2] = 0
 				data[ o + 3 ] = BVH_LEAF_MARKERS.BLAS_POINTER_LEAF; // -2 marker
 

package/src/Stages/PathTracer.js

@@ -188,6 +188,10 @@ export class PathTracer extends RenderStage {
 		this.lightBVHStorageAttr = new StorageInstancedBufferAttribute( new Float32Array( 16 ), 4 );
 		this.lightBVHStorageNode = storage( this.lightBVHStorageAttr, 'vec4', 1 ).toReadOnly();
 
+		// Per-mesh visibility (storage buffer for TLAS BLAS-pointer skip)
+		this.meshVisibilityStorageAttr = new StorageInstancedBufferAttribute( new Float32Array( [ 1, 0, 0, 0 ] ), 4 );
+		this.meshVisibilityStorageNode = storage( this.meshVisibilityStorageAttr, 'vec4', 1 ).toReadOnly();
+
 		// Adaptive sampling
 		this.adaptiveSamplingTexture = null;
 
@@ -480,6 +484,10 @@ export class PathTracer extends RenderStage {
 
 		}
 
+		// Per-mesh visibility — collect meshes from scene ordered by meshIndex
+		this._meshRefs = this._collectMeshRefs( this.scene );
+		this.setMeshVisibilityData( this._meshRefs );
+
 		// Spheres
 		this.spheres = this.sdfs.spheres || [];
 
@@ -759,6 +767,109 @@ export class PathTracer extends RenderStage {
 
 	}
 
+	/**
+	 * Build per-mesh visibility storage buffer from mesh world-visibility.
+	 * Each mesh gets one float (1.0 = visible, 0.0 = hidden).
+	 * Padded to vec4 alignment for GPU storage buffer compatibility.
+	 * @param {Array} meshes - Array of Three.js mesh objects
+	 */
+	setMeshVisibilityData( meshes ) {
+
+		if ( ! meshes || meshes.length === 0 ) return;
+
+		const meshCount = meshes.length;
+		// One vec4 per mesh — visibility stored in .x (simple indexing on GPU)
+		const data = new Float32Array( meshCount * 4 );
+
+		for ( let i = 0; i < meshCount; i ++ ) {
+
+			data[ i * 4 ] = this._isWorldVisible( meshes[ i ] ) ? 1.0 : 0.0;
+
+		}
+
+		this.meshVisibilityStorageAttr = new StorageInstancedBufferAttribute( data, 4 );
+		this.meshVisibilityStorageNode.value = this.meshVisibilityStorageAttr;
+		this.meshVisibilityStorageNode.bufferCount = meshCount;
+
+	}
+
+	/**
+	 * Update visibility for a single mesh in the GPU buffer (no rebuild).
+	 * @param {number} meshIndex
+	 * @param {boolean} visible
+	 */
+	updateMeshVisibility( meshIndex, visible ) {
+
+		if ( ! this.meshVisibilityStorageAttr ) return;
+
+		this.meshVisibilityStorageAttr.array[ meshIndex * 4 ] = visible ? 1.0 : 0.0;
+		this.meshVisibilityStorageAttr.needsUpdate = true;
+
+	}
+
+	/**
+	 * Recompute world-visibility for all meshes and update the GPU buffer.
+	 * Call this when group visibility changes at runtime.
+	 */
+	updateAllMeshVisibility() {
+
+		if ( ! this._meshRefs || ! this.meshVisibilityStorageAttr ) return;
+
+		const data = this.meshVisibilityStorageAttr.array;
+		for ( let i = 0; i < this._meshRefs.length; i ++ ) {
+
+			data[ i * 4 ] = this._isWorldVisible( this._meshRefs[ i ] ) ? 1.0 : 0.0;
+
+		}
+
+		this.meshVisibilityStorageAttr.needsUpdate = true;
+
+	}
+
+	/**
+	 * Collect mesh references from scene, ordered by meshIndex (assigned during extraction).
+	 * @param {Object3D} scene
+	 * @returns {Array}
+	 * @private
+	 */
+	_collectMeshRefs( scene ) {
+
+		if ( ! scene ) return [];
+
+		const meshes = [];
+		scene.traverse( obj => {
+
+			if ( obj.isMesh && obj.userData.meshIndex !== undefined ) {
+
+				meshes[ obj.userData.meshIndex ] = obj;
+
+			}
+
+		} );
+
+		return meshes;
+
+	}
+
+	/**
+	 * Walk the parent chain to determine world-space visibility.
+	 * @param {Object3D} object
+	 * @returns {boolean}
+	 * @private
+	 */
+	_isWorldVisible( object ) {
+
+		while ( object ) {
+
+			if ( ! object.visible ) return false;
+			object = object.parent;
+
+		}
+
+		return true;
+
+	}
+
 	// ===== FAST BUFFER UPDATES (BVH Refit / Animation) =====
 
 	/**

package/src/TSL/BVHTraversal.js

@@ -25,7 +25,6 @@ import {
 	array,
 } from 'three/tsl';
 
-import { struct } from './structProxy.js';
 import { Ray, HitInfo } from './Struct.js';
 import { getDatafromStorageBuffer, MATERIAL_SLOTS } from './Common.js';
 import { RandomPointInCircle } from './Random.js';
@@ -34,14 +33,6 @@ import { RandomPointInCircle } from './Random.js';
 // STRUCTS
 // ================================================================================
 
-// Combined visibility data structure
-export const VisibilityData = struct( {
-	visible: 'bool',
-	side: 'int',
-	transparent: 'bool',
-	opacity: 'float'
-} );
-
 // ================================================================================
 // CONSTANTS
 // ================================================================================
@@ -52,6 +43,20 @@ const BVH_STRIDE = 4;
 const TRI_STRIDE = 8;
 const HUGE_VAL = 1e8;
 
+// Per-mesh visibility buffer (set by ShaderBuilder before graph construction)
+let _meshVisibilityBuffer = null;
+
+/**
+ * Set the per-mesh visibility storage buffer node.
+ * Must be called before the shader graph is constructed (i.e., before setupCompute).
+ * @param {StorageNode} buffer - TSL storage node indexed by meshIndex
+ */
+export function setMeshVisibilityBuffer( buffer ) {
+
+	_meshVisibilityBuffer = buffer;
+
+}
+
 // ================================================================================
 // STACK HELPERS (Native WGSL array via TSL ArrayNode)
 // ================================================================================
@@ -127,48 +132,17 @@ const fastRayAABBDst = wgslFn( `
 // VISIBILITY FUNCTIONS
 // ================================================================================
 
-// Fetch all visibility data in 2 reads
-export const getVisibilityData = Fn( ( [ materialIndex, materialBuffer ] ) => {
+// Side culling — 1 buffer read (slot 10 only)
+// Per-mesh visibility handled at BLAS-pointer level; material visibility always 1.
+export const passesSideCulling = Fn( ( [ materialIndex, rayDirection, normal, materialBuffer ] ) => {
 
-	// Read visibility flag from slot 4
-	const visData = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 4 ), int( MATERIAL_SLOTS ) );
-	// Read side and transparency data from slot 10
 	const sideData = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 10 ), int( MATERIAL_SLOTS ) );
-
-	return VisibilityData( {
-		visible: visData.g.greaterThan( 0.5 ),
-		opacity: sideData.r,
-		side: int( sideData.g ),
-		transparent: sideData.b.greaterThan( 0.5 ),
-	} );
-
-} );
-
-// Fast visibility check using material texture
-export const isTriangleVisible = Fn( ( [ materialIndex, materialBuffer ] ) => {
-
-	const visData = getDatafromStorageBuffer( materialBuffer, materialIndex, int( 4 ), int( MATERIAL_SLOTS ) );
-	return visData.g.greaterThan( 0.5 );
-
-} );
-
-// Complete visibility check with side culling
-export const isMaterialVisibleOptimized = wgslFn( `
-	fn isMaterialVisibleOptimized( visible: bool, side: i32, rayDirection: vec3f, normal: vec3f ) -> bool {
-		if ( !visible ) { return false; }
-		let rayDotNormal = dot( rayDirection, normal );
-		let doubleSide = side == 2;
-		let frontSide  = side == 0 && rayDotNormal < -0.0001f;
-		let backSide   = side == 1 && rayDotNormal > 0.0001f;
-		return doubleSide || frontSide || backSide;
-	}
-` );
-
-// Single visibility check with combined data fetch
-export const isMaterialVisible = Fn( ( [ materialIndex, rayDirection, normal, materialBuffer ] ) => {
-
-	const vis = VisibilityData.wrap( getVisibilityData( materialIndex, materialBuffer ) );
-	return isMaterialVisibleOptimized( { visible: vis.visible, side: vis.side, rayDirection, normal } );
+	const side = int( sideData.g );
+	const rayDotNormal = rayDirection.dot( normal );
+	const doubleSide = side.equal( int( 2 ) );
+	const frontSide = side.equal( int( 0 ) ).and( rayDotNormal.lessThan( - 0.0001 ) );
+	const backSide = side.equal( int( 1 ) ).and( rayDotNormal.greaterThan( 0.0001 ) );
+	return doubleSide.or( frontSide ).or( backSide );
 
 } );
 
@@ -269,28 +243,23 @@ export const traverseBVH = Fn( ( [
 
 						const matIdx = int( uvData2.z );
 
-						// Early material rejection
-						If( isTriangleVisible( matIdx, materialBuffer ), () => {
+						// 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();
 
-							// 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 ), () => {
 
-							// Full material visibility check (culling etc)
-							If( isMaterialVisible( matIdx, rayDirection, normal, materialBuffer ), () => {
-
-								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
-								closestTriIdx.assign( triIndex );
-								closestU.assign( u );
-								closestV.assign( v );
+							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
+							closestTriIdx.assign( triIndex );
+							closestU.assign( u );
+							closestV.assign( v );
 
 						} );
 
@@ -308,13 +277,34 @@ export const traverseBVH = Fn( ( [
 			} ).Else( () => {
 
 				// BLAS-pointer leaf (marker -2) — push BLAS root node onto stack
+				// nodeData0: [blasRootNodeIndex, meshIndex, 0, -2]
 				const blasRoot = int( nodeData0.x ).toVar();
-				If( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ), () => {
 
-					stack.element( stackPtr ).assign( blasRoot );
-					stackPtr.addAssign( 1 );
+				if ( _meshVisibilityBuffer ) {
 
-				} );
+					// Per-mesh visibility check — skip entire BLAS if mesh is hidden
+					// getDatafromStorageBuffer( buffer, stride=1, sampleIndex=meshIdx, dataOffset=0 )
+					const meshIdx = int( nodeData0.y ).toVar();
+					const meshVis = getDatafromStorageBuffer( _meshVisibilityBuffer, int( 1 ), meshIdx, int( 0 ) ).x;
+
+					If( meshVis.greaterThan( 0.5 ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
+
+						stack.element( stackPtr ).assign( blasRoot );
+						stackPtr.addAssign( 1 );
+
+					} );
+
+				} else {
+
+					// No visibility buffer — push unconditionally (original behavior)
+					If( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ), () => {
+
+						stack.element( stackPtr ).assign( blasRoot );
+						stackPtr.addAssign( 1 );
+
+					} );
+
+				}
 
 			} );
 
@@ -390,7 +380,7 @@ export const traverseBVHShadow = Fn( ( [
 	ray,
 	bvhBuffer,
 	triangleBuffer,
-	materialBuffer,
+	_materialBuffer, // eslint-disable-line no-unused-vars -- kept for call-site compatibility
 	maxShadowDist,
 ] ) => {
 
@@ -448,25 +438,21 @@ export const traverseBVHShadow = Fn( ( [
 
 					If( triResult.w.greaterThan( 0.5 ), () => {
 
+						// Per-mesh visibility handled at BLAS-pointer level — accept any hit
 						const uvData2 = getDatafromStorageBuffer( triangleBuffer, triIndex, int( 7 ), int( TRI_STRIDE ) );
-						const matIdx = int( uvData2.z );
-
-						If( isTriangleVisible( matIdx, materialBuffer ), () => {
-
-							closestHit.didHit.assign( true );
-							closestHit.dst.assign( triResult.x );
-							closestHit.materialIndex.assign( matIdx );
-							closestHit.meshIndex.assign( int( uvData2.w ) );
 
-							// Compute hit point and geometric normal -- required for transmissive
-							// Fresnel in traceShadowRay (cosThetaI needs a real normal, not vec3(0))
-							closestHit.hitPoint.assign( ray.origin.add( ray.direction.mul( triResult.x ) ) );
-							closestHit.normal.assign( normalize( cross( pB.sub( pA ), pC.sub( pA ) ) ) );
+						closestHit.didHit.assign( true );
+						closestHit.dst.assign( triResult.x );
+						closestHit.materialIndex.assign( int( uvData2.z ) );
+						closestHit.meshIndex.assign( int( uvData2.w ) );
 
-							// Shadow ray only needs any hit — skip remaining triangles in leaf
-							Break();
+						// Compute hit point and geometric normal -- required for transmissive
+						// Fresnel in traceShadowRay (cosThetaI needs a real normal, not vec3(0))
+						closestHit.hitPoint.assign( ray.origin.add( ray.direction.mul( triResult.x ) ) );
+						closestHit.normal.assign( normalize( cross( pB.sub( pA ), pC.sub( pA ) ) ) );
 
-						} );
+						// Shadow ray only needs any hit — skip remaining triangles in leaf
+						Break();
 
 					} );
 
@@ -475,13 +461,34 @@ export const traverseBVHShadow = Fn( ( [
 			} ).Else( () => {
 
 				// BLAS-pointer leaf (marker -2) — push BLAS root node onto stack
+				// nodeData0: [blasRootNodeIndex, meshIndex, 0, -2]
 				const blasRoot = int( nodeData0.x ).toVar();
-				If( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ), () => {
 
-					stack.element( stackPtr ).assign( blasRoot );
-					stackPtr.addAssign( 1 );
+				if ( _meshVisibilityBuffer ) {
 
-				} );
+					// Per-mesh visibility check — skip entire BLAS if mesh is hidden
+					// getDatafromStorageBuffer( buffer, stride=1, sampleIndex=meshIdx, dataOffset=0 )
+					const meshIdx = int( nodeData0.y ).toVar();
+					const meshVis = getDatafromStorageBuffer( _meshVisibilityBuffer, int( 1 ), meshIdx, int( 0 ) ).x;
+
+					If( meshVis.greaterThan( 0.5 ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
+
+						stack.element( stackPtr ).assign( blasRoot );
+						stackPtr.addAssign( 1 );
+
+					} );
+
+				} else {
+
+					// No visibility buffer — push unconditionally (original behavior)
+					If( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ), () => {
+
+						stack.element( stackPtr ).assign( blasRoot );
+						stackPtr.addAssign( 1 );
+
+					} );
+
+				}
 
 			} );
 

package/src/TSL/Common.js

@@ -353,7 +353,6 @@ export const getMaterial = Fn( ( [ materialIndex, materialBuffer ] ) => {
 		attenuationColor: data3.rgb,
 		attenuationDistance: data3.a,
 		dispersion: data4.r,
-		visible: data4.g,
 		sheen: data4.b,
 		sheenRoughness: data4.a,
 		sheenColor: data5.rgb,

package/src/TSL/PathTracerCore.js

@@ -22,12 +22,9 @@ import {
 	vec3,
 	vec4,
 	int,
-	uint,
 	bool as tslBool,
 	max,
 	min,
-	abs,
-	sqrt,
 	exp,
 	clamp,
 	mix,
@@ -47,15 +44,12 @@ import {
 import { struct } from './structProxy.js';
 
 import {
-	PI,
 	PI_INV,
-	EPSILON,
 	MIN_ROUGHNESS,
 	MAX_ROUGHNESS,
 	MIN_CLEARCOAT_ROUGHNESS,
 	MIN_PDF,
 	maxComponent,
-	minComponent,
 	classifyMaterial,
 	constructTBN,
 	calculateFireflyThreshold,
@@ -66,8 +60,6 @@ import {
 import {
 	DirectionSample,
 	MaterialClassification,
-	PathState,
-	RenderState,
 	MaterialCache,
 	BRDFWeights,
 	Ray,
@@ -83,7 +75,6 @@ import { sampleAllMaterialTextures } from './TextureSampling.js';
 import { refineDisplacedIntersection, DisplacementResult } from './Displacement.js';
 import { handleMaterialTransparency, MaterialInteractionResult, sampleMicrofacetTransmission, MicrofacetTransmissionResult } from './MaterialTransmission.js';
 import {
-	DistributionGGX,
 	SheenDistribution,
 	calculateVNDFPDF,
 	calculateBRDFWeights,
@@ -115,7 +106,6 @@ const RAY_TYPE_CAMERA = 0;
 const RAY_TYPE_REFLECTION = 1;
 const RAY_TYPE_TRANSMISSION = 2;
 const RAY_TYPE_DIFFUSE = 3;
-const RAY_TYPE_SHADOW = 4;
 
 // Trace result struct
 export const TraceResult = struct( {

package/src/TSL/Random.js

@@ -24,7 +24,6 @@ const blueNoiseTextureSize = vec2( textureSize( blueNoiseTextureNode ) );
 
 // Golden ratio constants for dimension decorrelation
 
-const PHI = float( 1.61803398875 );
 const INV_PHI = float( 0.61803398875 );
 const INV_PHI2 = float( 0.38196601125 );
 

package/src/TSL/RayIntersection.js

@@ -1,10 +1,7 @@
 import { Fn, float, vec2, vec3, int, If, dot, cross, abs, normalize, sqrt, min, max, select } from 'three/tsl';
 
 import {
-	Ray,
 	HitInfo,
-	Triangle,
-	Sphere,
 } from './Struct.js';
 
 // Optimized Intersection with Geometry only (no attributes)