rayzee 5.3.8 → 5.4.1

package/src/Stages/NormalDepth.js

@@ -352,7 +352,7 @@ export class NormalDepth extends RenderStage {
 		this._dispatchY = Math.ceil( height / 8 );
 		if ( this._computeNode ) {
 
-			this._computeNode.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
+			this._computeNode.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
 
 		}
 

package/src/Stages/PathTracer.js

@@ -180,17 +180,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 +457,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 +772,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 ) {
+
+		this._instanceTable = instanceTable;
+
+	}
 
-		if ( ! meshes || meshes.length === 0 ) return;
+	/**
+	 * 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 ) {
 
-		const meshCount = meshes.length;
-		// One vec4 per mesh — visibility stored in .x (simple indexing on GPU)
-		const data = new Float32Array( meshCount * 4 );
+		if ( ! meshes || meshes.length === 0 || ! this._instanceTable ) return;
 
-		for ( let i = 0; i < meshCount; i ++ ) {
+		for ( let i = 0; i < meshes.length; i ++ ) {
 
-			data[ i * 4 ] = this._isWorldVisible( meshes[ i ] ) ? 1.0 : 0.0;
+			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;
 
 	}
 
@@ -1135,9 +1156,6 @@ export class PathTracer extends RenderStage {
 		// Update frame uniform
 		this.frame.value = frameValue;
 
-		// Force-compile compute nodes on first frame
-		this.shaderBuilder.forceCompile( this.renderer );
-
 		// Set dispatch region — tile-only dispatch for tiled mode, full-screen otherwise
 		if ( tileInfo.tileIndex >= 0 && tileInfo.tileBounds ) {
 
@@ -1496,18 +1514,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;
 
-		const vec4Count = emissiveData.length / 4;
+		// 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.emissiveTriangleStorageAttr = new StorageInstancedBufferAttribute( emissiveData, 4 );
-		this.emissiveTriangleStorageNode.value = this.emissiveTriangleStorageAttr;
-		this.emissiveTriangleStorageNode.bufferCount = vec4Count;
+		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;
+
+	}
+
+	setEmissiveTriangleData( emissiveData, count, totalPower = 0 ) {
+
+		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)` );
 
 	}
@@ -1516,11 +1559,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` );
 
 	}
@@ -1616,6 +1657,7 @@ export class PathTracer extends RenderStage {
 		this.materialData?.dispose();
 		this.environment?.dispose();
 		this.shaderBuilder?.dispose();
+		this.uniforms?.dispose();
 
 		// Dispose storage textures
 		this.storageTextures?.dispose();

package/src/Stages/SSRC.js

@@ -175,10 +175,10 @@ export class SSRC extends RenderStage {
 		this._dispatchX = Math.ceil( width / 8 );
 		this._dispatchY = Math.ceil( height / 8 );
 
-		const count = [ this._dispatchX, this._dispatchY, 1 ];
-		if ( this._pass1NodeA ) this._pass1NodeA.setCount( count );
-		if ( this._pass1NodeB ) this._pass1NodeB.setCount( count );
-		if ( this._pass2Node ) this._pass2Node.setCount( count );
+		const dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
+		if ( this._pass1NodeA ) this._pass1NodeA.dispatchSize = dispatchSize;
+		if ( this._pass1NodeB ) this._pass1NodeB.dispatchSize = dispatchSize;
+		if ( this._pass2Node ) this._pass2Node.dispatchSize = dispatchSize;
 
 		this._resetCache();
 

package/src/Stages/Variance.js

@@ -360,8 +360,8 @@ export class Variance extends RenderStage {
 		// Update dispatch dimensions
 		this._dispatchX = Math.ceil( width / 8 );
 		this._dispatchY = Math.ceil( height / 8 );
-		this._computeNodeA.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
-		this._computeNodeB.setCount( [ this._dispatchX, this._dispatchY, 1 ] );
+		this._computeNodeA.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
+		this._computeNodeB.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
 
 	}
 

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)
@@ -276,35 +265,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 );
-
-					} );
-
-				} else {
-
-					// No visibility buffer — push unconditionally (original behavior)
-					If( 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 ) ) ), () => {
 
-					} );
+					stack.element( stackPtr ).assign( blasRoot );
+					stackPtr.addAssign( 1 );
 
-				}
+				} );
 
 			} );
 
@@ -466,35 +437,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 {
+				If( nodeData0.z.greaterThan( 0.5 ).and( stackPtr.lessThan( int( MAX_STACK_DEPTH ) ) ), () => {
 
-					// 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 );
 
-				}
+				} );
 
 			} );
 

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;
 

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();
 

package/src/TSL/MaterialTransmission.js

@@ -30,7 +30,7 @@ import {
 	fract,
 } from 'three/tsl';
 
-import { struct } from './structProxy.js';
+import { struct } from './patches.js';
 import { Ray, RayTracingMaterial, RenderState, HitInfo, DotProducts, DirectionSample } from './Struct.js';
 import { PI, EPSILON, MIN_ROUGHNESS, MIN_CLEARCOAT_ROUGHNESS, computeDotProducts } from './Common.js';
 import { iorToFresnel0, fresnelSchlickFloat } from './Fresnel.js';

package/src/TSL/PathTracer.js

@@ -137,14 +137,14 @@ export const pathTracerMain = ( params ) => {
 		pointLightsBuffer, numPointLights,
 		spotLightsBuffer, numSpotLights,
 		envTexture, environmentIntensity, envMatrix,
-		envMarginalWeights, envConditionalWeights,
+		envCDFBuffer,
 		envTotalSum, envResolution,
 		enableEnvironmentLight, useEnvMapIS,
 		maxBounceCount, transmissiveBounces,
 		showBackground, transparentBackground, backgroundIntensity,
 		fireflyThreshold, globalIlluminationIntensity,
 		totalTriangleCount, enableEmissiveTriangleSampling,
-		emissiveTriangleBuffer, emissiveTriangleCount, emissiveTotalPower, emissiveBoost,
+		emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower, emissiveBoost,
 		lightBVHBuffer, lightBVHNodeCount,
 		debugVisScale,
 		enableAccumulation, hasPreviousAccumulated,
@@ -284,14 +284,14 @@ export const pathTracerMain = ( params ) => {
 				pointLightsBuffer, numPointLights,
 				spotLightsBuffer, numSpotLights,
 				envTexture, environmentIntensity, envMatrix,
-				envMarginalWeights, envConditionalWeights,
+				envCDFBuffer,
 				envTotalSum, envResolution,
 				enableEnvironmentLight, useEnvMapIS,
 				maxBounceCount, transmissiveBounces,
 				backgroundIntensity, showBackground, transparentBackground,
 				fireflyThreshold, globalIlluminationIntensity,
 				totalTriangleCount, enableEmissiveTriangleSampling,
-				emissiveTriangleBuffer, emissiveTriangleCount, emissiveTotalPower, emissiveBoost,
+				emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower, emissiveBoost,
 				lightBVHBuffer, lightBVHNodeCount,
 				pixelCoord, resolution, frame,
 			) );