rayzee 5.4.0 → 5.4.2

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 );
@@ -180,17 +193,20 @@ export class PathTracer extends RenderStage {
 		// Blue noise
 		this.blueNoiseTexture = null;
 
-		// Emissive triangles (storage buffer) — initialized with dummy data so TSL compilation never sees null
-		this.emissiveTriangleStorageAttr = new StorageInstancedBufferAttribute( new Float32Array( 4 ), 4 );
-		this.emissiveTriangleStorageNode = storage( this.emissiveTriangleStorageAttr, 'vec4', 1 ).toReadOnly();
+		// Packed light buffer — [lightBVH nodes (4 vec4s each) | emissive triangles (2 vec4s each)]
+		// emissiveVec4Offset uniform tracks the vec4-count offset where emissive data starts.
+		// Initialized with dummy data so TSL compilation never sees null.
+		this.lightStorageAttr = new StorageInstancedBufferAttribute( new Float32Array( 16 ), 4 );
+		this.lightStorageNode = storage( this.lightStorageAttr, 'vec4', 1 ).toReadOnly();
 
-		// Light BVH storage buffer — initialized with dummy data
-		this.lightBVHStorageAttr = new StorageInstancedBufferAttribute( new Float32Array( 16 ), 4 );
-		this.lightBVHStorageNode = storage( this.lightBVHStorageAttr, 'vec4', 1 ).toReadOnly();
+		// Cached CPU-side data — rebuilt into the packed buffer whenever either source changes.
+		this._lbvhDataCache = null;
+		this._emissiveDataCache = null;
 
-		// 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();
+		// Per-mesh visibility is packed into the TLAS BLAS-pointer leaf's slot [2]
+		// (see TLASBuilder.flatten + BVHTraversal.js). The InstanceTable holds the
+		// tlasLeafIndex for each mesh so we can patch visibility in place.
+		this._instanceTable = null;
 
 		// Adaptive sampling
 		this.adaptiveSamplingTexture = null;
@@ -454,6 +470,7 @@ export class PathTracer extends RenderStage {
 		// Set data references
 		this.setTriangleData( this.sdfs.triangleData, this.sdfs.triangleCount );
 		this.setBVHData( this.sdfs.bvhData );
+		this.setInstanceTable( this.sdfs.instanceTable );
 		this.materialData.setMaterialData( this.sdfs.materialData );
 
 		// Update triangle count
@@ -768,61 +785,78 @@ 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
+	 * Bind the InstanceTable used to locate each mesh's TLAS leaf for in-place
+	 * visibility patching. Called by SceneProcessor during upload.
+	 * @param {import('../Processor/InstanceTable.js').InstanceTable} instanceTable
 	 */
-	setMeshVisibilityData( meshes ) {
+	setInstanceTable( instanceTable ) {
 
-		if ( ! meshes || meshes.length === 0 ) return;
+		this._instanceTable = instanceTable;
 
-		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 ++ ) {
+	/**
+	 * Initialize packed visibility for each mesh from current world-visibility.
+	 * Patches the TLAS leaf slots in the combined BVH buffer that was just uploaded.
+	 * @param {Array} meshes - Array of Three.js mesh objects, ordered by meshIndex
+	 */
+	setMeshVisibilityData( meshes ) {
 
-			data[ i * 4 ] = this._isWorldVisible( meshes[ i ] ) ? 1.0 : 0.0;
+		if ( ! meshes || meshes.length === 0 || ! this._instanceTable ) return;
+
+		for ( let i = 0; i < meshes.length; i ++ ) {
+
+			this._patchTLASLeafVisibility( i, this._isWorldVisible( meshes[ i ] ) );
 
 		}
 
-		this.meshVisibilityStorageAttr = new StorageInstancedBufferAttribute( data, 4 );
-		this.meshVisibilityStorageNode.value = this.meshVisibilityStorageAttr;
-		this.meshVisibilityStorageNode.bufferCount = meshCount;
+		if ( this.bvhStorageAttr ) this.bvhStorageAttr.needsUpdate = true;
 
 	}
 
 	/**
-	 * Update visibility for a single mesh in the GPU buffer (no rebuild).
+	 * Update visibility for a single mesh by patching its TLAS leaf slot [2].
 	 * @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;
+		if ( ! this._patchTLASLeafVisibility( meshIndex, visible ) ) return;
+		if ( this.bvhStorageAttr ) this.bvhStorageAttr.needsUpdate = true;
 
 	}
 
 	/**
-	 * Recompute world-visibility for all meshes and update the GPU buffer.
+	 * Recompute world-visibility for all meshes and patch TLAS leaves in place.
 	 * Call this when group visibility changes at runtime.
 	 */
 	updateAllMeshVisibility() {
 
-		if ( ! this._meshRefs || ! this.meshVisibilityStorageAttr ) return;
+		if ( ! this._meshRefs || ! this._instanceTable ) 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._patchTLASLeafVisibility( i, this._isWorldVisible( this._meshRefs[ i ] ) );
 
 		}
 
-		this.meshVisibilityStorageAttr.needsUpdate = true;
+		if ( this.bvhStorageAttr ) this.bvhStorageAttr.needsUpdate = true;
+
+	}
+
+	/**
+	 * Patch a single TLAS leaf's visibility flag in the combined BVH buffer.
+	 * Returns true if the patch was applied.
+	 * @private
+	 */
+	_patchTLASLeafVisibility( meshIndex, visible ) {
+
+		const entry = this._instanceTable?.entries?.[ meshIndex ];
+		if ( ! entry || entry.tlasLeafIndex < 0 || ! this.bvhStorageAttr ) return false;
+
+		entry.visible = visible;
+		this.bvhStorageAttr.array[ entry.tlasLeafIndex * 16 + 2 ] = visible ? 1.0 : 0.0;
+		return true;
 
 	}
 
@@ -1493,18 +1527,43 @@ export class PathTracer extends RenderStage {
 
 	}
 
-	setEmissiveTriangleData( emissiveData, count, totalPower = 0 ) {
+	/**
+	 * Rebuild the packed light buffer from cached lightBVH + emissive data.
+	 * Layout: [ lightBVH (LBVH_STRIDE vec4s per node) | emissive (EMISSIVE_STRIDE vec4s per entry) ].
+	 * Also updates `emissiveVec4Offset` uniform (in vec4 elements).
+	 * @private
+	 */
+	_rebuildLightBuffer() {
 
-		if ( ! emissiveData ) return;
+		const LBVH_STRIDE = 4; // vec4s per LBVH node — must match LightBVHSampling.js
+		const lbvh = this._lbvhDataCache;
+		const emis = this._emissiveDataCache;
+		const lbvhLen = lbvh ? lbvh.length : 0;
+		const emisLen = emis ? emis.length : 0;
+
+		// Ensure at least a minimal non-empty buffer so GPU allocation remains valid.
+		const totalLen = Math.max( lbvhLen + emisLen, 4 );
+		const combined = new Float32Array( totalLen );
+		if ( lbvh ) combined.set( lbvh, 0 );
+		if ( emis ) combined.set( emis, lbvhLen );
+
+		this.lightStorageAttr = new StorageInstancedBufferAttribute( combined, 4 );
+		this.lightStorageNode.value = this.lightStorageAttr;
+		this.lightStorageNode.bufferCount = combined.length / 4;
+
+		// Offset (in vec4 elements) where emissive data starts.
+		this.emissiveVec4Offset.value = ( this.lightBVHNodeCount.value || 0 ) * LBVH_STRIDE;
 
-		const vec4Count = emissiveData.length / 4;
+	}
+
+	setEmissiveTriangleData( emissiveData, count, totalPower = 0 ) {
 
-		this.emissiveTriangleStorageAttr = new StorageInstancedBufferAttribute( emissiveData, 4 );
-		this.emissiveTriangleStorageNode.value = this.emissiveTriangleStorageAttr;
-		this.emissiveTriangleStorageNode.bufferCount = vec4Count;
+		if ( ! emissiveData ) return;
 
+		this._emissiveDataCache = emissiveData;
 		this.emissiveTriangleCount.value = count;
 		this.emissiveTotalPower.value = totalPower;
+		this._rebuildLightBuffer();
 		console.log( `PathTracer: ${count} emissive triangles, totalPower=${totalPower.toFixed( 4 )} (storage buffer)` );
 
 	}
@@ -1513,11 +1572,9 @@ export class PathTracer extends RenderStage {
 
 		if ( ! nodeData ) return;
 
-		const vec4Count = nodeData.length / 4;
-		this.lightBVHStorageAttr = new StorageInstancedBufferAttribute( nodeData, 4 );
-		this.lightBVHStorageNode.value = this.lightBVHStorageAttr;
-		this.lightBVHStorageNode.bufferCount = vec4Count;
+		this._lbvhDataCache = nodeData;
 		this.lightBVHNodeCount.value = nodeCount;
+		this._rebuildLightBuffer();
 		console.log( `PathTracer: Light BVH ${nodeCount} nodes` );
 
 	}

package/src/TSL/BVHTraversal.js

@@ -43,19 +43,8 @@ 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;
-
-}
+// Per-mesh visibility is now packed into the TLAS BLAS-pointer leaf's slot [2]
+// by TLASBuilder.flatten() — eliminates the dedicated meshVisibility storage buffer.
 
 // ================================================================================
 // STACK HELPERS (Native WGSL array via TSL ArrayNode)
@@ -235,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 );
@@ -276,35 +271,17 @@ export const traverseBVH = Fn( ( [
 
 			} ).Else( () => {
 
-				// BLAS-pointer leaf (marker -2) — push BLAS root node onto stack
-				// nodeData0: [blasRootNodeIndex, meshIndex, 0, -2]
+				// BLAS-pointer leaf (marker -2) — push BLAS root onto stack if mesh is visible
+				// nodeData0: [blasRootNodeIndex, meshIndex, visibility, -2]
+				// Visibility is free-fetched with the leaf — no extra storage read.
 				const blasRoot = int( nodeData0.x ).toVar();
 
-				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 );
+				If( nodeData0.z.greaterThan( 0.5 ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
 
-					} );
-
-				} else {
-
-					// No visibility buffer — push unconditionally (original behavior)
-					If( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ), () => {
-
-						stack.element( stackPtr ).assign( blasRoot );
-						stackPtr.addAssign( 1 );
-
-					} );
+					stack.element( stackPtr ).assign( blasRoot );
+					stackPtr.addAssign( 1 );
 
-				}
+				} );
 
 			} );
 
@@ -353,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 ) ) );
@@ -364,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 );
 
 	} );
@@ -466,35 +445,16 @@ export const traverseBVHShadow = Fn( ( [
 
 			} ).Else( () => {
 
-				// BLAS-pointer leaf (marker -2) — push BLAS root node onto stack
-				// nodeData0: [blasRootNodeIndex, meshIndex, 0, -2]
+				// BLAS-pointer leaf (marker -2) — push BLAS root onto stack if mesh is visible
+				// nodeData0: [blasRootNodeIndex, meshIndex, visibility, -2]
 				const blasRoot = int( nodeData0.x ).toVar();
 
-				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 ) ), () => {
+				If( nodeData0.z.greaterThan( 0.5 ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
 
-						stack.element( stackPtr ).assign( blasRoot );
-						stackPtr.addAssign( 1 );
-
-					} );
+					stack.element( stackPtr ).assign( blasRoot );
+					stackPtr.addAssign( 1 );
 
-				}
+				} );
 
 			} );
 

package/src/TSL/Clearcoat.js

@@ -13,7 +13,7 @@ import {
 	If,
 } from 'three/tsl';
 
-import { struct } from './structProxy.js';
+import { struct } from './patches.js';
 
 import { Ray, HitInfo, RayTracingMaterial, DotProducts } from './Struct.js';
 import { PI, MIN_CLEARCOAT_ROUGHNESS, computeDotProducts } from './Common.js';

package/src/TSL/Displacement.js

@@ -1,6 +1,6 @@
 import { Fn, float, vec2, int, If, Loop, abs, normalize, dot, max } from 'three/tsl';
 
-import { struct } from './structProxy.js';
+import { struct } from './patches.js';
 import { getDatafromStorageBuffer } from './Common.js';
 import { sampleDisplacementMap } from './TextureSampling.js';
 

package/src/TSL/EmissiveSampling.js

@@ -27,7 +27,7 @@ import {
 	atan,
 } from 'three/tsl';
 
-import { struct } from './structProxy.js';
+import { struct } from './patches.js';
 import { MIN_PDF, getDatafromStorageBuffer, powerHeuristic, MATERIAL_SLOTS, MATERIAL_SLOT } from './Common.js';
 import { RandomValue } from './Random.js';
 import { calculateMaterialPDF } from './LightsSampling.js';
@@ -361,8 +361,10 @@ export const calculateEmissiveLightPdf = Fn( ( [
 // ================================================================================
 
 // Binary search in CDF for importance-weighted triangle selection
-// CDF values are stored in the .b channel of the emissive buffer
-const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveTriangleCount, rand ] ) => {
+// CDF values are stored in the .b channel of the emissive buffer.
+// `emissiveOffset` is the vec4-element offset into the packed light buffer
+// where emissive entries start (0 if using a non-packed buffer).
+const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveOffset, emissiveTriangleCount, rand ] ) => {
 
 	const lo = int( 0 ).toVar();
 	const hi = emissiveTriangleCount.sub( 1 ).toVar();
@@ -370,7 +372,7 @@ const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveTriangleCount, r
 	Loop( lo.lessThan( hi ), () => {
 
 		const mid = lo.add( hi ).div( 2 ).toVar();
-		const cdfVal = emissiveTriangleBuffer.element( mid.mul( EMISSIVE_STRIDE ) ).b;
+		const cdfVal = emissiveTriangleBuffer.element( emissiveOffset.add( mid.mul( int( EMISSIVE_STRIDE ) ) ) ).b;
 
 		If( cdfVal.lessThan( rand ), () => {
 
@@ -388,11 +390,13 @@ const binarySearchCDF = Fn( ( [ emissiveTriangleBuffer, emissiveTriangleCount, r
 
 } );
 
-// Sample from emissive triangle index using CDF importance sampling
+// Sample from emissive triangle index using CDF importance sampling.
+// `emissiveTriangleBuffer` may be the shared packed light buffer; `emissiveVec4Offset`
+// gives the vec4 offset where emissive entries begin.
 export const sampleEmissiveTriangle = Fn( ( [
 	hitPoint, surfaceNormal, totalTriangleCount,
 	rngState,
-	emissiveTriangleBuffer, emissiveTriangleCount, emissiveTotalPower,
+	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer,
 ] ) => {
 
@@ -413,12 +417,12 @@ export const sampleEmissiveTriangle = Fn( ( [
 
 		// CDF importance-weighted triangle selection (brighter triangles sampled more)
 		const randEmissive = RandomValue( rngState );
-		const emissiveIndex = binarySearchCDF( emissiveTriangleBuffer, emissiveTriangleCount, randEmissive ).toVar();
+		const emissiveIndex = binarySearchCDF( emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, randEmissive ).toVar();
 
-		// Fetch emissive triangle data from storage buffer (2 vec4s per entry)
+		// Fetch emissive triangle data from packed light buffer (2 vec4s per entry)
 		// vec4[0] = (triangleIndex, power, cdf, selectionPdf)
 		// vec4[1] = (emission.r, emission.g, emission.b, area)
-		const baseIdx = emissiveIndex.mul( EMISSIVE_STRIDE );
+		const baseIdx = emissiveVec4Offset.add( emissiveIndex.mul( int( EMISSIVE_STRIDE ) ) );
 		const emissiveData0 = emissiveTriangleBuffer.element( baseIdx );
 		const emissiveData1 = emissiveTriangleBuffer.element( baseIdx.add( 1 ) );
 		const triangleIndex = int( emissiveData0.r );
@@ -534,7 +538,7 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 	hitPoint, normal, viewDir, material,
 	totalTriangleCount, bounceIndex, rngState,
 	emissiveBoost,
-	emissiveTriangleBuffer, emissiveTriangleCount, emissiveTotalPower,
+	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer,
 	// Callback functions to avoid circular deps
 	traceShadowRayFn,
@@ -557,7 +561,7 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 		// Sample emissive triangle (CDF importance-weighted)
 		const emissiveSample = EmissiveSample.wrap( sampleEmissiveTriangle(
 			hitPoint, normal, totalTriangleCount, rngState,
-			emissiveTriangleBuffer, emissiveTriangleCount, emissiveTotalPower,
+			emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 			triangleBuffer,
 		) );
 
@@ -619,7 +623,7 @@ export const calculateEmissiveTriangleContribution = Fn( ( [
 	hitPoint, normal, viewDir, material,
 	totalTriangleCount, bounceIndex, rngState,
 	emissiveBoost,
-	emissiveTriangleBuffer, emissiveTriangleCount, emissiveTotalPower,
+	emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 	triangleBuffer,
 	traceShadowRayFn,
 	evaluateMaterialResponseFn,
@@ -630,7 +634,7 @@ export const calculateEmissiveTriangleContribution = Fn( ( [
 		hitPoint, normal, viewDir, material,
 		totalTriangleCount, bounceIndex, rngState,
 		emissiveBoost,
-		emissiveTriangleBuffer, emissiveTriangleCount, emissiveTotalPower,
+		emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 		triangleBuffer,
 		traceShadowRayFn,
 		evaluateMaterialResponseFn,

package/src/TSL/Environment.js

@@ -82,8 +82,7 @@ export const sampleEquirect = Fn( ( [ environment, direction, environmentMatrix,
 // Exact implementation from three-gpu-pathtracer
 export const sampleEquirectProbability = Fn( ( [
 	environment,
-	envMarginalWeights,
-	envConditionalWeights,
+	envCDFBuffer,
 	environmentMatrix,
 	environmentIntensity,
 	envTotalSum,
@@ -92,15 +91,19 @@ export const sampleEquirectProbability = Fn( ( [
 	colorOutput
 ] ) => {
 
-	// Sample marginal CDF for V coordinate (1D storage buffer, linear interpolation)
+	// Packed CDF layout: [marginal (envResolution.y floats) | conditional (envResolution.x * envResolution.y floats)]
+	// The conditional offset equals the marginal length, which is envResolution.y.
+	const condOffset = int( envResolution.y ).toVar();
+
+	// Sample marginal CDF for V coordinate (1D, linear interpolation)
 	const marginalSize = envResolution.y;
 	const mIdx = clamp( r.x.mul( marginalSize.sub( 1.0 ) ), 0.0, marginalSize.sub( 1.0 ) );
 	const mI0 = int( floor( mIdx ) );
 	const mI1 = min( mI0.add( 1 ), int( marginalSize ).sub( 1 ) );
 	const mFrac = fract( mIdx );
-	const v = mix( envMarginalWeights.element( mI0 ), envMarginalWeights.element( mI1 ), mFrac ).toVar();
+	const v = mix( envCDFBuffer.element( mI0 ), envCDFBuffer.element( mI1 ), mFrac ).toVar();
 
-	// Sample conditional CDF for U coordinate (2D storage buffer, bilinear interpolation)
+	// Sample conditional CDF for U coordinate (2D grid, bilinear interpolation)
 	const condW = envResolution.x;
 	const condH = envResolution.y;
 	const cxf = clamp( r.y.mul( condW.sub( 1.0 ) ), 0.0, condW.sub( 1.0 ) );
@@ -112,10 +115,10 @@ export const sampleEquirectProbability = Fn( ( [
 	const fx = fract( cxf );
 	const fy = fract( cyf );
 	const condWi = int( condW );
-	const v00 = envConditionalWeights.element( cy0.mul( condWi ).add( cx0 ) );
-	const v10 = envConditionalWeights.element( cy0.mul( condWi ).add( cx1 ) );
-	const v01 = envConditionalWeights.element( cy1.mul( condWi ).add( cx0 ) );
-	const v11 = envConditionalWeights.element( cy1.mul( condWi ).add( cx1 ) );
+	const v00 = envCDFBuffer.element( condOffset.add( cy0.mul( condWi ).add( cx0 ) ) );
+	const v10 = envCDFBuffer.element( condOffset.add( cy0.mul( condWi ).add( cx1 ) ) );
+	const v01 = envCDFBuffer.element( condOffset.add( cy1.mul( condWi ).add( cx0 ) ) );
+	const v11 = envCDFBuffer.element( condOffset.add( cy1.mul( condWi ).add( cx1 ) ) );
 	const u = mix( mix( v00, v10, fx ), mix( v01, v11, fx ), fy ).toVar();
 
 	const uv = vec2( u, v ).toVar();

package/src/TSL/LightBVHSampling.js

@@ -53,6 +53,7 @@ export const sampleLightBVHTriangle = Fn( ( [
 	rngState,
 	lbvhBuffer,
 	emissiveTriangleBuffer,
+	emissiveVec4Offset,
 	triangleBuffer,
 ] ) => {
 
@@ -185,7 +186,7 @@ export const sampleLightBVHTriangle = Fn( ( [
 		Loop( { start: int( 0 ), end: emissiveCount }, ( { i } ) => {
 
 			const entryIdx = emissiveStart.add( i );
-			const baseIdx = entryIdx.mul( int( EMISSIVE_STRIDE ) );
+			const baseIdx = emissiveVec4Offset.add( entryIdx.mul( int( EMISSIVE_STRIDE ) ) );
 			const emData0 = emissiveTriangleBuffer.element( baseIdx );
 			const triPower = max( emData0.g, float( 0.0 ) );
 			cumPower.addAssign( triPower );
@@ -204,7 +205,7 @@ export const sampleLightBVHTriangle = Fn( ( [
 		selectionPdf.mulAssign( selectedPower.div( leafTotalPower ) );
 
 		// Now sample the selected triangle (same path as flat CDF sampling)
-		const baseIdx = selectedEmissiveIndex.mul( int( EMISSIVE_STRIDE ) );
+		const baseIdx = emissiveVec4Offset.add( selectedEmissiveIndex.mul( int( EMISSIVE_STRIDE ) ) );
 		const emissiveData0 = emissiveTriangleBuffer.element( baseIdx );
 		const emissiveData1 = emissiveTriangleBuffer.element( baseIdx.add( int( 1 ) ) );
 

package/src/TSL/LightsCore.js

@@ -13,7 +13,7 @@ import {
 	abs,
 } from 'three/tsl';
 
-import { struct } from './structProxy.js';
+import { struct } from './patches.js';
 
 // ================================================================================
 // LIGHT STRUCTURES

package/src/TSL/LightsDirect.js

@@ -41,7 +41,7 @@ import { RandomValue } from './Random.js';
 import { getTransformedUV } from './TextureSampling.js';
 
 // Module-level state for alpha-cutout shadow testing.
-// Set by ShaderBuilder before graph construction (same pattern as _meshVisibilityBuffer in BVHTraversal.js).
+// Set by ShaderBuilder before graph construction.
 let _shadowAlbedoMaps = null;
 let _enableAlphaShadows = null;
 
@@ -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/LightsIndirect.js

@@ -273,7 +273,6 @@ export const calculateIndirectLighting = Fn( ( [
 	samplingInfo,
 	// Environment resources
 	envTexture, environmentIntensity, envMatrix,
-	envMarginalWeights, envConditionalWeights,
 	envTotalSum, envResolution,
 	enableEnvironmentLight, useEnvMapIS,
 ] ) => {

package/src/TSL/LightsSampling.js

@@ -934,7 +934,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 	materialBuffer,
 	// Environment resources
 	envTexture, environmentIntensity, envMatrix,
-	envMarginalWeights, envConditionalWeights,
+	envCDFBuffer,
 	envTotalSum, envResolution,
 	enableEnvironmentLight,
 ] ) => {
@@ -1203,7 +1203,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 			// Sample direction + PDF + color from importance-sampled environment
 			const envSampleResult = sampleEquirectProbability(
-				envTexture, envMarginalWeights, envConditionalWeights,
+				envTexture, envCDFBuffer,
 				envMatrix, environmentIntensity, envTotalSum, envResolution, envRandom, envColor
 			).toVar();